general_iterator.hh

Go to the documentation of this file.

// --------------------------------------------------- GeneralIterator ---------------------------------
/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * 
 * @file    general_iterator.hh
 * @brief   Template Iter serves as general template for internal iterators.
 */

#ifndef GENERAL_ITERATOR_HH_
#define GENERAL_ITERATOR_HH_

/** @brief General iterator template.
 * Provides iterator over objects of type Object in some container.
 *
 * Operators '*' and '->' returns objects of type ObjectOut
 * 
 * Requires the template object to implement:
 * - comparison operator==()
 * - increment operator++()
 */
template<class Object>
class Iter
{
public:
//     IterConvert();

    Iter(const Object& object);

    /// equal operator
    bool operator==(const Iter& other);
    /// non-equal operator
    bool operator!=(const Iter& other);

    ///  * dereference operator
    const Object& operator*() const;

    /// -> dereference operator
    const Object* operator->() const;

    /// prefix increment
    Iter& operator++();

protected:
    Object object_;
};


/** @brief General iterator template.
 * Provides iterator over objects of type ObjectIn in some container.
 * Same as previous but allows conversion of output to type ObjectOut.
 */
template<class ObjectIn, class ObjectOut>
class IterConvert : public Iter<ObjectIn>
{
public:
//     IterConvert();

    IterConvert(const ObjectIn& object);

    ///  * dereference operator
    const ObjectOut& operator*() const;

    /// -> dereference operator
    const ObjectOut* operator->() const;

private:
    mutable ObjectOut out_;
};


/**
 * Create iterator from object
 */
template<class Object>
Iter<Object> make_iter(Object obj) {
    return Iter<Object>(obj);
}

/**
 * Create convertible iterator from object
 */
template<class ObjectIn, class ObjectOut>
IterConvert<ObjectIn, ObjectOut> make_iter(ObjectIn obj) {
    return IterConvert<ObjectIn, ObjectOut>(obj);
}


// --------------------------------------------------- Iter INLINE implementation -----------
// inline IterConvert::IterConvert()
// {}

template<class Object>
inline Iter<Object>::Iter(const Object& object)
: object_(object)
{}

template<class Object>
inline bool Iter<Object>::operator==(const Iter& other)
{
    return (object_ == other.object_);
}

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

template<class Object>
inline const Object& Iter<Object>::operator*() const
{
    return object_;
}

template<class Object>
inline const Object* Iter<Object>::operator->() const
{
    return &object_;
}

template<class Object>
inline Iter<Object>& Iter<Object>::operator++()
{
    object_.inc();
    return (*this);
}

template<class ObjectIn, class ObjectOut>
inline IterConvert<ObjectIn, ObjectOut>::IterConvert(const ObjectIn& object)
: Iter<ObjectIn>(object)
{}

template<class ObjectIn, class ObjectOut>
inline const ObjectOut& IterConvert<ObjectIn, ObjectOut>::operator*() const
{
    out_ = (ObjectOut)this->object_;
    return out_;
}

template<class ObjectIn, class ObjectOut>
inline const ObjectOut* IterConvert<ObjectIn, ObjectOut>::operator->() const
{
    out_ = (ObjectOut)this->object_;
    return &out_;
}

#endif // GENERAL_ITERATOR_HH_