OgreProperty.h
Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2011 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __OGRE_PROPERTY_H__
00029 #define __OGRE_PROPERTY_H__
00030 
00031 #include "OgrePropertyPrerequisites.h"
00032 #include "OgreAny.h"
00033 #include "OgreIteratorWrappers.h"
00034 #include "OgreString.h"
00035 #include "OgreException.h"
00036 #include "OgreVector2.h"
00037 #include "OgreVector3.h"
00038 #include "OgreVector4.h"
00039 #include "OgreColourValue.h"
00040 #include "OgreQuaternion.h"
00041 #include "OgreMatrix3.h"
00042 #include "OgreMatrix4.h"
00043 
00044 #include <boost/bind.hpp>
00045 #include <boost/function.hpp>
00100 namespace Ogre
00101 {
00109 
00110     enum PropertyType
00111     {
00112         PROP_SHORT = 0,
00113         PROP_UNSIGNED_SHORT = 1,
00114         PROP_INT = 2,
00115         PROP_UNSIGNED_INT = 3,
00116         PROP_LONG = 4, 
00117         PROP_UNSIGNED_LONG = 5,
00118         PROP_REAL = 6,
00119         PROP_STRING = 7,
00120         PROP_VECTOR2 = 8, 
00121         PROP_VECTOR3 = 9,
00122         PROP_VECTOR4 = 10, 
00123         PROP_COLOUR = 11,
00124         PROP_BOOL = 12,
00125         PROP_QUATERNION = 13, 
00126         PROP_MATRIX3 = 14,
00127         PROP_MATRIX4 = 15, 
00128 
00129         PROP_UNKNOWN = 999
00130     };
00131 
00137     class _OgrePropertyExport PropertyDef : public PropertyAlloc
00138     {
00139     public:
00140 
00141         /* Construct a property.
00142         @param name The name of the property
00143         @param desc A (potentially) long description of the property
00144         @param pType The type of the property
00145         */
00146         PropertyDef(const String& name, const String& desc, PropertyType pType)
00147             : mName(name), mDesc(desc), mType(pType) {}
00148 
00150         const String& getName() const { return mName; }
00151 
00153         const String& getDescription() const { return mDesc; }
00154 
00156         PropertyType getType() const { return mType; }
00157 
00159         static const String& getTypeName(PropertyType theType);
00160 
00161         static PropertyType getTypeForValue(const short& val) { return PROP_SHORT; }
00162         static PropertyType getTypeForValue(const unsigned short& val) { return PROP_UNSIGNED_SHORT; }
00163         static PropertyType getTypeForValue(const int& val) { return PROP_INT; }
00164         static PropertyType getTypeForValue(const unsigned int& val) { return PROP_UNSIGNED_INT; }
00165         static PropertyType getTypeForValue(const long& val) { return PROP_LONG; }
00166         static PropertyType getTypeForValue(const unsigned long& val) { return PROP_UNSIGNED_LONG; }
00167         static PropertyType getTypeForValue(const Real& val) { return PROP_REAL; }
00168         static PropertyType getTypeForValue(const String& val) { return PROP_STRING; }
00169         static PropertyType getTypeForValue(const Vector2& val) { return PROP_VECTOR2; }
00170         static PropertyType getTypeForValue(const Vector3& val) { return PROP_VECTOR3; }
00171         static PropertyType getTypeForValue(const Vector4& val) { return PROP_VECTOR4; }
00172         static PropertyType getTypeForValue(const ColourValue& val) { return PROP_COLOUR; }
00173         static PropertyType getTypeForValue(const bool& val) { return PROP_BOOL; }
00174         static PropertyType getTypeForValue(const Quaternion& val) { return PROP_QUATERNION; }
00175         static PropertyType getTypeForValue(const Matrix3& val) { return PROP_MATRIX3; }
00176         static PropertyType getTypeForValue(const Matrix4& val) { return PROP_MATRIX4; }
00177 
00178     protected:
00179         // no default construction
00180         PropertyDef() {}
00181 
00182         String mName;
00183         String mDesc;
00184         PropertyType mType;
00185 
00186     };
00187 
00189     typedef map<String, PropertyDef>::type PropertyDefMap;
00190 
00193     class _OgrePropertyExport PropertyBase : public PropertyAlloc
00194     {
00195     public:
00197         PropertyBase(PropertyDef* def) : mDef(def) {}
00198         virtual ~PropertyBase() {}
00199 
00201         const String& getName() const { return mDef->getName(); }
00202 
00204         const String& getDescription() const { return mDef->getDescription(); }
00205 
00207         PropertyType getType() const { return mDef->getType(); }
00208 
00210         virtual Ogre::Any getValue() const = 0;
00211 
00212     protected:
00213         // disallow default construction
00214         PropertyBase() {}
00215         PropertyDef* mDef;
00216 
00217     };
00218 
00220     template <typename T>
00221     class Property : public PropertyBase
00222     {
00223     public:
00224         typedef T value_type;
00225         typedef boost::function< T (void) > getter_func;
00226         typedef boost::function< void (T) > setter_func;
00227 
00231         Property(PropertyDef* def, getter_func getter, setter_func setter)
00232             : PropertyBase(def)
00233             , mGetter(getter)
00234             , mSetter(setter) 
00235         {
00236         }
00237 
00240         virtual void set(T val)
00241         {
00242             mSetter(val);
00243         }
00244 
00245         virtual T get() const
00246         {
00247             return mGetter();
00248         }
00249 
00250         Ogre::Any getValue() const
00251         {
00252             return Ogre::Any(get());
00253         }
00254 
00255     protected:
00256         // disallow default construction
00257         Property() {}
00258         ~Property() {}
00259 
00260         getter_func mGetter;
00261         setter_func mSetter;
00262     };
00263 
00268     struct PropertyValue
00269     {
00270         PropertyType propType;
00271         Ogre::Any val;
00272     };
00274     typedef map<String, PropertyValue>::type PropertyValueMap;
00275 
00276 
00279     class _OgrePropertyExport PropertySet : public PropertyAlloc
00280     {
00281     public:
00282         PropertySet();
00283         ~PropertySet();
00284 
00289         void addProperty(PropertyBase* prop);
00290 
00298         PropertyBase* getProperty(const String& name) const;
00299 
00301         bool hasProperty(const String& name) const;
00302 
00303         typedef map<String, PropertyBase*>::type PropertyMap;
00304         typedef Ogre::MapIterator<PropertyMap> PropertyIterator;
00306         PropertyIterator getPropertyIterator();
00307 
00311         PropertyValueMap getValueMap() const;
00312 
00315         void setValueMap(const PropertyValueMap& values);
00316 
00319         template<typename T>
00320         void getValue(const String& name, T& value) const
00321         {
00322             getPropertyImpl(name, value, PropertyDef::getTypeForValue(value));
00323         }
00324 
00327         template<typename T>
00328         void setValue(const String& name, const T* value)
00329         {
00330             setPropertyImpl(name, *value, PropertyDef::getTypeForValue(*value));
00331         }
00334         template<typename T>
00335         void setValue(const String& name, T value)
00336         {
00337             setPropertyImpl(name, value, PropertyDef::getTypeForValue(value));
00338         }
00341         void setValue(const String& name, const char* pChar)
00342         {
00343             String v(pChar);
00344             setPropertyImpl(name, v, PROP_STRING);
00345         }
00346 
00347 
00348     protected:
00349         PropertyMap mPropertyMap;
00350 
00352         template <typename T>
00353         void setPropertyImpl(const String& name, const T& val, PropertyType typeCheck)
00354         {
00355             PropertyBase* baseProp = getProperty(name);
00356             if (baseProp->getType() != typeCheck)
00357             {
00358                 StringUtil::StrStreamType msg;
00359                 msg << "Property error: type passed in: '" << PropertyDef::getTypeName(typeCheck)
00360                     << "', type of property: '" << PropertyDef::getTypeName(baseProp->getType()) << "'";
00361                 OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, msg.str(), "PropertySet::setPropertyImpl");
00362             }
00363             static_cast<Property<T>*>(baseProp)->set(val);
00364         }
00365 
00367         template <typename T>
00368         void getPropertyImpl(const String& name, T& refVal, PropertyType typeCheck) const
00369         {
00370             PropertyBase* baseProp = getProperty(name);
00371             if (baseProp->getType() != typeCheck)
00372             {
00373                 StringUtil::StrStreamType msg;
00374                 msg << "Property error: type requested: '" << PropertyDef::getTypeName(typeCheck)
00375                     << "', type of property: '" << PropertyDef::getTypeName(baseProp->getType()) << "'";
00376                 OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, msg.str(), "PropertySet::getPropertyImpl");
00377             }
00378             refVal = static_cast<Property<T>*>(baseProp)->get();
00379         }
00380 
00381     };
00382 
00386 }
00387 
00388 #endif 

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sat Jan 14 2012 18:40:43