array.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_OBJECT_ARRAY_1107121519_HPP
#define OGLPLUS_OBJECT_ARRAY_1107121519_HPP

#include <oglplus/object/reference.hpp>
#include <oglplus/object/seq_tpl.hpp>
#include <oglplus/utils/nothing.hpp>

#include <vector>
#include <cassert>

namespace oglplus {

template <typename ObjTag>
struct ObjectSubtype;

template <typename ObjTag>
class ObjGenDelOps;


template <typename Object>
class Array
 : public ObjGenDelOps<typename Classify<Object>::ObjTag>
{
private:
    typedef typename Classify<Object>::OpsTag OpsTag;
    typedef typename Classify<Object>::ObjTag ObjTag;
    typedef typename ObjGenTag<OpsTag, ObjTag>::Type GenTag;
    typedef ObjGenDelOps<ObjTag> GenDelOps;

    Array(const Array&);
protected:
    typedef typename ObjTag::NameType NameT;
    std::vector<NameT> _names;

    void _init(Nothing)
    {
        GenDelOps::Gen(GenTag(), GLsizei(_names.size()), _names.data());
    }

    template <typename ObjectSubtype>
    void _init(ObjectSubtype type)
    {
        this->_type = decltype(this->_type)(type);
        _init(Nothing());
    }
public:
    Array(Array&& temp)
     : _names(std::move(temp._names))
    { }

    Array(std::size_t count)
     : _names(count, 0u)
    {
        _init(Nothing());
    }

    Array(std::size_t n, typename ObjectSubtype<ObjTag>::Type type)
     : _names(n, 0u)
    {
        _init(type);
    }

    ~Array(void)
    {
        if(!_names.empty())
        {
            GenDelOps::Delete(
                GLsizei(_names.size()),
                _names.data()
            );
        }
    }

    bool empty(void) const
    {
        return _names.empty();
    }

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

    typedef Reference<Object> reference;

    typedef const reference const_reference;

    reference at(std::size_t index)
    {
        return reference(ObjectName<ObjTag>(_names.at(index)));
    }

    const_reference at(NameT index) const
    {
        return const_reference(ObjectName<ObjTag>(_names.at(index)));
    }

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

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

    typedef SeqIterator<Object> iterator;

    typedef iterator const_iterator;

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

    const_iterator end(void) const
    {
        return const_iterator(_names.data()+_names.size());
    }

/*
    Range<Object> all(void) const;
*/
    Sequence<ObjectName<ObjTag>> seq(void) const
    {
        return Sequence<ObjectName<ObjTag>>(
            _names.data(),
            _names.size()
        );
    }

    operator Sequence<ObjectName<ObjTag>> (void) const
    {
        return seq();
    }
};

} // namespace oglplus

#endif // include guard