property_collection.h

/*****************************************************/
/* lean Properties              (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_PROPERTIES_PROPERTY_COLLECTION
#define LEAN_PROPERTIES_PROPERTY_COLLECTION

#include <typeinfo>
#include <vector>
#include "../tags/noncopyable.h"

namespace lean
{
namespace properties
{

template < class Class, class Description, class Vector = std::vector<Description> >
class property_collection
{
private:
    typedef Vector property_vector;
    property_vector m_properties;

public:
    typedef Description property_desc;
    typedef typename property_vector::const_iterator iterator;
    typedef typename property_vector::const_iterator const_iterator;

    property_collection() { }
    template <class Iterator>
    property_collection(Iterator begin, Iterator end)
        : m_properties(begin, end) { }
    template <class Range>
    property_collection(const Range &range)
        : m_properties(range.begin(), range.end()) { }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    property_collection(property_collection &&right)
        : m_properties( std::move(right.m_properties) ) { }
#endif

    template <class Collection = property_collection>
    class inplace_builder
    {
    friend class property_collection;

    protected:
        Collection m_collection;

    public:
        inplace_builder() { }
        template <class Iterator>
        inplace_builder(Iterator begin, Iterator end)
            : m_collection(begin, end) { }
        template <class Range>
        inplace_builder(const Range &range)
            : m_collection(range) { }

        LEAN_INLINE inplace_builder& operator <<(const property_desc& propertyDesc)
        {
            m_collection.add(propertyDesc);
            return *this;
        }
    };
    property_collection(inplace_builder<> &right)
    {
        *this = right;
    }
    static LEAN_INLINE inplace_builder<> construct_inplace()
    {
        return inplace_builder<>();
    }
    template <class Iterator>
    static LEAN_INLINE inplace_builder<> construct_inplace(Iterator begin, Iterator end)
    {
        return inplace_builder<>(begin, end);
    }
    template <class Range>
    static LEAN_INLINE inplace_builder<> construct_inplace(const Range &range)
    {
        return inplace_builder<>(range);
    }

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE property_collection& operator =(property_collection &&right)
    {
        m_properties = std::move(right.m_properties);
        return *this;
    }
#endif

    LEAN_INLINE property_collection& operator =(inplace_builder<> &right)
    {
#ifndef LEAN0X_NO_RVALUE_REFERENCES
        m_properties = std::move(right.m_collection.m_properties);
#else
        using std::swap;
        swap(m_properties, right.m_collection.m_properties);
#endif
        return *this;
    }

    LEAN_INLINE size_t add(const property_desc& propertyDesc)
    {
        size_t id = m_properties.size();
        m_properties.push_back(propertyDesc);
        return id;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    LEAN_INLINE size_t add(property_desc&& propertyDesc)
    {
        size_t id = m_properties.size();
        m_properties.push_back( std::move(propertyDesc) );
        return id;
    }
#endif

    LEAN_INLINE const property_desc& desc(size_t id) const
    {
        return m_properties[id];
    }
    
    LEAN_INLINE size_t count() const
    {
        return m_properties.size();
    }

    LEAN_INLINE const property_desc* data() const
    {
        return &m_properties.front();
    }
    LEAN_INLINE const property_desc* data_end() const
    {
        return &m_properties.back() + 1;
    }

    LEAN_INLINE const_iterator begin() const
    {
        return m_properties.begin();
    }
    LEAN_INLINE const_iterator end() const
    {
        return m_properties.end();
    }

    template <class Value>
    LEAN_INLINE bool set(Class &object, size_t id, const Value &value) const
    {
        return set(object, id, &value, 1);
    }
    template <class Value>
    LEAN_INLINE bool set(Class &object, size_t id, const Value *values, size_t count) const
    {
        return (id < m_properties.size())
            ? set_property(object, m_properties[id].setter, values, count)
            : false;
    }

    template <class Value>
    LEAN_INLINE bool get(const Class &object, size_t id, Value &value) const
    {
        return get(object, id, &value, 1);
    }
    template <class Value>
    LEAN_INLINE bool get(const Class &object, size_t id, Value *values, size_t count) const
    {
        return (id < m_properties.size())
            ? get_property(object, m_properties[id].getter, values, count)
            : false;
    }
};

} // namespace

using properties::property_collection;

} // namespace

#endif