Array.hpp

Go to the documentation of this file.

/* 
 * Array.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_ARRAY_HPP
#define CDPL_UTIL_ARRAY_HPP
 
#include <vector>
#include <string>
#include <cstddef>
#include <utility>
#include <memory>
 
#include "CDPL/Base/Exceptions.hpp"
#include "CDPL/Util/BitSet.hpp"
 
#ifndef CDPL_UTIL_ARRAY_CHECK_INDEX
# ifdef CDPL_UTIL_ARRAY_CHECKS_DISABLE
#  define CDPL_UTIL_ARRAY_CHECK_INDEX(idx, allow_end)
# else // !CDPL_UTIL_ARRAY_CHECKS_DISABLE
#  define CDPL_UTIL_ARRAY_CHECK_INDEX(idx, allow_end) checkIndex(idx, allow_end)
# endif // CDPL_UTIL_ARRAY_CHECKS_DISABLE
#endif // !CDPL_UTIL_ARRAY_CHECK_INDEX
 
#ifndef CDPL_UTIL_ARRAY_CHECK_ITER
# ifdef CDPL_UTIL_ARRAY_CHECKS_DISABLE
#  define CDPL_UTIL_ARRAY_CHECK_ITER(it, allow_end)
# else // !CDPL_UTIL_ARRAY_CHECKS_DISABLE
#  define CDPL_UTIL_ARRAY_CHECK_ITER(it, allow_end) checkIterator(it, allow_end)
# endif // CDPL_UTIL_ARRAY_CHECKS_DISABLE
#endif // !CDPL_UTIL_ARRAY_CHECK_INDEX
 
 
namespace CDPL
{
 
    namespace Util
    {
 
        template <typename ValueType>
        class Array
        {
 
          public:
            typedef std::vector<ValueType> StorageType;
 
            typedef std::shared_ptr<Array> SharedPointer;
 
            typedef ValueType ElementType;
 
            typedef std::size_t SizeType;
 
            typedef Array BaseType;
 
            typedef typename StorageType::const_iterator ConstElementIterator;
 
            typedef typename StorageType::const_reverse_iterator ConstReverseElementIterator;
 
            typedef typename StorageType::iterator ElementIterator;
 
            typedef typename StorageType::reverse_iterator ReverseElementIterator;
 
            Array():
                data() {}
 
            Array(std::size_t num_elem, const ValueType& value = ValueType()):
                data(num_elem, value) {}
 
            template <typename InputIter>
            Array(const InputIter& first, const InputIter& last):
                data(first, last)
            {}
 
            virtual ~Array() {}
 
            StorageType& getData();
 
            const StorageType& getData() const;
 
            BaseType& getBase();
 
            const BaseType& getBase() const;
 
            std::size_t getSize() const;
 
            std::size_t size() const;
 
            bool isEmpty() const;
 
            void resize(std::size_t num_elem, const ValueType& value = ValueType());
 
            void reserve(std::size_t num_elem);
 
            std::size_t getCapacity() const;
 
            void clear();
 
            void swap(Array& array);
 
            void assign(std::size_t num_elem, const ValueType& value = ValueType());
 
            template <typename InputIter>
            void assign(const InputIter& first, const InputIter& last);
 
            void addElement(const ValueType& value = ValueType());
 
            void insertElement(std::size_t idx, const ValueType& value = ValueType());
 
            ElementIterator insertElement(const ElementIterator& it, const ValueType& value = ValueType());
 
            void insertElements(std::size_t idx, std::size_t num_elem, const ValueType& value = ValueType());
 
            void insertElements(const ElementIterator& it, std::size_t num_elem, const ValueType& value = ValueType());
 
            template <typename InputIter>
            void insertElements(std::size_t idx, const InputIter& first, const InputIter& last);
 
            template <typename InputIter>
            void insertElements(const ElementIterator& it, const InputIter& first, const InputIter& last);
 
            void popLastElement();
 
            void removeElement(std::size_t idx);
 
            ElementIterator removeElement(const ElementIterator& it);
 
            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);
 
            void setElement(std::size_t idx, const ValueType& value = ValueType());
 
            const ValueType& operator[](std::size_t idx) const;
 
            ValueType& operator[](std::size_t idx);
 
          protected:
            void checkIfNonEmpty() const;
            void checkIndex(std::size_t idx, bool allow_end) const;
            void checkIterator(const ElementIterator& it, bool allow_end);
            void checkIterator(const ConstElementIterator& it, bool allow_end) const;
 
            virtual const char* getClassName() const;
 
          private:
            void throwIndexError() const;
            void throwRangeError() const;
            void throwOperationFailed() const;
 
            StorageType data;
        };
 
 
        typedef Array<unsigned int> UIArray;
 
        typedef Array<std::size_t> STArray;
 
        typedef Array<long> LArray;
 
        typedef std::pair<std::size_t, std::size_t> STPair;
 
        typedef Array<STPair> STPairArray;
 
        typedef Array<double> DArray;
 
        typedef Array<std::string> SArray;
 
        typedef Array<BitSet> BitSetArray;
 
        template <typename ValueType>
        bool operator==(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
        template <typename ValueType>
        bool operator!=(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
        template <typename ValueType>
        bool operator<=(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
        template <typename ValueType>
        bool operator>=(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
        template <typename ValueType>
        bool operator<(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
        template <typename ValueType>
        bool operator>(const Array<ValueType>& array1, const Array<ValueType>& array2);
 
    } // namespace Util
} // namespace CDPL
 
 
// Implementation
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::StorageType& CDPL::Util::Array<ValueType>::getData()
{
    return data;
}
 
template <typename ValueType>
const typename CDPL::Util::Array<ValueType>::StorageType& CDPL::Util::Array<ValueType>::getData() const
{
    return data;
}
 
template <typename ValueType>
CDPL::Util::Array<ValueType>& CDPL::Util::Array<ValueType>::getBase()
{
    return *this;
}
 
template <typename ValueType>
const CDPL::Util::Array<ValueType>& CDPL::Util::Array<ValueType>::getBase() const
{
    return *this;
}
 
template <typename ValueType>
std::size_t CDPL::Util::Array<ValueType>::getSize() const
{
    return data.size();
}
 
template <typename ValueType>
std::size_t CDPL::Util::Array<ValueType>::size() const
{
    return data.size();
}
 
template <typename ValueType>
bool CDPL::Util::Array<ValueType>::isEmpty() const
{
    return data.empty();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::resize(std::size_t n, const ValueType& value)
{
    data.resize(n, value);
}
 
template <typename ValueType>
std::size_t CDPL::Util::Array<ValueType>::getCapacity() const
{
    return data.capacity();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::reserve(std::size_t min_size)
{
    data.reserve(min_size);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::clear()
{
    data.clear();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::swap(Array& array)
{
    data.swap(array.data);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::assign(std::size_t n, const ValueType& value)
{
    data.assign(n, value);
}
 
template <typename ValueType>
template <typename InputIter>
void CDPL::Util::Array<ValueType>::assign(const InputIter& first, const InputIter& last)
{
    data.assign(first, last);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::addElement(const ValueType& value)
{
    data.push_back(value);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::insertElement(std::size_t idx, const ValueType& value)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, true);
 
    data.insert(data.begin() + idx, value);
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::insertElement(const ElementIterator& it,
                                                                                                   const ValueType&       value)
{
    CDPL_UTIL_ARRAY_CHECK_ITER(it, true);
 
    return data.insert(it, value);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::insertElements(std::size_t idx, std::size_t n, const ValueType& value)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, true);
 
    data.insert(data.begin() + idx, n, value);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::insertElements(const ElementIterator& it, std::size_t n, const ValueType& value)
{
    CDPL_UTIL_ARRAY_CHECK_ITER(it, true);
 
    data.insert(it, n, value);
}
 
template <typename ValueType>
template <typename InputIter>
void CDPL::Util::Array<ValueType>::insertElements(std::size_t idx, const InputIter& first, const InputIter& last)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, true);
 
    data.insert(data.begin() + idx, first, last);
}
 
template <typename ValueType>
template <typename InputIter>
void CDPL::Util::Array<ValueType>::insertElements(const ElementIterator& it, const InputIter& first, const InputIter& last)
{
    CDPL_UTIL_ARRAY_CHECK_ITER(it, true);
 
    data.insert(it, first, last);
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::popLastElement()
{
    if (data.empty())
        throw Base::OperationFailed("Array: attempt to pop element from an empty array");
 
    data.pop_back();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::removeElement(std::size_t idx)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    data.erase(data.begin() + idx);
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::removeElement(const ElementIterator& it)
{
    CDPL_UTIL_ARRAY_CHECK_ITER(it, false);
 
    return data.erase(it);
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::removeElements(const ElementIterator& first,
                                                                                                    const ElementIterator& last)
{
    CDPL_UTIL_ARRAY_CHECK_ITER(first, true);
    CDPL_UTIL_ARRAY_CHECK_ITER(last, true);
 
    if (first > last)
        throw Base::RangeError(std::string(getClassName()) + ": invalid iterator range: first > last");
 
    return data.erase(first, last);
}
 
template <typename ValueType>
const ValueType& CDPL::Util::Array<ValueType>::getFirstElement() const
{
    checkIfNonEmpty();
 
    return data.front();
}
 
template <typename ValueType>
const ValueType& CDPL::Util::Array<ValueType>::getLastElement() const
{
    checkIfNonEmpty();
 
    return data.back();
}
 
template <typename ValueType>
ValueType& CDPL::Util::Array<ValueType>::getFirstElement()
{
    checkIfNonEmpty();
 
    return data.front();
}
 
template <typename ValueType>
ValueType& CDPL::Util::Array<ValueType>::getLastElement()
{
    checkIfNonEmpty();
 
    return data.back();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstElementIterator CDPL::Util::Array<ValueType>::getElementsBegin() const
{
    return data.begin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::getElementsBegin()
{
    return data.begin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstElementIterator CDPL::Util::Array<ValueType>::getElementsEnd() const
{
    return data.end();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::getElementsEnd()
{
    return data.end();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstElementIterator CDPL::Util::Array<ValueType>::begin() const
{
    return data.begin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::begin()
{
    return data.begin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstElementIterator CDPL::Util::Array<ValueType>::end() const
{
    return data.end();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ElementIterator CDPL::Util::Array<ValueType>::end()
{
    return data.end();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstReverseElementIterator CDPL::Util::Array<ValueType>::getElementsReverseBegin() const
{
    return data.rbegin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ReverseElementIterator CDPL::Util::Array<ValueType>::getElementsReverseBegin()
{
    return data.rbegin();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ConstReverseElementIterator CDPL::Util::Array<ValueType>::getElementsReverseEnd() const
{
    return data.rend();
}
 
template <typename ValueType>
typename CDPL::Util::Array<ValueType>::ReverseElementIterator CDPL::Util::Array<ValueType>::getElementsReverseEnd()
{
    return data.rend();
}
 
template <typename ValueType>
const ValueType& CDPL::Util::Array<ValueType>::getElement(std::size_t idx) const
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    return data[idx];
}
 
template <typename ValueType>
ValueType& CDPL::Util::Array<ValueType>::getElement(std::size_t idx)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    return data[idx];
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::setElement(std::size_t idx, const ValueType& value)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    data[idx] = value;
}
 
template <typename ValueType>
const ValueType& CDPL::Util::Array<ValueType>::operator[](std::size_t idx) const
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    return data[idx];
}
 
template <typename ValueType>
ValueType& CDPL::Util::Array<ValueType>::operator[](std::size_t idx)
{
    CDPL_UTIL_ARRAY_CHECK_INDEX(idx, false);
 
    return data[idx];
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::checkIfNonEmpty() const
{
    if (data.empty())
        throwOperationFailed();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::checkIndex(std::size_t idx, bool allow_end) const
{
    if ((allow_end && idx > data.size()) || (!allow_end && idx >= data.size()))
        throwIndexError();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::checkIterator(const ElementIterator& it, bool allow_end)
{
    if (it < data.begin() || (allow_end && it > data.end()) || (!allow_end && it >= data.end()))
        throwRangeError();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::checkIterator(const ConstElementIterator& it, bool allow_end) const
{
    if (it < data.begin() || (allow_end && it > data.end()) || (!allow_end && it >= data.end()))
        throwRangeError();
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::throwIndexError() const
{
    throw Base::IndexError(std::string(getClassName()) + ": element index out of bounds");
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::throwRangeError() const
{
    throw Base::RangeError(std::string(getClassName()) + ": invalid iterator");
}
 
template <typename ValueType>
void CDPL::Util::Array<ValueType>::throwOperationFailed() const
{
    throw Base::OperationFailed(std::string(getClassName()) + ": operation requires non-empty array");
}
 
template <typename ValueType>
const char* CDPL::Util::Array<ValueType>::getClassName() const
{
    return "Array";
}
 
// \cond DOC_IMPL_DETAILS 
 
template <typename ValueType>
bool CDPL::Util::operator==(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() == array2.getData());
}
 
template <typename ValueType>
bool CDPL::Util::operator!=(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() != array2.getData());
}
 
template <typename ValueType>
bool CDPL::Util::operator<=(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() <= array2.getData());
}
 
template <typename ValueType>
bool CDPL::Util::operator>=(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() >= array2.getData());
}
 
template <typename ValueType>
bool CDPL::Util::operator<(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() < array2.getData());
}
 
template <typename ValueType>
bool CDPL::Util::operator>(const Array<ValueType>& array1, const Array<ValueType>& array2)
{
    return (array1.getData() > array2.getData());
}
 
// \endcond
 
#endif // CDPL_UTIL_ARRAY_HPP