source: nrEngine/include/PropertyManager.h @ 18

Revision 18, 6.4 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14#ifndef _NR_PROPERTY_MANAGERH_
15#define _NR_PROPERTY_MANAGERH_
16
17//----------------------------------------------------------------------------------
18// Includes
19//----------------------------------------------------------------------------------
20#include "Prerequisities.h"
21#include "Property.h"
22#include "Log.h"
23#include "Exception.h"
24
25namespace nrEngine{
26       
27        //! Property manager does hold properties for global access
28        /**
29         * Property manager class is used to access global properties. In this
30         * way your application can store some values of any type in the manager
31         * by a certain name. The value can then be accessed from another place.
32         * Propertties are grouped in groups, so group names must be unique. If no
33         * group name is specified, so default group is used. Property must have
34         * unique names in one group.
35         *
36         * \ingroup gp
37        **/
38        class _NRExport PropertyManager{
39                public:
40
41                        /**
42                         * Create Property manager object and initialiye default data
43                         **/
44                        PropertyManager();
45
46                        /**
47                         * Release used memory and remove all properties from the memory.
48                         **/
49                        ~PropertyManager();
50
51                        /**
52                         * Create new property group.
53                         * If such group already exists, so nothing happens.
54                         *
55                         * @param name Unique name of a property group
56                         **/
57                        void createGroup(const std::string& name);
58
59                        /**
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());
65
66                        /**
67                         * Get property list of properties of certain group.
68                         * The list is const, so no changes are allowed.
69                         * If no such group exists, so empty list will be returned
70                         * @param [group] Name of the group
71                         **/
72                        const PropertyList& getPropertyList(const std::string& group = std::string());
73
74                        /**
75                         * Get property.
76                         * @param name Name of the property
77                         * @param [group] Unique name of the group
78                         **/
79                        Property& getProperty(const std::string& name, const std::string& group = std::string());
80                        Property& getPropertyByFullName(const std::string& fullname);
81                       
82                        /**
83                        * Get the property directly. @see PropertyManager::getProperty()
84                        **/
85                        NR_FORCEINLINE Property& operator()(const std::string& name, const std::string& group = std::string()) {return getProperty(name, group);}
86                       
87                        /**
88                         * Add/add new property to a group.
89                         * If no such group exists, so group will be created.
90                         * If such property already exists, so it will be overwritten
91                         *
92                         * @param property Property which to add
93                         * @param name Name of the property
94                         * @param [group] Unique group name.
95                         **/
96                        void set (const Property& property, const std::string& name, const std::string& group = std::string());
97
98                        /**
99                         * Directly setup new property with new value
100                         * @copydoc PropertyManager::set()
101                         **/
102                        void set(const boost::any& value, const std::string& name, const std::string& group = std::string());
103
104                        /**
105                         * Set new value based on fullname
106                         * @copydoc PropertyManager::set()
107                         **/
108                        void setByFullName(const boost::any& value, const std::string& fullname);
109                        void setByFullName(const Property& property,const std::string& name);
110
111                        /**
112                         * Get the value directly from the database.
113                         * The method is templated, so you get the value converted to given type.
114                         * If conversion is not possible, so error occurs. To prevent errors, check
115                         * the type before access.
116                         *
117                         * @param name Name of the property
118                         * @param [group] Unique group name of the property
119                         **/
120                        template<typename T>
121                        NR_FORCEINLINE T get(const std::string& name, const std::string& group = std::string());
122                       
123                        /**
124                         * @see get()
125                         **/
126                        template<typename T>
127                        NR_FORCEINLINE T getByFullName(const std::string& name);
128
129                private:
130                                               
131                        //! This describey the type of our property map
132                        typedef std::map<std::string, PropertyList> PropertyMap;
133
134                        //! Here we store our properties
135                        PropertyMap mPropertyMap;
136        };
137       
138
139        //----------------------------------------------------------------------------------
140        template<typename T>
141        NR_FORCEINLINE T PropertyManager::get(const std::string& name, const std::string& group)
142        {       
143                try{
144                        // get property value
145                        boost::any& v = getProperty(name, group).getValue();
146                       
147                        // check if property is empty
148                        if (v.empty())
149                        {
150                                // give warning, that now a undefined value will be returned
151                                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE, Log::LL_WARNING, "PropertyManager::get() - You are retrieving undefined value from '%s.%s' property", group.c_str(), name.c_str());
152                                return T();
153                        }
154
155                        // cast the property value and return it back
156                        return boost::any_cast<T>(v);
157                       
158                }catch(const boost::bad_any_cast &){
159                        NR_EXCEPT(PROPERTY_WRONG_TYPE, "Cannot cast property to the given type", "PropertyManager::get()");
160                }
161        }
162
163        //----------------------------------------------------------------------------------
164        template<typename T>
165        NR_FORCEINLINE T PropertyManager::getByFullName(const std::string& fullname)
166        {       
167                try{
168                        // get property value
169                        boost::any& v = getPropertyByFullName(fullname).getValue();
170                       
171                        // check if property is empty
172                        if (v.empty())
173                        {
174                                // give warning, that now a undefined value will be returned
175                                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE, Log::LL_WARNING, "PropertyManager::get() - You are retrieving undefined value from '%s' property", fullname.c_str());
176                                return T();
177                        }
178
179                        // cast the property value and return it back
180                        return boost::any_cast<T>(v);
181                       
182                }catch(const boost::bad_any_cast &){
183                        NR_EXCEPT(PROPERTY_WRONG_TYPE, "Cannot cast property to the given type", "PropertyManager::get()");
184                }
185        }
186
187}; // end namespace
188
189#endif
Note: See TracBrowser for help on using the repository browser.