seq_tpl.hpp

#pragma once
#ifndef OGLPLUS_OBJECT_SEQ_TPL_1405011014_HPP
#define OGLPLUS_OBJECT_SEQ_TPL_1405011014_HPP

#include <oglplus/object/name_tpl.hpp>
#include <cstddef>
#include <cassert>

namespace oglplus {

template <typename ObjectT>
class SeqIterator
{
private:
    typedef typename Classify<ObjectT>::ObjTag ObjTag;
    typedef typename ObjTag::NameType NameT;
    const NameT* _pos;
public:
    SeqIterator(const NameT* pos)
     : _pos(pos)
    { }

    friend bool operator == (SeqIterator a, SeqIterator b)
    {
        return a._pos == b._pos;
    }

    friend bool operator != (SeqIterator a, SeqIterator b)
    {
        return a._pos != b._pos;
    }

    friend bool operator <  (SeqIterator a, SeqIterator b)
    {
        return a._pos <  b._pos;
    }

    typedef ObjectT value_type;

    typedef std::ptrdiff_t difference_type;

    friend difference_type operator - (SeqIterator a, SeqIterator b)
    {
        return a._pos - b._pos;
    }

    value_type operator * (void) const
    {
        assert(_pos != nullptr);
        return ObjectT(ObjectName<ObjTag>(*_pos));
    }

    value_type operator [](std::size_t index) const
    {
        assert(_pos != nullptr);
        return ObjectT(ObjectName<ObjTag>(_pos[index]));
    }

    SeqIterator& operator ++ (void)
    {
        ++_pos;
        return *this;
    }

    SeqIterator operator ++ (int)
    {
        return SeqIterator(_pos++);
    }

    SeqIterator& operator -- (void)
    {
        --_pos;
        return *this;
    }

    SeqIterator operator -- (int)
    {
        return SeqIterator(_pos--);
    }

    friend SeqIterator operator + (SeqIterator a, difference_type d)
    {
        return SeqIterator(a._pos+d);
    }

    SeqIterator& operator += (difference_type d)
    {
        _pos += d;
        return *this;
    }

    friend SeqIterator operator - (SeqIterator a, difference_type d)
    {
        return SeqIterator(a._pos-d);
    }

    SeqIterator& operator -= (difference_type d)
    {
        _pos -= d;
        return *this;
    }
};

template <typename ObjectT>
const typename Classify<ObjectT>::ObjTag::NameType*
GetNames(const Sequence<ObjectT>&);

template <typename ObjectT>
class Sequence
{
private:
    typedef typename Classify<ObjectT>::ObjTag ObjTag;
    typedef typename ObjTag::NameType NameT;

    friend const NameT* GetNames<ObjectT>(const Sequence&);

    const NameT* _names;
    std::size_t _size;
public:
    Sequence(void)
     : _names(nullptr)
     , _size(0)
    { }

    Sequence(const NameT* names, std::size_t count)
     : _names(names)
     , _size(count)
    { }

    bool empty(void) const
    {
        return _size == 0;
    }

    std::size_t size(void) const
    {
        return _size;
    }

    ObjectT at(std::size_t index) const
    {
        assert(index < _size);
        return ObjectT(_names[index]);
    }

    ObjectT operator[](std::size_t index) const
    {
        return at(index);
    }

    Sequence slice(std::size_t start) const
    {
        assert(start <= _size);
        return Sequence(_names+start, _size-start);
    }

    Sequence slice(std::size_t start, std::size_t count) const
    {
        assert(start + count <= _size);
        return Sequence(_names+start, count);
    }

    typedef SeqIterator<ObjectT> iterator;
    typedef SeqIterator<ObjectT> const_iterator;

    const_iterator begin(void) const
    {
        return const_iterator(_names);
    }

    const_iterator end(void) const
    {
        return const_iterator(_names+_size);
    }
};

template <typename ObjectT>
inline const typename Classify<ObjectT>::ObjTag::NameType*
GetNames(const Sequence<ObjectT>& sequence)
{
    return sequence._names;
}

} // namespace oglplus

#endif // include guard