property.h

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

#ifndef LEAN_PROPERTIES_PROPERTY
#define LEAN_PROPERTIES_PROPERTY

#include "../lean.h"
#include "../smart/cloneable.h"
#include "../smart/cloneable_obj.h"
#include "../tags/noncopyable.h"
#include "../meta/conditional.h"
#include "../strings/types.h"
#include "../type_info.h"

namespace lean
{
namespace properties
{

template <class Class>
class property_setter : public cloneable
{
public:
    virtual bool operator ()(Class &object, const std::type_info &type, const void *values, size_t count) = 0;

    template <class Value>
    LEAN_INLINE bool operator ()(Class &object, const Value *values, size_t count)
    {
        return (*this)(object, typeid(Value), values, count);
    }
};

template <class Class>
class property_getter : public cloneable
{
public:
    virtual bool operator ()(const Class &object, const std::type_info &type, void *values, size_t count) const = 0;

    template <class Value>
    LEAN_INLINE bool operator ()(const Class &object, Value *values, size_t count) const
    {
        return (*this)(object, typeid(Value), values, count);
    }
};

class property_type
{
protected:
    ~property_type() throw() { }

public:
    virtual size_t size(size_t count) const = 0;
    virtual const type_info& type_info() const = 0;

    virtual void* allocate(size_t count) const = 0;
    virtual void construct(void *elements, size_t count) const = 0;
    virtual void destruct(void *elements, size_t count) const = 0;
    virtual void deallocate(void *elements, size_t count) const = 0;
};

struct destruct_property_data_policy
{
    static void release(const property_type &type, void *data, size_t count)
    {
        type.destruct(data, count);
    }
};
struct deallocate_property_data_policy
{
    static void release(const property_type &type, void *data, size_t count)
    {
        type.deallocate(data, count);
    }
};
struct delete_property_data_policy
{
    static void release(const property_type &type, void *data, size_t count)
    {
        try
        {
            type.destruct(data, count);
        }
        catch (...)
        {
            type.deallocate(data, count);
            throw;
        }

        type.deallocate(data, count);
    }
};

template <class Polocy = delete_property_data_policy>
class scoped_property_data : public noncopyable
{
    const property_type *m_type;
    void *m_data;
    size_t m_count;

public:
    LEAN_INLINE scoped_property_data(const property_type *type, void *data, size_t count)
        : m_type(type),
        m_data(data),
        m_count(count) { }
    LEAN_INLINE ~scoped_property_data()
    {
        m_type->destruct(m_data, m_count);
    }

    LEAN_INLINE void* data() { return m_data; }
    LEAN_INLINE const void* data() const { return m_data; }

    LEAN_INLINE size_t count() const { return m_count; }
};

template <class Class, class Derived = void>
struct property_desc
{
    typedef typename first_non_void<Derived, property_desc>::type actual_type;

    const property_type *type;  
    size_t count;               

    typedef property_setter<Class> setter_type;
    typedef cloneable_obj<setter_type, true> setter_storage_type;
    typedef property_getter<Class> getter_type;
    typedef cloneable_obj<getter_type, true> getter_storage_type;

    setter_storage_type setter; 
    getter_storage_type getter; 

    property_desc()
        : type(nullptr),
        count(0),
        setter(setter_storage_type::null()),
        getter(getter_storage_type::null()) { }
    property_desc(const property_type &type, size_t count)
        : type(&type),
        count(count),
        setter(setter_storage_type::null()),
        getter(getter_storage_type::null()) { }

    actual_type& set_setter(const setter_type &setter) { this->setter = setter; return static_cast<actual_type&>(*this); }
    actual_type& set_getter(const getter_type &getter) { this->getter = getter; return static_cast<actual_type&>(*this); }
};

template <class Class, class Derived = void>
struct named_property_desc : public property_desc<Class, typename first_non_void< Derived, named_property_desc<Class, Derived> >::type>
{
    typedef typename first_non_void<Derived, named_property_desc>::type actual_type;

