IndirectArray.hpp

Go to the documentation of this file.

/* 
 * IndirectArray.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_UTIL_INDIRECTARRAY_HPP
#define CDPL_UTIL_INDIRECTARRAY_HPP
 
#include <type_traits>
 
#include <boost/iterator/transform_iterator.hpp>
 
#include "CDPL/Util/Dereferencer.hpp"
#include "CDPL/Util/Array.hpp"
 
 
namespace CDPL
{
 
    namespace Util
    {
 
        template <typename ValueType, typename PointerType = typename ValueType::SharedPointer, bool NullPointerCheck = true>
        class IndirectArray : public Array<PointerType>
        {
 
            typedef typename std::conditional<NullPointerCheck,
                                              NullCheckDereferencer<PointerType, ValueType&>,
                                              Dereferencer<PointerType, ValueType&> >::type DerefFunc;
 
          public:
            typedef Array<PointerType> BaseType;
 
            typedef ValueType ElementType;
 
            typedef std::shared_ptr<IndirectArray> SharedPointer;
 
            typedef boost::transform_iterator<DerefFunc, typename BaseType::ConstElementIterator,
                                              const ValueType&>
                ConstElementIterator;
 
            typedef boost::transform_iterator<DerefFunc, typename BaseType::ConstReverseElementIterator,
                                              const ValueType&>
                ConstReverseElementIterator;
 
            typedef boost::transform_iterator<DerefFunc, typename BaseType::ElementIterator,
                                              ValueType&>
                ElementIterator;
 
            typedef boost::transform_iterator<DerefFunc, typename BaseType::ReverseElementIterator,
                                              ValueType&>
                ReverseElementIterator;
            IndirectArray():
                BaseType() {}
 
            IndirectArray(std::size_t num_elem, const PointerType& ptr = PointerType()):
                BaseType(num_elem, ptr) {}
 
            template <typename InputIter>
            IndirectArray(const InputIter& first, const InputIter& last):
                BaseType(first, last)
            {}
 
            virtual ~IndirectArray() {}
 
            using BaseType::insertElement;
 
            ElementIterator insertElement(const ElementIterator& it, const PointerType& ptr);
 
            using BaseType::insertElements;
 
            void insertElements(const ElementIterator& it, std::size_t num_elem, const PointerType& ptr);
 
            template <typename InputIter>
            void insertElements(const ElementIterator& it, const InputIter& first, const InputIter& last);
 
            using BaseType::removeElement;
 
            ElementIterator removeElement(const ElementIterator& it);
 
            using BaseType::removeElements;
 
            ElementIterator removeElements(const ElementIterator& first, const ElementIterator& last);
 
            const ValueType& getFirstElement() const;
 
            const ValueType& getLastElement() const;
 
            ValueType& getFirstElement();
 
            ValueType& getLastElement();
 
            ConstElementIterator getElementsBegin() const;
 
            ElementIterator getElementsBegin();
 
            ConstElementIterator getElementsEnd() const;
 
            ElementIterator getElementsEnd();
 
            ConstElementIterator begin() const;
 
            ElementIterator begin();
 
            ConstElementIterator end() const;
 
            ElementIterator end();
 
            ConstReverseElementIterator getElementsReverseBegin() const;
 
            ReverseElementIterator getElementsReverseBegin();
 
            ConstReverseElementIterator getElementsReverseEnd() const;
 
            ReverseElementIterator getElementsReverseEnd();
 
            const ValueType& getElement(std::size_t idx) const;
 
            ValueType& getElement(std::size_t idx);
 
            const ValueType& operator[](std::size_t idx) const;
 
            ValueType& operator[](std::size_t idx);
 
          private:
            virtual const char* getClassName() const;
 
            DerefFunc dereferencer;
        };
    } // namespace Util
} // namespace CDPL
 
 
// Implementation of IndirectArray<>
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::insertElement(const ElementIterator& it, const PointerType& ptr)
{
    return ElementIterator(Array<PointerType>::insertElement(it.base(), ptr));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
void CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::insertElements(const ElementIterator& it, std::size_t n,
                                                                                         const PointerType& ptr)
{
    Array<PointerType>::insertElements(it.base(), n, ptr);
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
template <typename InputIter>
void CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::insertElements(const ElementIterator& it, const InputIter& first,
                                                                                         const InputIter& last)
{
    Array<PointerType>::insertElements(it.base(), first, last);
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::removeElement(const ElementIterator& it)
{
    return ElementIterator(Array<PointerType>::removeElement(it.base()));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::removeElements(const ElementIterator& first, const ElementIterator& last)
{
    return ElementIterator(Array<PointerType>::removeElements(first.base(), last.base()));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
const ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getFirstElement() const
{
    return dereferencer(Array<PointerType>::getFirstElement());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
const ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getLastElement() const
{
    return dereferencer(Array<PointerType>::getLastElement());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getFirstElement()
{
    return dereferencer(Array<PointerType>::getFirstElement());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getLastElement()
{
    return dereferencer(Array<PointerType>::getLastElement());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsBegin() const
{
    return ConstElementIterator(Array<PointerType>::getElementsBegin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsBegin()
{
    return ElementIterator(Array<PointerType>::getElementsBegin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsEnd() const
{
    return ConstElementIterator(Array<PointerType>::getElementsEnd());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsEnd()
{
    return ElementIterator(Array<PointerType>::getElementsEnd());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::begin() const
{
    return ConstElementIterator(Array<PointerType>::begin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::begin()
{
    return ElementIterator(Array<PointerType>::begin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::end() const
{
    return ConstElementIterator(Array<PointerType>::end());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::end()
{
    return ElementIterator(Array<PointerType>::end());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstReverseElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsReverseBegin() const
{
    return ConstReverseElementIterator(Array<PointerType>::getElementsReverseBegin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ReverseElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsReverseBegin()
{
    return ReverseElementIterator(Array<PointerType>::getElementsReverseBegin());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ConstReverseElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsReverseEnd() const
{
    return ConstReverseElementIterator(Array<PointerType>::getElementsReverseEnd());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
typename CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::ReverseElementIterator
CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElementsReverseEnd()
{
    return ReverseElementIterator(Array<PointerType>::getElementsReverseEnd());
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
const ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElement(std::size_t idx) const
{
    return dereferencer(Array<PointerType>::getElement(idx));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getElement(std::size_t idx)
{
    return dereferencer(Array<PointerType>::getElement(idx));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
const ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::operator[](std::size_t idx) const
{
    return dereferencer(Array<PointerType>::operator[](idx));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
ValueType& CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::operator[](std::size_t idx)
{
    return dereferencer(Array<PointerType>::operator[](idx));
}
 
template <typename ValueType, typename PointerType, bool NullPointerCheck>
const char* CDPL::Util::IndirectArray<ValueType, PointerType, NullPointerCheck>::getClassName() const
{
    return "IndirectArray";
}
 
#endif // CDPL_UTIL_INDIRECTARRAY_HPP