Changeset 49


Ignore:
Timestamp:
09/18/07 23:15:21 (12 years ago)
Author:
art
Message:
  • PropertyManager? get new methods to check if property is already registered
  • FullName? renamed everywhere (in the property managment system) into Fullname
Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/README

    r41 r49  
    1 How to install: 
     1First you have to compile the engine: 
     2        make 
    23 
    3 Install in default directory (/usr/local) 
    4         scons 
    5         scons install 
    6          
    7 Install in prefered directory (/bla/bla) 
    8         scons 
    9         scons prefix=/blah/blah install 
     4if you want to install the engine later in a non default directory, then call 
     5        make prefix=/path/as/prefix 
    106 
    11 To build debug version call: 
    12         scons debug=1 
     7To install engine type: 
     8        make install (to install into default directory /usr/local) 
     9        make INST_LOCATION=/path/to/install (to install into another directory) 
    1310 
    14 For more help on parameters call 
    15         scons -h 
    16          
    17  by problems contact me on arti_tevs@yahoo.de 
     11 
     12by problems contact me on arti_tevs@yahoo.de 
  • trunk/include/nrEngine/Property.h

    r45 r49  
    7474                         * is not handled by manager, so fullname is equal name 
    7575                         **/ 
    76                         NR_FORCEINLINE const std::string& getFullName() const { return mFullName; } 
     76                        NR_FORCEINLINE const std::string& getFullname() const { return mFullname; } 
    7777 
    7878                        /** 
     
    148148 
    149149                        //! Full name of property (group.name) 
    150                         std::string mFullName; 
     150                        std::string mFullname; 
    151151                         
    152152                        //! Value holding by the property 
  • trunk/include/nrEngine/PropertyManager.h

    r45 r49  
    5858 
    5959                        /** 
    60                          * Get number of properties in a certain group 
    61                          * 
    62                          * @param [group] Unique name of a property group 
    63                          **/ 
    64                         //int32 getPropertyCount(const std::string& group = std::string()); 
     60                         * Check whenever a property exists in the database. 
     61                         * @param name Name of the property 
     62                         * @param [group] Unique name of the group, where to look for the property 
     63                         **/ 
     64                        bool isPropertyRegistered(const std::string& name, const std::string& group = std::string()) const; 
     65                        bool isPropertyRegisteredByFullname(const std::string& fullname) const; 
    6566 
    6667                        /** 
     
    7879                         **/ 
    7980                        Property& getProperty(const std::string& name, const std::string& group = std::string()); 
    80                         Property& getPropertyByFullName(const std::string& fullname); 
     81                        Property& getPropertyByFullname(const std::string& fullname); 
    8182                         
    8283                        /** 
     
    111112                         * @param fullname Fullname of the property (i.e. "group.name") 
    112113                         **/ 
    113                         void setByFullName(const boost::any& value, const std::string& fullname); 
    114                         void setByFullName(const Property& property,const std::string& name); 
     114                        void setByFullname(const boost::any& value, const std::string& fullname); 
     115                        void setByFullname(const Property& property,const std::string& name); 
    115116 
    116117                        /** 
     
    130131                         **/ 
    131132                        template<typename T> 
    132                         NR_FORCEINLINE T getByFullName(const std::string& name); 
     133                        NR_FORCEINLINE T getByFullname(const std::string& name); 
     134 
     135                        /** 
     136                         * Extract the group name from a fullname of a property. The fullname is  
     137                         * a combination like: "group.property". So this function will look for  
     138                         * the first occurence of '.' and will return the group name back. 
     139                         * If no group name exists, then empty string will be given back 
     140                         * @param fullname Combined name of the property (also known as Fullname) 
     141                        **/ 
     142                        std::string getGroupName(const std::string& fullname) const; 
     143 
     144                        /** 
     145                         * Same as getGroupName(), but extracts the property name from the combination. 
     146                         **/ 
     147                        std::string getPropertyName(const std::string& fullname) const; 
    133148 
    134149                private: 
    135                                                  
     150 
    136151                        //! This describey the type of our property map 
    137152                        typedef std::map<std::string, PropertyList> PropertyMap; 
     
    139154                        //! Here we store our properties 
    140155                        PropertyMap mPropertyMap; 
     156 
    141157        }; 
    142158         
     
    168184        //---------------------------------------------------------------------------------- 
    169185        template<typename T> 
    170         NR_FORCEINLINE T PropertyManager::getByFullName(const std::string& fullname) 
     186        NR_FORCEINLINE T PropertyManager::getByFullname(const std::string& fullname) 
    171187        {        
    172188                try{ 
    173189                        // get property value 
    174                         boost::any& v = getPropertyByFullName(fullname).getValue(); 
     190                        boost::any& v = getPropertyByFullname(fullname).getValue(); 
    175191                         
    176192                        // check if property is empty 
  • trunk/src/nrEngine/Property.cpp

    r46 r49  
    2727 
    2828        //---------------------------------------------------------------------------------- 
    29         Property::Property(const std::string& name) : mName(name), mFullName(name), mUserData(NULL) 
     29        Property::Property(const std::string& name) : mName(name), mFullname(name), mUserData(NULL) 
    3030        { 
    3131 
     
    3333 
    3434        //---------------------------------------------------------------------------------- 
    35         Property::Property (const std::string& name, const boost::any& value) : mName(name), mFullName(name), mValue(value), mUserData(NULL) 
     35        Property::Property (const std::string& name, const boost::any& value) : mName(name), mFullname(name), mValue(value), mUserData(NULL) 
    3636        { 
    3737 
     
    3939 
    4040        //---------------------------------------------------------------------------------- 
    41         Property::Property(const Property& p):mName(p.getName()), mFullName(p.getFullName()), mValue(p.getValue()), mUserData(p.mUserData) 
     41        Property::Property(const Property& p):mName(p.getName()), mFullname(p.getFullname()), mValue(p.getValue()), mUserData(p.mUserData) 
    4242        { 
    4343 
     
    5454        bool Property::operator==(const Property& p) 
    5555        { 
    56                 return (p.getFullName() == mFullName && p.getValue().type() == mValue.type()); 
     56                return (p.getFullname() == mFullname && p.getValue().type() == mValue.type()); 
    5757        } 
    5858 
  • trunk/src/nrEngine/PropertyManager.cpp

    r46 r49  
    5151 
    5252        //---------------------------------------------------------------------------------- 
    53         Property& PropertyManager::getPropertyByFullName(const std::string& fullname) 
     53        Property& PropertyManager::getPropertyByFullname(const std::string& fullname) 
    5454        { 
    5555                // iterate through all groups 
     
    6060                        PropertyList::iterator jt = it->second.begin(); 
    6161                        for (; jt != it->second.end(); jt++) 
    62                                 if (jt->getFullName() == fullname) 
     62                                if (jt->getFullname() == fullname) 
    6363                                { 
    6464                                        return *jt; 
     
    6868                // we have not found any such element, so create one 
    6969                NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "PropertyManager: Property with fullname '%s' is not registered, so create it in default group", fullname.c_str()); 
    70                 return getProperty(fullname, "");                
     70                return getProperty(fullname, ""); 
     71        } 
     72 
     73        //---------------------------------------------------------------------------------- 
     74        bool PropertyManager::isPropertyRegistered(const std::string& name, const std::string& group) const 
     75        { 
     76                // iterate through all groups 
     77                PropertyMap::const_iterator it = mPropertyMap.begin(); 
     78                for (; it != mPropertyMap.end(); it++) 
     79                { 
     80                        // if we are checking in a certain group 
     81                        if (it->first == group) 
     82                        { 
     83                                return it->second.exists(name); 
     84                        } 
     85                } 
     86                return false; 
     87        } 
     88 
     89        //---------------------------------------------------------------------------------- 
     90        bool PropertyManager::isPropertyRegisteredByFullname(const std::string& fullname) const 
     91        { 
     92                // extract the group name 
     93                return isPropertyRegistered(getPropertyName(fullname), getGroupName(fullname)); 
     94        } 
     95 
     96        //---------------------------------------------------------------------------------- 
     97        std::string PropertyManager::getGroupName(const std::string& fullname) const 
     98        { 
     99                // find the first occurence of . character 
     100                uint32 pos = fullname.find('.'); 
     101 
     102                if (pos == std::string::npos || pos == 0) return std::string(); 
     103 
     104                return fullname.substr(0, pos - 1); 
     105        } 
     106 
     107        //---------------------------------------------------------------------------------- 
     108        std::string PropertyManager::getPropertyName(const std::string& fullname) const 
     109        { 
     110                // find the first occurence of . character 
     111                uint32 pos = fullname.find('.'); 
     112 
     113                if (pos == std::string::npos) return fullname; 
     114                if (pos == 0) pos = -1; 
     115 
     116                return fullname.substr(pos + 1); 
    71117        } 
    72118         
     
    77123                p.copyDataOnly(property); 
    78124                p.mName = name; 
    79                 p.mFullName = group + std::string(".") + name;           
     125                p.mFullname = group + std::string(".") + name;           
    80126        } 
    81127         
    82128        //---------------------------------------------------------------------------------- 
    83         void PropertyManager::setByFullName(const Property& property, const std::string& fullname) 
     129        void PropertyManager::setByFullname(const Property& property, const std::string& fullname) 
    84130        { 
    85131                // get property by fullname 
    86                 Property& p = getPropertyByFullName(fullname); 
     132                Property& p = getPropertyByFullname(fullname); 
    87133                p.copyDataOnly(property); 
    88                 p.mFullName = fullname; 
     134                p.mFullname = fullname; 
    89135                if (p.mName.length() == 0) p.mName = fullname; 
    90136        } 
     
    102148 
    103149        //---------------------------------------------------------------------------------- 
    104         void PropertyManager::setByFullName(const boost::any& value, const std::string& fullname) 
     150        void PropertyManager::setByFullname(const boost::any& value, const std::string& fullname) 
    105151        { 
    106152                // get property 
    107                 Property& p = getPropertyByFullName(fullname); 
     153                Property& p = getPropertyByFullname(fullname); 
    108154 
    109155                // set new value 
Note: See TracChangeset for help on using the changeset viewer.