# OgreStringInterface.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-2006 Torus Knot Software Ltd
    00008 Also see acknowledgements in Readme.html
    00009
    00010 This program is free software; you can redistribute it and/or modify it under
    00011 the terms of the GNU Lesser General Public License as published by the Free Software
    00012 Foundation; either version 2 of the License, or (at your option) any later
    00013 version.
    00014
    00015 This program is distributed in the hope that it will be useful, but WITHOUT
    00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
    00018
    00019 You should have received a copy of the GNU Lesser General Public License along with
    00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    00022 http://www.gnu.org/copyleft/lesser.txt.
    00023
    00024 You may alternatively use this source under the terms of a specific version of
    00025 the OGRE Unrestricted License provided you have obtained such a license from
    00026 Torus Knot Software Ltd.
    00027 -----------------------------------------------------------------------------
    00028 */
    00029
    00030 #ifndef __StringInterface_H__
    00031 #define __StringInterface_H__
    00032
    00033 #include "OgrePrerequisites.h"
    00034 #include "OgreString.h"
    00035 #include "OgreCommon.h"
    00036
    00037 namespace Ogre {
    00038
    00039
    00041     enum ParameterType
    00042     {
    00043         PT_BOOL,
    00044         PT_REAL,
    00045         PT_INT,
    00046         PT_UNSIGNED_INT,
    00047         PT_SHORT,
    00048         PT_UNSIGNED_SHORT,
    00049         PT_LONG,
    00050         PT_UNSIGNED_LONG,
    00051         PT_STRING,
    00052         PT_VECTOR3,
    00053         PT_MATRIX3,
    00054         PT_MATRIX4,
    00055         PT_QUATERNION,
    00056         PT_COLOURVALUE
    00057     };
    00058
    00060     class _OgreExport ParameterDef
    00061     {
    00062     public:
    00063         String name;
    00064         String description;
    00065         ParameterType paramType;
    00066         ParameterDef(const String& newName, const String& newDescription, ParameterType newType)
    00067             : name(newName), description(newDescription), paramType(newType) {}
    00068     };
    00069     typedef std::vector<ParameterDef> ParameterList;
    00070
    00072     class _OgreExport ParamCommand
    00073     {
    00074     public:
    00075         virtual String doGet(const void* target) const = 0;
    00076         virtual void doSet(void* target, const String& val) = 0;
    00077
    00078         virtual ~ParamCommand() { }
    00079     };
    00080     typedef std::map<String, ParamCommand* > ParamCommandMap;
    00081
    00083     class _OgreExport ParamDictionary
    00084     {
    00085         friend class StringInterface;
    00086     protected:
    00088         ParameterList mParamDefs;
    00089
    00091         ParamCommandMap mParamCommands;
    00092
    00094         ParamCommand* getParamCommand(const String& name)
    00095         {
    00096             ParamCommandMap::iterator i = mParamCommands.find(name);
    00097             if (i != mParamCommands.end())
    00098             {
    00099                 return i->second;
    00100             }
    00101             else
    00102             {
    00103                 return 0;
    00104             }
    00105         }
    00106
    00107         const ParamCommand* getParamCommand(const String& name) const
    00108         {
    00109             ParamCommandMap::const_iterator i = mParamCommands.find(name);
    00110             if (i != mParamCommands.end())
    00111             {
    00112                 return i->second;
    00113             }
    00114             else
    00115             {
    00116                 return 0;
    00117             }
    00118         }
    00119     public:
    00120         ParamDictionary()  {}
    00127         void addParameter(const ParameterDef& paramDef, ParamCommand* paramCmd)
    00128         {
    00129             mParamDefs.push_back(paramDef);
    00130             mParamCommands[paramDef.name] = paramCmd;
    00131         }
    00137         const ParameterList& getParameters(void) const
    00138         {
    00139             return mParamDefs;
    00140         }
    00141
    00142
    00143
    00144     };
    00145     typedef std::map<String, ParamDictionary> ParamDictionaryMap;
    00146
    00156     class _OgreExport StringInterface
    00157     {
    00158     private:
    00159         OGRE_STATIC_MUTEX( msDictionaryMutex );
    00160
    00162         static ParamDictionaryMap msDictionary;
    00163
    00165         String mParamDictName;
    00166         ParamDictionary* mParamDict;
    00167
    00168     protected:
    00179         bool createParamDictionary(const String& className)
    00180         {
    00181             OGRE_LOCK_MUTEX( msDictionaryMutex )
    00182
    00183             ParamDictionaryMap::iterator it = msDictionary.find(className);
    00184
    00185             if ( it == msDictionary.end() )
    00186             {
    00187                 mParamDict = &msDictionary.insert( std::make_pair( className, ParamDictionary() ) ).first->second;
    00188                 mParamDictName = className;
    00189                 return true;
    00190             }
    00191             else
    00192             {
    00193                 mParamDict = &it->second;
    00194                 mParamDictName = className;
    00195                 return false;
    00196             }
    00197         }
    00198
    00199     public:
    00200         StringInterface() : mParamDict(NULL) { }
    00201
    00203         virtual ~StringInterface() {}
    00204
    00212         ParamDictionary* getParamDictionary(void)
    00213         {
    00214             return mParamDict;
    00215         }
    00216
    00217         const ParamDictionary* getParamDictionary(void) const
    00218         {
    00219             return mParamDict;
    00220         }
    00221
    00227         const ParameterList& getParameters(void) const;
    00228
    00243         virtual bool setParameter(const String& name, const String& value);
    00253         virtual void setParameterList(const NameValuePairList& paramList);
    00265         virtual String getParameter(const String& name) const
    00266         {
    00267             // Get dictionary
    00268             const ParamDictionary* dict = getParamDictionary();
    00269
    00270             if (dict)
    00271             {
    00272                 // Look up command object
    00273                 const ParamCommand* cmd = dict->getParamCommand(name);
    00274
    00275                 if (cmd)
    00276                 {
    00277                     return cmd->doGet(this);
    00278                 }
    00279             }
    00280
    00281             // Fallback
    00282             return "";
    00283         }
    00296         virtual void copyParametersTo(StringInterface* dest) const
    00297         {
    00298             // Get dictionary
    00299             const ParamDictionary* dict = getParamDictionary();
    00300
    00301             if (dict)
    00302             {
    00303                 // Iterate through own parameters
    00304                 ParameterList::const_iterator i;
    00305
    00306                 for (i = dict->mParamDefs.begin();
    00307                 i != dict->mParamDefs.end(); ++i)
    00308                 {
    00309                     dest->setParameter(i->name, getParameter(i->name));
    00310                 }
    00311             }
    00312
    00313
    00314         }
    00315
    00319         static void cleanupDictionary () ;
    00320
    00321     };
    00322
    00323
    00324
    00325 }
    00326
    00327 #endif
    00328

Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Dec 27 17:31:08 2009