Changeset 49

Timestamp:

09/18/2007 11:15:21 PM (5 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:

• README (modified) (1 diff)
• include/nrEngine/Property.h (modified) (2 diffs)
• include/nrEngine/PropertyManager.h (modified) (6 diffs)
• src/nrEngine/Property.cpp (modified) (4 diffs)
• src/nrEngine/PropertyManager.cpp (modified) (5 diffs)

trunk/README

@@ -1 @@
-How to install:
+First you have to compile the engine:
+        make
 
-Install in default directory (/usr/local)
-        scons
-        scons install
-        
-Install in prefered directory (/bla/bla)
-        scons
-        scons prefix=/blah/blah install
+if you want to install the engine later in a non default directory, then call
+        make prefix=/path/as/prefix
 
-To build debug version call:
-        scons debug=1
+To install engine type:
+        make install (to install into default directory /usr/local)
+        make INST_LOCATION=/path/to/install (to install into another directory)
 
-For more help on parameters call
-        scons -h
-        
- by problems contact me on arti_tevs@yahoo.de
+
+by problems contact me on arti_tevs@yahoo.de

trunk/include/nrEngine/Property.h

@@ -74 +74 @@
                          * is not handled by manager, so fullname is equal name
                          **/
-                        NR_FORCEINLINE const std::string& getFullName() const { return mFullName; }
+                        NR_FORCEINLINE const std::string& getFullname() const { return mFullname; }
 
                         /**
@@ -148 +148 @@
 
                         //! Full name of property (group.name)
-                        std::string mFullName;
+                        std::string mFullname;
                         
                         //! Value holding by the property

trunk/include/nrEngine/PropertyManager.h

@@ -58 +58 @@
 
                         /**
-                         * Get number of properties in a certain group
-                         *
-                         * @param [group] Unique name of a property group
-                         **/
-                        //int32 getPropertyCount(const std::string& group = std::string());
+                         * Check whenever a property exists in the database.
+                         * @param name Name of the property
+                         * @param [group] Unique name of the group, where to look for the property
+                         **/
+                        bool isPropertyRegistered(const std::string& name, const std::string& group = std::string()) const;
+                        bool isPropertyRegisteredByFullname(const std::string& fullname) const;
 
                         /**
@@ -78 +79 @@
                          **/
                         Property& getProperty(const std::string& name, const std::string& group = std::string());
-                        Property& getPropertyByFullName(const std::string& fullname);
+                        Property& getPropertyByFullname(const std::string& fullname);
                         
                         /**
@@ -111 +112 @@
                          * @param fullname Fullname of the property (i.e. "group.name")
                          **/
-                        void setByFullName(const boost::any& value, const std::string& fullname);
-                        void setByFullName(const Property& property,const std::string& name);
+                        void setByFullname(const boost::any& value, const std::string& fullname);
+                        void setByFullname(const Property& property,const std::string& name);
 
                         /**
@@ -130 +131 @@
                          **/
                         template<typename T>
-                        NR_FORCEINLINE T getByFullName(const std::string& name);
+                        NR_FORCEINLINE T getByFullname(const std::string& name);
+
+                        /**
+                         * Extract the group name from a fullname of a property. The fullname is 
+                         * a combination like: "group.property". So this function will look for 
+                         * the first occurence of '.' and will return the group name back.
+                         * If no group name exists, then empty string will be given back
+                         * @param fullname Combined name of the property (also known as Fullname)
+                        **/
+                        std::string getGroupName(const std::string& fullname) const;
+
+                        /**
+                         * Same as getGroupName(), but extracts the property name from the combination.
+                         **/
+                        std::string getPropertyName(const std::string& fullname) const;
 
                 private:
-                                                
+
                         //! This describey the type of our property map
                         typedef std::map<std::string, PropertyList> PropertyMap;
@@ -139 +154 @@
                         //! Here we store our properties
                         PropertyMap mPropertyMap;
+
         };
         
@@ -168 +184 @@
         //----------------------------------------------------------------------------------
         template<typename T>
