D:/Programmierung/C/TRTK/include/TRTK/Range.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2010 - 2014, 2019 Christoph Hänisch

    Chair of Medical Engineering (mediTEC)
    RWTH Aachen University
    Pauwelsstr. 20
    52074 Aachen
    Germany

    See license.txt for more information.

    Version 0.1.2 (2019-05-21)
*/

#ifndef RANGE_HPP_7631082974
#define RANGE_HPP_7631082974


#include "Iterator.hpp"


namespace TRTK
{


//                               Range                                //


template <class T>
class Range
{
private:

    typedef void (Range<T>::*bool_type)() const; 
    void safe_bool_idiom_helper_function() const; 

public:

    Range();
    Range(const Iterator<T> & begin, const Iterator<T> & end);
    Range(const Range<T> & other);
    virtual ~Range();

    Range<T> & operator=(const Range<T> & other);
    bool operator==(const Range<T> & other) const;
    bool operator!=(const Range<T> & other) const;
    operator bool_type() const; // safe bool idiom

    Iterator<T> begin() const;
    Iterator<T> end() const;

    bool isValid() const;
    bool isEmpty() const;

    void first() const;
    bool isDone() const;
    void next() const;
    T currentItem() const;

    size_t size() const;

    typedef Iterator<T> const_iterator;

private:

    Iterator<T> m_begin;
    Iterator<T> m_end;
    mutable Iterator<T> m_current;
};


template <class T>
Range<T>::Range()
{
}


template <class T>
Range<T>::Range(const Range<T> & other) : m_begin(other.m_begin), m_end(other.m_end), m_current(other.m_begin)
{
}


template <class T>
Range<T>::Range(const Iterator<T> & begin, const Iterator<T> & end) : m_begin(begin), m_end(end), m_current(begin)
{
}


template <class T>
Range<T>::~Range()
{
}


template <class T>
Range<T> & Range<T>::operator=(const Range<T> & other)
{
    if (this == &other) return *this;

    m_begin = other.m_begin;
    m_end = other.m_end;
    m_current = other.m_begin;

    return *this;
}


template <class T>
bool Range<T>::operator==(const Range<T> & other) const
{
    if (isValid() && other.isValid())
    {
        return (m_begin == other.m_begin) && (m_end == other.m_end);
    }
    else if (!m_begin.isValid() && !other.begin().isValid() && !m_end.isValid() && !other.end().isValid())
    {
        return true;
    }
    else
    {
        return false;
    }
}


template <class T>
bool Range<T>::operator!=(const Range<T> & other) const
{
    return !(*this == other);
}


template <class T>
Range<T>::operator typename Range<T>::bool_type() const // safe bool idiom
{
    return isValid() ? &Range<T>::safe_bool_idiom_helper_function : NULL;
}


template <class T>
void Range<T>::safe_bool_idiom_helper_function() const
{
}


template <class T>
Iterator<T> Range<T>::begin() const
{
    return m_begin;
}


template <class T>
T Range<T>::currentItem() const
{
    if (m_begin && m_end)
    {
        if (m_current != m_end)
        {
            return *m_current;
        }
        else
        {
            throw std::range_error("Range<T>::next(): The last element was already reached.");
        }
    }
    else
    {
        throw std::range_error("Range<T>::next(): This instance does not reference any iterators.");
    }
}


template <class T>
Iterator<T> Range<T>::end() const
{
    return m_end;
}


template <class T>
void Range<T>::first() const
{
    m_current = m_begin;
}


template <class T>
bool Range<T>::isDone() const
{
    if (m_begin && m_end)
    {
        return m_current == m_end;
    }
    else
    {
        return true;
    }
}


template <class T>
bool Range<T>::isEmpty() const
{
    if (m_begin && m_end)
    {
        return m_begin == m_end;
    }
    else
    {
        return true;
    }
}


template <class T>
bool Range<T>::isValid() const
{
    return m_begin.isValid() && m_end.isValid();
}


template <class T>
void Range<T>::next() const
{
    if (m_begin && m_end)
    {
        if (m_current != m_end)
        {
            ++m_current;
        }
        else
        {
            throw std::range_error("Range<T>::next(): The last element was already reached.");
        }
    }
    else
    {
        throw std::range_error("Range<T>::next(): This instance does not reference any iterators.");
    }
}


template <class T>
size_t Range<T>::size() const
{
    if (m_begin && m_end)
    {
        return distance(m_begin, m_end);
    }
    else
    {
        return 0;
    }
}


template <class Sequence>
Range<typename Sequence::value_type> make_range(const Sequence & sequence)
{
    typedef typename Sequence::value_type T; // TODO: in C++11 second template parameter class T = Sequence::value_type
    const Iterator<T> & begin = IteratorAdapter<T, typename Sequence::const_iterator>(sequence.begin());
    const Iterator<T> & end = IteratorAdapter<T, typename Sequence::const_iterator>(sequence.end());
    return Range<T>(begin, end);
}


} // namespace TRTK


#endif // RANGE_HPP_7631082974