    utf8_string name;   

    named_property_desc() { }
    named_property_desc(const utf8_ntri &name, const property_type &type, size_t count)
        : property_desc<Class, actual_type>(type, count),
        name(name.to<utf8_string>()) { }
};

template <class Class, class Widget, class Derived = void>
struct ui_property_desc : public named_property_desc<Class, typename first_non_void< Derived, ui_property_desc<Class, Widget, Derived> >::type>
{
    typedef typename first_non_void<Derived, ui_property_desc>::type actual_type;

    Widget widget;  

    typedef property_getter<Class> value_type;
    typedef cloneable_obj<value_type, true> value_storage_type;

    value_storage_type default_value;   

    value_storage_type min_value;       
    value_storage_type value_step;      
    value_storage_type max_value;       

    ui_property_desc()
        : default_value(value_storage_type::null()),
        min_value(value_storage_type::null()),
        value_step(value_storage_type::null()),
        max_value(value_storage_type::null()) { }
    ui_property_desc(const utf8_ntri &name, const property_type &type, size_t count, const Widget &widget)
        : named_property_desc<Class, actual_type>(name, type, count),
        widget(widget),
        default_value(value_storage_type::null()),
        min_value(value_storage_type::null()),
        value_step(value_storage_type::null()),
        max_value(value_storage_type::null()) { }

    actual_type& set_default_value(const value_type &getter) { this->default_value = getter; return static_cast<actual_type&>(*this); }
    actual_type& set_min_value(const value_type &getter) { this->min_value = getter; return static_cast<actual_type&>(*this); }
    actual_type& set_value_step(const value_type &getter) { this->value_step = getter; return static_cast<actual_type&>(*this); }
    actual_type& set_max_value(const value_type &getter) { this->max_value = getter; return static_cast<actual_type&>(*this); }
};

template <class Class, class Value>
LEAN_INLINE bool set_property(Class &object, property_setter<Class> *setter, const Value *values, size_t count)
{
    return (setter) ? (*setter)(object, values, count) : false;
}
template <class Class, class Value>
LEAN_INLINE bool set_property(Class &object, cloneable_obj<property_setter<Class>, false> &setter, const Value *values, size_t count)
{
    return (*setter)(object, values, count);
}
template <class Class, class Value>
LEAN_INLINE bool set_property(Class &object, const cloneable_obj<property_setter<Class>, true> &setter, const Value *values, size_t count)
{
    return set_property(object, setter.getptr(), values, count);
}

template <class Class, class Value>
LEAN_INLINE bool get_property(const Class &object, const property_getter<Class> *getter, Value *values, size_t count)
{
    return (getter) ? (*getter)(object, values, count) : false;
}
template <class Class, class Value, bool PointerSem>
LEAN_INLINE bool get_property(const Class &object, const cloneable_obj<property_getter<Class>, PointerSem> &getter, Value *values, size_t count)
{
    return (PointerSem)
        ? get_property(object, getter.getptr(), values, count)
        : (*getter)(object, values, count);
}

static const size_t invalid_property_id = static_cast<size_t>(-1);

template <class String, class Collection, class ID>
inline size_t find_property(const Collection &collection, const String &name, ID invalidID = invalid_property_id)
{
    for (typename Collection::const_iterator itProperty = collection.begin();
        itProperty != collection.end(); ++itProperty)
        if (itProperty->name == name)
            return itProperty - collection.begin();

    return invalidID;
}

} // namespace

using properties::property_setter;
using properties::property_getter;
using properties::property_type;

using properties::property_desc;
using properties::named_property_desc;
using properties::ui_property_desc;

using properties::get_property;
using properties::set_property;

using properties::invalid_property_id;
using properties::find_property;

using properties::scoped_property_data;
using properties::delete_property_data_policy;
using properties::destruct_property_data_policy;
using properties::deallocate_property_data_policy;

} // namespace

#endif