OgreProperty.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2011 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __OGRE_PROPERTY_H__
#define __OGRE_PROPERTY_H__

#include "OgrePropertyPrerequisites.h"
#include "OgreAny.h"
#include "OgreIteratorWrappers.h"
#include "OgreString.h"
#include "OgreException.h"
#include "OgreVector2.h"
#include "OgreVector3.h"
#include "OgreVector4.h"
#include "OgreColourValue.h"
#include "OgreQuaternion.h"
#include "OgreMatrix3.h"
#include "OgreMatrix4.h"

#include <boost/bind.hpp>
#include <boost/function.hpp>
namespace Ogre
{
    enum PropertyType
    {
        PROP_SHORT = 0,
        PROP_UNSIGNED_SHORT = 1,
        PROP_INT = 2,
        PROP_UNSIGNED_INT = 3,
        PROP_LONG = 4, 
        PROP_UNSIGNED_LONG = 5,
        PROP_REAL = 6,
        PROP_STRING = 7,
        PROP_VECTOR2 = 8, 
        PROP_VECTOR3 = 9,
        PROP_VECTOR4 = 10, 
        PROP_COLOUR = 11,
        PROP_BOOL = 12,
        PROP_QUATERNION = 13, 
        PROP_MATRIX3 = 14,
        PROP_MATRIX4 = 15, 

        PROP_UNKNOWN = 999
    };

    class _OgrePropertyExport PropertyDef : public PropertyAlloc
    {
    public:

        /* Construct a property.
        @param name The name of the property
        @param desc A (potentially) long description of the property
        @param pType The type of the property
        */
        PropertyDef(const String& name, const String& desc, PropertyType pType)
            : mName(name), mDesc(desc), mType(pType) {}

        const String& getName() const { return mName; }

        const String& getDescription() const { return mDesc; }

        PropertyType getType() const { return mType; }

        static const String& getTypeName(PropertyType theType);

        static PropertyType getTypeForValue(const short& val) { return PROP_SHORT; }
        static PropertyType getTypeForValue(const unsigned short& val) { return PROP_UNSIGNED_SHORT; }
        static PropertyType getTypeForValue(const int& val) { return PROP_INT; }
        static PropertyType getTypeForValue(const unsigned int& val) { return PROP_UNSIGNED_INT; }
        static PropertyType getTypeForValue(const long& val) { return PROP_LONG; }
        static PropertyType getTypeForValue(const unsigned long& val) { return PROP_UNSIGNED_LONG; }
        static PropertyType getTypeForValue(const Real& val) { return PROP_REAL; }
        static PropertyType getTypeForValue(const String& val) { return PROP_STRING; }
        static PropertyType getTypeForValue(const Vector2& val) { return PROP_VECTOR2; }
        static PropertyType getTypeForValue(const Vector3& val) { return PROP_VECTOR3; }
        static PropertyType getTypeForValue(const Vector4& val) { return PROP_VECTOR4; }
        static PropertyType getTypeForValue(const ColourValue& val) { return PROP_COLOUR; }
        static PropertyType getTypeForValue(const bool& val) { return PROP_BOOL; }
        static PropertyType getTypeForValue(const Quaternion& val) { return PROP_QUATERNION; }
        static PropertyType getTypeForValue(const Matrix3& val) { return PROP_MATRIX3; }
        static PropertyType getTypeForValue(const Matrix4& val) { return PROP_MATRIX4; }

    protected:
        // no default construction
        PropertyDef() {}

        String mName;
        String mDesc;
        PropertyType mType;

    };

    typedef map<String, PropertyDef>::type PropertyDefMap;

    class _OgrePropertyExport PropertyBase : public PropertyAlloc
    {
    public:
        PropertyBase(PropertyDef* def) : mDef(def) {}
        virtual ~PropertyBase() {}

        const String& getName() const { return mDef->getName(); }

        const String& getDescription() const { return mDef->getDescription(); }

        PropertyType getType() const { return mDef->getType(); }

        virtual Ogre::Any getValue() const = 0;

    protected:
        // disallow default construction
        PropertyBase() {}
        PropertyDef* mDef;

    };

    template <typename T>
    class Property : public PropertyBase
    {
    public:
        typedef T value_type;
        typedef boost::function< T (void) > getter_func;
        typedef boost::function< void (T) > setter_func;

        Property(PropertyDef* def, getter_func getter, setter_func setter)
            : PropertyBase(def)
            , mGetter(getter)
            , mSetter(setter) 
        {
        }

        virtual void set(T val)
        {
            mSetter(val);
        }

        virtual T get() const
        {
            return mGetter();
        }

        Ogre::Any getValue() const
        {
            return Ogre::Any(get());
        }

    protected:
        // disallow default construction
        Property() {}
        ~Property() {}

        getter_func mGetter;
        setter_func mSetter;
    };

    struct PropertyValue
    {
        PropertyType propType;
        Ogre::Any val;
    };
    typedef map<String, PropertyValue>::type PropertyValueMap;


    class _OgrePropertyExport PropertySet : public PropertyAlloc
    {
    public:
        PropertySet();
        ~PropertySet();

        void addProperty(PropertyBase* prop);

        PropertyBase* getProperty(const String& name) const;

        bool hasProperty(const String& name) const;

        typedef map<String, PropertyBase*>::type PropertyMap;
        typedef Ogre::MapIterator<PropertyMap> PropertyIterator;
        PropertyIterator getPropertyIterator();

        PropertyValueMap getValueMap() const;

        void setValueMap(const PropertyValueMap& values);

        template<typename T>
        void getValue(const String& name, T& value) const
        {
            getPropertyImpl(name, value, PropertyDef::getTypeForValue(value));
        }

        template<typename T>
        void setValue(const String& name, const T* value)
        {
            setPropertyImpl(name, *value, PropertyDef::getTypeForValue(*value));
        }
        template<typename T>
        void setValue(const String& name, T value)
        {
            setPropertyImpl(name, value, PropertyDef::getTypeForValue(value));
        }
        void setValue(const String& name, const char* pChar)
        {
            String v(pChar);
            setPropertyImpl(name, v, PROP_STRING);
        }


    protected:
        PropertyMap mPropertyMap;

        template <typename T>
        void setPropertyImpl(const String& name, const T& val, PropertyType typeCheck)
        {
            PropertyBase* baseProp = getProperty(name);
            if (baseProp->getType() != typeCheck)
            {
                StringUtil::StrStreamType msg;
                msg << "Property error: type passed in: '" << PropertyDef::getTypeName(typeCheck)
                    << "', type of property: '" << PropertyDef::getTypeName(baseProp->getType()) << "'";
                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, msg.str(), "PropertySet::setPropertyImpl");
            }
            static_cast<Property<T>*>(baseProp)->set(val);
        }

        template <typename T>
        void getPropertyImpl(const String& name, T& refVal, PropertyType typeCheck) const
        {
            PropertyBase* baseProp = getProperty(name);
            if (baseProp->getType() != typeCheck)
            {
                StringUtil::StrStreamType msg;
                msg << "Property error: type requested: '" << PropertyDef::getTypeName(typeCheck)
                    << "', type of property: '" << PropertyDef::getTypeName(baseProp->getType()) << "'";
                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, msg.str(), "PropertySet::getPropertyImpl");
            }
            refVal = static_cast<Property<T>*>(baseProp)->get();
        }

    };

}

#endif