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

Go to the documentation of this file.

/*
    Copyright (C) 2010 - 2019 Christoph Haenisch

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

    See license.txt for more information.

    Version 0.4.0 (2019-06-24)
*/

#ifndef ITERATOR_HPP_3437312701
#define ITERATOR_HPP_3437312701


#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <typeinfo>


namespace TRTK
{


//                              Iterator                              //


/* Forward declarations */

template <class T>
class Iterator;

template <class T>
unsigned long distance(Iterator<T> first, Iterator<T> last);


template <class T>
class Iterator : public std::iterator<std::input_iterator_tag, T>
{
protected:
    typedef void (Iterator<T>::*bool_type)() const; 
    void safe_bool_idiom_helper_function() const; 

public:
    Iterator();
    Iterator(const Iterator<T> & other);
    virtual ~Iterator();

    virtual Iterator & operator=(const Iterator<T> & other);
    virtual T operator*() const;
    virtual Iterator & operator++();
    virtual Iterator operator++(int);
    virtual bool operator==(const Iterator<T> & other) const;
    virtual bool operator!=(const Iterator<T> & other) const;
    virtual operator bool_type() const; // safe bool idiom

    virtual bool isValid() const;
    const Iterator & getIterator() const;

    friend unsigned long distance<T>(Iterator<T> first, Iterator<T> last);

protected:
    virtual Iterator * clone() const;
    virtual unsigned long distance(const Iterator<T> & other) const;

private:
    Iterator<T> * iterator; // is always a clone of a derived iterator (or NULL)
    const char * error_message;
};


template <class T>
Iterator<T>::Iterator() : iterator(NULL), error_message("Iterator<T>: Operation on uninitialized instance.")
{
}


template <class T>
Iterator<T>::Iterator(const Iterator<T> & other) : error_message("Iterator<T>: Operation on uninitialized instance.")
{
    iterator = other.clone();
}


template <class T>
Iterator<T>::~Iterator()
{
    if (iterator) delete iterator;
}


template <class T>
Iterator<T> & Iterator<T>::operator=(const Iterator<T> & other)
{
    if (&other == this) return *this; // case it = it

    if (iterator) delete iterator;
    iterator = other.clone();

    return *this;
}


template <class T>
T Iterator<T>::operator*() const
{
    if (iterator)
    {
        return iterator->operator*();
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


template <class T>
Iterator<T> & Iterator<T>::operator++()
{
    if (iterator)
    {
        return iterator->operator++();
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


template <class T>
Iterator<T> Iterator<T>::operator++(int)
{
    if (iterator)
    {
        return iterator->operator++(0);
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


template <class T>
bool Iterator<T>::operator==(const Iterator<T> & other) const
{
    if (iterator)
    {
        return iterator->operator==(other);
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


template <class T>
bool Iterator<T>::operator!=(const Iterator<T> & other) const
{
    if (iterator)
    {
        return iterator->operator!=(other);
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


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


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


template <class T>
Iterator<T> * Iterator<T>::clone() const
{
    if (iterator == NULL)
    {
        return NULL;
    }
    else
    {
        return iterator->clone();
    }
}


template <class T>
const Iterator<T> & Iterator<T>::getIterator() const
{
    return *iterator;
}


template <class T>
bool Iterator<T>::isValid() const
{
    return iterator != NULL;
}


template <class T>
unsigned long Iterator<T>::distance(const Iterator<T> & other) const
{
    if (iterator)
    {
        return iterator->distance(other);
    }
    else
    {
        throw std::runtime_error(error_message);
    }
}


template <class T>
unsigned long distance(const Iterator<T> first, Iterator<T> last) // friend function
{
    return first.distance(last);
}


//                          IteratorAdaptor                           //


/* Forward declarations */

template <class T, class InputIterator>
class IteratorAdapter;

template <class T, class InputIterator>
unsigned long distance(IteratorAdapter<T, InputIterator> first, IteratorAdapter<T, InputIterator> last);


template <class T, class InputIterator>
class IteratorAdapter : public Iterator<T>
{
protected:
    typedef Iterator<T> super;

public:
    IteratorAdapter();
    IteratorAdapter(InputIterator iterator);
    IteratorAdapter(const IteratorAdapter<T, InputIterator> & other);
    ~IteratorAdapter();

    IteratorAdapter & operator=(const Iterator<T> & other);
    IteratorAdapter & operator=(const IteratorAdapter<T, InputIterator> & other);
    T operator*() const;
    Iterator<T> & operator++();
    Iterator<T> operator++(int);
    bool operator==(const Iterator<T> & other) const;
    bool operator!=(const Iterator<T> & other) const;
    operator typename Iterator<T>::bool_type() const;

    bool isValid() const;

    friend unsigned long TRTK::distance<T, InputIterator>(IteratorAdapter<T, InputIterator> first, IteratorAdapter<T, InputIterator> last);

protected:
    Iterator<T> * clone() const;
    unsigned long distance(const Iterator<T> & other) const;

private:
    InputIterator iterator;
    bool valid;
};


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator>::IteratorAdapter() : iterator(InputIterator()), valid(false)
{
}


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator>::IteratorAdapter(InputIterator iterator) : iterator(iterator), valid(true)
{
}


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator>::IteratorAdapter(const IteratorAdapter<T, InputIterator> & other) : iterator(other.iterator), valid(other.valid)
{
}


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator>::~IteratorAdapter()
{
}


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator> & IteratorAdapter<T, InputIterator>::operator=(const Iterator<T> & other)
{
    // The case it = it is handled in the overloaded function below.

    try
    {
        // Is 'other.iterator' of type 'IteratorAdapter'?
        const IteratorAdapter<T, InputIterator> & iteratorAdapter = dynamic_cast<const IteratorAdapter<T, InputIterator> &>(other.getIterator());
        iterator = iteratorAdapter.iterator;
        valid = iteratorAdapter.valid;
    }
    catch (std::bad_cast &)
    {
        throw std::runtime_error("IteratorAdapter: Iterator types do not match");
    }

    return *this;
}


template <class T, class InputIterator>
IteratorAdapter<T, InputIterator> & IteratorAdapter<T, InputIterator>::operator=(const IteratorAdapter<T, InputIterator> & other)
{
    if (&other == this) return *this; // case it = it

    iterator = other.iterator;
    valid = other.valid;
    return *this;
}


template <class T, class InputIterator>
T IteratorAdapter<T, InputIterator>::operator*() const
{
    return *iterator;
}


template <class T, class InputIterator>
Iterator<T> & IteratorAdapter<T, InputIterator>::operator++()
{
    ++iterator;
    return *this;
}


template <class T, class InputIterator>
Iterator<T> IteratorAdapter<T, InputIterator>::operator++(int)
{
    Iterator<T> temporary_iterator = *this;
    ++iterator;
    return temporary_iterator;
}


template <class T, class InputIterator>
bool IteratorAdapter<T, InputIterator>::operator==(const Iterator<T> & other) const
{
    try
    {
        // Is 'other' of type 'IteratorAdapter'?
        const IteratorAdapter<T, InputIterator> & iteratorAdapter = dynamic_cast<const IteratorAdapter<T, InputIterator> &>(other);
        return this->iterator == iteratorAdapter.iterator;
    }
    catch (std::bad_cast &)
    {
        // 'other' might be of type 'Iterator<T>'. So is 'other.iterator' of type 'IteratorAdapter'?
        try
        {
            const IteratorAdapter<T, InputIterator> & iteratorAdapter = dynamic_cast<const IteratorAdapter<T, InputIterator> &>(other.getIterator());
            return this->iterator == iteratorAdapter.iterator;
        }
        catch (std::bad_cast &)
        {
            throw std::runtime_error("IteratorAdapter: Iterator types do not match");
        }
    }
}


template <class T, class InputIterator>
bool IteratorAdapter<T, InputIterator>::operator!=(const Iterator<T> & other) const
{
    return !this->operator==(other);
}


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


template <class T, class InputIterator>
Iterator<T> * IteratorAdapter<T, InputIterator>::clone() const
{
    return new IteratorAdapter<T, InputIterator>(iterator);
}


template <class T, class InputIterator>
unsigned long IteratorAdapter<T, InputIterator>::distance(const Iterator<T> & other) const
{
    using std::distance;

    try
    {
        // Is 'other' of type 'IteratorAdapter'?
        const IteratorAdapter<T, InputIterator> & iteratorAdapter = dynamic_cast<const IteratorAdapter<T, InputIterator> &>(other);
        return (unsigned long ) distance(iterator, iteratorAdapter.iterator);
    }
    catch (std::bad_cast &)
    {
        // 'other' might be of type 'Iterator<T>'. So is 'other.iterator' of type 'IteratorAdapter'?
        try
        {
            const IteratorAdapter<T, InputIterator> & iteratorAdapter = dynamic_cast<const IteratorAdapter<T, InputIterator> &>(other.getIterator());
            return (unsigned long) distance(iterator, iteratorAdapter.iterator);
        }
        catch (std::bad_cast &)
        {
            throw std::runtime_error("IteratorAdapter: Iterator types do not match");
        }
    }
}


template <class T, class InputIterator>
bool IteratorAdapter<T, InputIterator>::isValid() const
{
    return valid;
}


template <class T, class InputIterator>
unsigned long distance(IteratorAdapter<T, InputIterator> first, IteratorAdapter<T, InputIterator> last) // friend function
{
    using std::distance;
    return distance(first.iterator, last.iterator);
}


template <class InputIterator>
Iterator<typename InputIterator::value_type> make_iterator(InputIterator iterator)
{
    return IteratorAdapter<typename InputIterator::value_type, InputIterator>(iterator);
}


} // namespace TRTK


#endif // ITERATOR_HPP_3437312701