Changeset 18 for nrEngine


Ignore:
Timestamp:
01/06/07 00:18:45 (12 years ago)
Author:
art
Message:
 
Location:
nrEngine
Files:
3 added
12 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/Engine.h

    r12 r18  
    153153 
    154154                        /** 
     155                         * Get instance to the property manager of the engine. 
     156                         **/ 
     157                        static PropertyManager* sPropertyManager(); 
     158                         
     159                        /** 
    155160                         * Get the singleton instance. Passing the parameter specify 
    156161                         * if the instance should be released 
     
    194199                        static ScriptEngine* _script; 
    195200                        static EventManager* _event; 
     201                        static PropertyManager* _propmgr; 
    196202                         
    197203                        //! Store pointer to the engine's core singleton object 
  • nrEngine/include/Makefile

    r11 r18  
    1919                        Prerequisities.h\ 
    2020                        Property.h\ 
    21                         config.h\ 
     21                        PropertyManager.h\ 
    2222                        Platform.h\ 
    2323                        Priority.h\ 
  • nrEngine/include/Prerequisities.h

    r1 r18  
    8989        // Forward declarations of used classes. 
    9090        //---------------------------------------------------------------------------------- 
    91         class                                                                           Clock; 
    92         class                                                                           CPriority; 
     91        /*class                                                                                 CPriority; 
    9392        template<class T, class value_parser> class CDator; 
    9493        template<class T, class value_parser> class CDatorList; 
    9594        class                                                                           CStringDator; 
    9695        template<class T> class                                         CValueParser; 
     96        */ 
     97         
     98        class                                                                           Clock; 
    9799        class                                                                           Engine; 
    98100        class                                                                           ExceptionManager; 
    99101        class                                                                           Exception; 
    100         class                                                                           IDator; 
    101102        class                                                                           ITask; 
    102103        class                                                                           ITimeObserver; 
     
    118119        class                                                                           Kernel; 
    119120        class                                                                           Log; 
    120         class                                                                           NameValuePairs; 
     121        //class                                                                                 NameValuePairs; 
    121122        class                                                                           Timer;   
    122123 
     
    138139         
    139140        class                                                                           VarArg; 
     141        class                                                                           Property; 
     142        class                                                                           PropertyManager; 
    140143         
    141144}; // end namespace 
  • nrEngine/include/Property.h

    r1 r18  
    2323 
    2424namespace nrEngine{ 
     25 
     26        class PropertyManager; 
    2527         
    2628        //! Properties are name value pair with a value of any type 
     
    6466                         **/ 
    6567                        NR_FORCEINLINE const std::string& getName() const { return mName; } 
     68                         
     69                        /** 
     70                         * Get the fullname of the property. Fullname contains 
     71                         * whole group path and the name (i.e. "group.name" ). 
     72                         * Only PropertyManager can change full name, because he does 
     73                         * only know to which group this property belongs. If property 
     74                         * is not handled by manager, so fullname is equal name 
     75                         **/ 
     76                        NR_FORCEINLINE const std::string& getFullName() const { return mFullName; } 
    6677 
    6778                        /** 
     
    6980                         **/ 
    7081                        NR_FORCEINLINE const boost::any& getValue() const { return mValue; } 
    71  
    72                         /** 
    73                          * Check whenever the property does not contain a value. 
    74                          * Note: it can still contain user data not equal to NULL 
    75                          **/ 
    76                         NR_FORCEINLINE bool hasNoValue() const { return mHasNoValue; } 
     82                        NR_FORCEINLINE boost::any& getValue() { return mValue; } 
     83 
     84 
     85                        /** 
     86                         * Check if the stored value has this type 
     87                         **/ 
     88                        //NR_FORCEINLINE bool is 
    7789                         
    7890                        /** 
     
    135147                        std::string mName; 
    136148 
     149                        //! Full name of property (group.name) 
     150                        std::string mFullName; 
     151                         
    137152                        //! Value holding by the property 
    138153                        boost::any      mValue; 
     
    141156                        void*   mUserData; 
    142157 
    143                         //! Do we have any value 
    144                         bool mHasNoValue; 
    145                          
     158                        //! Manager is allowed to change internal structure 
     159                        friend class PropertyManager; 
     160 
     161                        //! Copy only the data from given property 
     162                        NR_FORCEINLINE void copyDataOnly(const Property& p) 
     163                        { 
     164                                mValue = p.mValue; 
     165                                mUserData = p.mUserData; 
     166                        } 
    146167        }; 
    147168 
     
    160181                         * Add a new element into the property list 
    161182                         **/ 
    162                         PropertyList& operator << (const Property& p); 
     183                        PropertyList& operator, (const Property& p); 
    163184 
    164185                        /** 
    165186                         * Pop an element from the front and return it back 
    166187                         **/ 
    167                         PropertyList& operator >> (Property& p); 
     188                        PropertyList& operator, (Property& p); 
    168189 
    169190                        /** 
     
    173194 
    174195                        /** 
    175                          * Get a property value for by the given name. 
     196                         * Get a property value by the given name. 
    176197                         * The behaviour is the same as in std::map. If no 
    177198                         * such property exists, so new one with such a name will be created 
    178199                         **/ 
    179200                        Property& operator[](const std::string& name); 
     201                        const Property& operator[](const std::string& name) const ; 
     202 
     203                        /** 
     204                         * Get property from the list 
     205                         **/ 
     206                        //Property& get(const std::string& name); 
    180207                         
    181208        }; 
  • nrEngine/include/Result.h

    r1 r18  
    326326                EVENT_FACTORY_NOT_FOUND = EVENT_ERROR | (1 << 7), 
    327327 
    328  
     328                //------------------------------------------------------------------------------ 
     329                //! Generic group for properties errors 
     330                PROPERTY_ERROR = NR_ERR_GROUP(13), 
     331 
     332                //! No such property exists 
     333                PROPERTY_NOT_EXISTS = PROPERTY_ERROR | (1 << 0), 
     334 
     335                //! Wrong property type, so cannot cast 
     336                PROPERTY_WRONG_TYPE = PROPERTY_ERROR | (1 << 1), 
     337                 
    329338                //------------------------------------------------------------------------------ 
    330339                //! This are general engine layer errors 
  • nrEngine/include/VariadicArgument.h

    r1 r18  
    4949                         
    5050                        //! Fill the list with new element 
    51                         VarArg& operator << (const boost::any&); 
     51                        VarArg& operator, (const boost::any&); 
    5252         
    5353                        //! Get access to certain element 
  • nrEngine/include/nrEngine.h

    r1 r18  
    2020#include "Profiler.h" 
    2121#include "Property.h" 
     22#include "PropertyManager.h" 
    2223#include "Priority.h" 
    2324#include "ITask.h" 
  • nrEngine/nrEngine.h

    r1 r18  
    2020#include "include/Profiler.h" 
    2121#include "include/Property.h" 
     22#include "include/PropertyManager.h" 
    2223#include "include/Priority.h" 
    2324#include "include/ITask.h" 
  • nrEngine/src/Engine.cpp

    r1 r18  
    2222#include "ScriptEngine.h" 
    2323#include "ScriptLoader.h" 
     24#include "PropertyManager.h" 
     25#include "DefaultScriptingFunctions.cpp" 
    2426 
    2527namespace nrEngine{ 
     
    3436        ScriptEngine*           Engine::_script = NULL; 
    3537        EventManager*           Engine::_event = NULL; 
     38        PropertyManager*        Engine::_propmgr = NULL; 
    3639 
    3740        //-------------------------------------------------------------------------- 
     
    117120        } 
    118121 
     122        //-------------------------------------------------------------------------- 
     123        PropertyManager* Engine::sPropertyManager() 
     124        { 
     125                valid(_propmgr, "PropertyManager"); 
     126                return _propmgr; 
     127        } 
     128 
    119129        //------------------------------------------------------------------------ 
    120130        Engine::Engine() 
     
    126136                        NR_EXCEPT(OUT_OF_MEMORY, "Log system could not be created. Probably memory is full", "Engine::Engine()"); 
    127137                } 
     138                 
     139                // create property manager 
     140                _propmgr = (new PropertyManager()); 
     141                if (_propmgr == NULL) 
     142                { 
     143                        NR_EXCEPT(OUT_OF_MEMORY, "PropertyManager could not been created. Check if the memory is not full", "Engine::Engine()"); 
     144                } 
    128145 
    129146                // initialize the scripting engine 
     
    152169        Engine::~Engine() 
    153170        { 
     171                // remove default scripting methods 
     172                DefaultScriptingFunctions::delMethods(); 
    154173 
    155174                // remove the manager 
     
    168187                delete _event; 
    169188                 
     189                // remove property manager 
     190                delete _propmgr; 
     191                 
    170192                // remove profiler 
    171193                delete _profiler; 
     
    197219                // give some info about the underlying engine 
    198220                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE | Log::LOG_KERNEL, "nrEngine v%s - %s", convertVersionToString(nrEngineVersion).c_str(), NR_VERSION_NAME); 
    199  
     221                 
    200222                // initialize the clock 
    201223                SharedPtr<TimeSource> timeSource(new TimeSource()); 
     
    220242                _kernel->AddTask(SharedPtr<ITask>(_event, null_deleter()), ORDER_SYS_SECOND); 
    221243 
     244                // initialise default scripting methods 
     245                DefaultScriptingFunctions::addMethods(); 
     246                 
    222247                // initialize resource manager singleton 
    223248                _resmgr = (new ResourceManager()); 
     
    283308 
    284309        //} 
    285  
    286  
     310         
    287311}; // end namespace 
    288312 
    289 #if 0 
    290 /** 
    291  * This function will convert the given nrResult number to the 
    292  * string describing it. e.g: NR_OK => "NR_OK" 
    293  * 
    294  * @param res - error code to be converted in string 
    295  * \ingroup engine 
    296  **/ 
    297 /*string        nrErrorGetShort(nrResult res){ 
    298  
    299         char str[256]; 
    300         sprintf(str, "%x", res); 
    301  
    302 #define _ERROR(p) case p: sprintf(str, #p);break; 
    303  
    304         switch (res){ 
    305  
    306 _ERROR(NR_OK) 
    307 _ERROR(NR_UNKNOWN_ERROR) 
    308 _ERROR(NR_BAD_PARAMETERS) 
    309 _ERROR(NR_OUT_OF_MEMORY) 
    310  
    311 _ERROR(NR_FILE_ERROR) 
    312 _ERROR(NR_FILE_NOT_FOUND) 
    313 _ERROR(NR_FILE_ERROR_IN_LINE) 
    314  
    315 _ERROR(NR_PROFILE_ERROR) 
    316 _ERROR(NR_PROFILE_NOT_FOUND) 
    317 _ERROR(NR_PROFILE_NOT_LOADED) 
    318 _ERROR(NR_PROFILE_NOT_EXISTS) 
    319 _ERROR(NR_PROFILE_ALREADY_EXISTS) 
    320  
    321 _ERROR(NR_EXTENSION_ERROR) 
    322 _ERROR(NR_EXTENSION_NOT_SUPPORTED) 
    323  
    324 _ERROR(NR_VFS_ERROR) 
    325 _ERROR(NR_VFS_ALREADY_OPEN) 
    326 _ERROR(NR_VFS_CANNOT_OPEN) 
    327 _ERROR(NR_VFS_CANNOT_CLOSE) 
    328 _ERROR(NR_VFS_IS_NOT_OPEN) 
    329 _ERROR(NR_VFS_FILE_NOT_FOUND) 
    330 _ERROR(NR_VFS_FILE_NOT_OPEN) 
    331 _ERROR(NR_VFS_FILE_END_REACHED) 
    332 _ERROR(NR_VFS_FILE_READ_ERROR) 
    333 _ERROR(NR_VFS_LINE_READ_ERROR) 
    334 _ERROR(NR_VFS_SCAN_READ_ERROR) 
    335 _ERROR(NR_VFS_SEEK_ERROR) 
    336  
    337 _ERROR(NR_APP_ERROR) 
    338  
    339 _ERROR(NR_LOG_ERROR) 
    340  
    341 _ERROR(NR_SETTINGS_ERROR) 
    342 _ERROR(NR_SETTINGS_VAR_ALREADY_REGISTERED) 
    343 _ERROR(NR_SETTINGS_VAR_NOT_REGISTERED) 
    344  
    345 _ERROR(NR_KERNEL_ERROR) 
    346 _ERROR(NR_KERNEL_NO_TASK_FOUND) 
    347  
    348 _ERROR(NR_TASK_ERROR) 
    349 _ERROR(NR_TASK_NOT_READY) 
    350  
    351 _ERROR(NR_CONSOLE_ERROR) 
    352 _ERROR(NR_CONSOLE_ITEM_ALREADY_EXISTS) 
    353  
    354  
    355 _ERROR(NR_TEX_ERROR) 
    356 _ERROR(NR_TEX_INVALID_FORMAT) 
    357 _ERROR(NR_TEX_NOT_CREATED_BEFORE) 
    358  
    359 _ERROR(NR_CLOCK_ERROR) 
    360 _ERROR(NR_CLOCK_OBSERVER_NOT_FOUND) 
    361 _ERROR(NR_CLOCK_OBSERVER_ALREADY_ADDED) 
    362  
    363 _ERROR(NR_FW_ERROR) 
    364 _ERROR(NR_FW_CANNOT_INITIALIZE) 
    365 _ERROR(NR_FW_FAILED_TO_RESIZE) 
    366 _ERROR(NR_FW_INVALID_RC_ID) 
    367 _ERROR(NR_FW_ALREADY_INIT) 
    368 _ERROR(NR_FW_NOT_INITIALIZED) 
    369  
    370 _ERROR(NR_RC_ERROR) 
    371 _ERROR(NR_RC_CANNOT_SETUP_PIXEL_FORMAT) 
    372  
    373 _ERROR(NR_ENGINE_ERROR) 
    374 _ERROR(NR_ENGINE_YOU_MUST_CREATE_ENGINE_BEFORE) 
    375  
    376 _ERROR(NR_RES_ERROR) 
    377 _ERROR(NR_RES_LOADER_ALREADY_EXISTS) 
    378 _ERROR(NR_RES_LOADER_NOT_REGISTERED) 
    379 _ERROR(NR_RES_ALREADY_EXISTS) 
    380 _ERROR(NR_RES_BAD_FILETYPE) 
    381 _ERROR(NR_RES_CAN_NOT_LOAD_EMPTY) 
    382 _ERROR(NR_RES_NOT_FOUND) 
    383 _ERROR(NR_RES_LOADER_NOT_EXISTS ) 
    384  
    385                 default: 
    386                         sprintf(str,"%x", res); 
    387         } 
    388  
    389 #undef _ERROR 
    390         return str; 
    391 }*/ 
    392 #endif 
  • nrEngine/src/Makefile

    r15 r18  
    3636                Profiler.cpp\ 
    3737                Property.cpp\ 
     38                PropertyManager.cpp\ 
    3839                Resource.cpp\ 
    3940                ResourceHolder.cpp\ 
     
    5455TARGET=  libnrEngine.so 
    5556INCPATH += -I../include 
    56 CFLAGS += -fPIC -g 
     57CFLAGS += -fPIC 
    5758LIBS += -ldl 
    5859 
  • nrEngine/src/Property.cpp

    r1 r18  
    1616#include "Property.h" 
    1717#include "Exception.h" 
     18#include "Log.h" 
    1819 
    1920namespace nrEngine { 
    2021 
    2122        //---------------------------------------------------------------------------------- 
    22         Property::Property() :mUserData(NULL), mHasNoValue(true) 
     23        Property::Property() :mUserData(NULL) 
    2324        { 
    2425 
     
    2627 
    2728        //---------------------------------------------------------------------------------- 
    28         Property::Property(const std::string& name) : mName(name), mUserData(NULL), mHasNoValue(true) 
     29        Property::Property(const std::string& name) : mName(name), mFullName(name), mUserData(NULL) 
    2930        { 
    3031 
     
    3233 
    3334        //---------------------------------------------------------------------------------- 
    34         Property::Property (const std::string& name, const boost::any& value) : mName(name), mValue(value), mUserData(NULL), mHasNoValue(false) 
     35        Property::Property (const std::string& name, const boost::any& value) : mName(name), mFullName(name), mValue(value), mUserData(NULL) 
    3536        { 
    3637 
     
    3839 
    3940        //---------------------------------------------------------------------------------- 
    40         Property::Property(const Property& p):mName(p.getName()), mValue(p.getValue()), mUserData(p.mUserData), mHasNoValue(p.mHasNoValue) 
     41        Property::Property(const Property& p):mName(p.getName()), mFullName(p.getFullName()), mValue(p.getValue()), mUserData(p.mUserData) 
    4142        { 
    4243 
     
    5354        bool Property::operator==(const Property& p) 
    5455        { 
    55                 return (p.getName() == mName && p.getValue().type() == mValue.type()); 
     56                return (p.getFullName() == mFullName && p.getValue().type() == mValue.type()); 
    5657        } 
    5758 
    5859         
    5960        //---------------------------------------------------------------------------------- 
    60         PropertyList& PropertyList::operator << (const Property& p) 
     61        PropertyList& PropertyList::operator, (const Property& p) 
    6162        { 
    6263                push_back(p); 
     
    6566 
    6667        //---------------------------------------------------------------------------------- 
    67         PropertyList& PropertyList::operator >> ( Property& p) 
     68        PropertyList& PropertyList::operator, ( Property& p) 
    6869        { 
    6970                p = front(); 
     
    8384 
    8485        //---------------------------------------------------------------------------------- 
     86        /*const Property& PropertyList::operator[](const std::string& name) 
     87        { 
     88                // search for the key 
     89                for (const_iterator it = begin(); it != end(); it++) if (it->getName() == name) return *it; 
     90 
     91                // we could not find it, so create it and return reference 
     92                push_back(Property(name)); 
     93                for (const_iterator it = begin(); it != end(); it++) if (it->getName() == name) return *it; 
     94                 
     95                // ok it should be there, so exception 
     96                NR_EXCEPT(UNKNOWN_ERROR, "This is a BUG! Contact Author!", "PropertyList::operator[]"); 
     97        }*/ 
     98         
     99        //---------------------------------------------------------------------------------- 
    85100        Property& PropertyList::operator[](const std::string& name) 
    86101        { 
     
    89104 
    90105                // we could not find it, so create it and return reference 
    91                 push_back(Property(name)); 
    92                 for (iterator it = begin(); it != end(); it++) if (it->getName() == name) return *it; 
    93                  
    94                 // ok it should be there, so exception 
    95                 NR_EXCEPT(UNKNOWN_ERROR, "This is a BUG! Contact Author!", "PropertyList::operator[]"); 
     106                Property p(name); 
     107                push_back(p); 
     108 
     109                // some debug info 
     110                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "Property: Initialize new property '%s'", name.c_str()); 
     111 
     112                return back(); 
     113        } 
     114 
     115        //---------------------------------------------------------------------------------- 
     116        const Property& PropertyList::operator[](const std::string& name) const 
     117        { 
     118                // search for the key 
     119                for (const_iterator it = begin(); it != end(); it++) if (it->getName() == name) return *it; 
     120 
     121                // we could not find it, so error, because we can not add new elements to const 
     122                NR_EXCEPT(UNKNOWN_ERROR, "const PropertyList can not add new elements", "PropertyList::operator[]"); 
    96123        } 
    97124 
  • nrEngine/src/VariadicArgument.cpp

    r1 r18  
    4040 
    4141        //---------------------------------------------------------------------------------- 
    42         VarArg& VarArg::operator << (const boost::any& p) 
     42        VarArg& VarArg::operator, (const boost::any& p) 
    4343        { 
    4444                // add new element to the list 
     
    7171        void VarArg::push_back(const boost::any& p) 
    7272        { 
    73                 *this << p; 
     73                *this,p; 
    7474        } 
    7575 
Note: See TracChangeset for help on using the changeset viewer.