-        NR_FORCEINLINE T PropertyManager::getByFullName(const std::string& fullname)
+        NR_FORCEINLINE T PropertyManager::getByFullname(const std::string& fullname)
         {       
                 try{
                         // get property value
-                        boost::any& v = getPropertyByFullName(fullname).getValue();
+                        boost::any& v = getPropertyByFullname(fullname).getValue();
                         
                         // check if property is empty

trunk/src/nrEngine/Property.cpp

@@ -27 +27 @@
 
         //----------------------------------------------------------------------------------
-        Property::Property(const std::string& name) : mName(name), mFullName(name), mUserData(NULL)
+        Property::Property(const std::string& name) : mName(name), mFullname(name), mUserData(NULL)
         {
 
@@ -33 +33 @@
 
         //----------------------------------------------------------------------------------
-        Property::Property (const std::string& name, const boost::any& value) : mName(name), mFullName(name), mValue(value), mUserData(NULL)
+        Property::Property (const std::string& name, const boost::any& value) : mName(name), mFullname(name), mValue(value), mUserData(NULL)
         {
 
@@ -39 +39 @@
 
         //----------------------------------------------------------------------------------
-        Property::Property(const Property& p):mName(p.getName()), mFullName(p.getFullName()), mValue(p.getValue()), mUserData(p.mUserData)
+        Property::Property(const Property& p):mName(p.getName()), mFullname(p.getFullname()), mValue(p.getValue()), mUserData(p.mUserData)
         {
 
@@ -54 +54 @@
         bool Property::operator==(const Property& p)
         {
-                return (p.getFullName() == mFullName && p.getValue().type() == mValue.type());
+                return (p.getFullname() == mFullname && p.getValue().type() == mValue.type());
         }
 

trunk/src/nrEngine/PropertyManager.cpp

@@ -51 +51 @@
 
         //----------------------------------------------------------------------------------
-        Property& PropertyManager::getPropertyByFullName(const std::string& fullname)
+        Property& PropertyManager::getPropertyByFullname(const std::string& fullname)
         {
                 // iterate through all groups
@@ -60 +60 @@
                         PropertyList::iterator jt = it->second.begin();
                         for (; jt != it->second.end(); jt++)
-                                if (jt->getFullName() == fullname)
+                                if (jt->getFullname() == fullname)
                                 {
                                         return *jt;
@@ -68 +68 @@
                 // we have not found any such element, so create one
                 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());
-                return getProperty(fullname, "");               
+                return getProperty(fullname, "");
+        }
+
+        //----------------------------------------------------------------------------------
+        bool PropertyManager::isPropertyRegistered(const std::string& name, const std::string& group) const
+        {
+                // iterate through all groups
+                PropertyMap::const_iterator it = mPropertyMap.begin();
+                for (; it != mPropertyMap.end(); it++)
+                {
+                        // if we are checking in a certain group
+                        if (it->first == group)
+                        {
+                                return it->second.exists(name);
+                        }
+                }
+                return false;
+        }
+
+        //----------------------------------------------------------------------------------
+        bool PropertyManager::isPropertyRegisteredByFullname(const std::string& fullname) const
+        {
+                // extract the group name
+                return isPropertyRegistered(getPropertyName(fullname), getGroupName(fullname));
+        }
+
+        //----------------------------------------------------------------------------------
+        std::string PropertyManager::getGroupName(const std::string& fullname) const
+        {
+                // find the first occurence of . character
+                uint32 pos = fullname.find('.');
+
+                if (pos == std::string::npos || pos == 0) return std::string();
+
+                return fullname.substr(0, pos - 1);
+        }
+
+        //----------------------------------------------------------------------------------
+        std::string PropertyManager::getPropertyName(const std::string& fullname) const
+        {
+                // find the first occurence of . character
+                uint32 pos = fullname.find('.');
+
+                if (pos == std::string::npos) return fullname;
+                if (pos == 0) pos = -1;
+
+                return fullname.substr(pos + 1);
         }
         
@@ -77 +123 @@
                 p.copyDataOnly(property);
                 p.mName = name;
-                p.mFullName = group + std::string(".") + name;          
+                p.mFullname = group + std::string(".") + name;          
         }
         
         //----------------------------------------------------------------------------------
-        void PropertyManager::setByFullName(const Property& property, const std::string& fullname)
+        void PropertyManager::setByFullname(const Property& property, const std::string& fullname)
         {
                 // get property by fullname
-                Property& p = getPropertyByFullName(fullname);
+                Property& p = getPropertyByFullname(fullname);
                 p.copyDataOnly(property);
-                p.mFullName = fullname;
+                p.mFullname = fullname;
                 if (p.mName.length() == 0) p.mName = fullname;
         }
@@ -102 +148 @@
 
         //----------------------------------------------------------------------------------
-        void PropertyManager::setByFullName(const boost::any& value, const std::string& fullname)
+        void PropertyManager::setByFullname(const boost::any& value, const std::string& fullname)
         {
                 // get property
-                Property& p = getPropertyByFullName(fullname);
+                Property& p = getPropertyByFullname(fullname);
 
                 // set new value