source: nrEngine/include/Property.h @ 18

Revision 18, 6.0 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_H_
15#define _NR_PROPERTY_H_
16
17//----------------------------------------------------------------------------------
18// Includes
19//----------------------------------------------------------------------------------
20#include "Prerequisities.h"
21#include <boost/any.hpp>
22
23
24namespace nrEngine{
25
26        class PropertyManager;
27       
28        //! Properties are name value pair with a value of any type
29        /**
30         * Properties represents name-value pairs with a name as a string and a
31         * value of any type. For the type of value we use boost::any which is
32         * capable to represent any type of data.
33         *
34         * \ingroup gp
35        **/
36        class _NRExport Property{
37                public:
38
39                        /**
40                         * Create an empty property object. No name is specified
41                         * and no value
42                         **/
43                        Property();
44
45                        /**
46                         * Create a new property object.
47                         *
48                         * @param name Name of the property. Name should be unique
49                         * within one property map
50                         **/
51                        Property(const std::string& name);
52
53                        /**
54                         * Construct a property object with a certain name, but also define
55                         * a value directly
56                         **/
57                        Property (const std::string& name, const boost::any& value);
58
59                        /**
60                         * Construct the property from another one
61                         **/
62                        Property(const Property&);
63                       
64                        /**
65                         * Get the name of the property
66                         **/
67                        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; }
77
78                        /**
79                         * Get value of the property
80                         **/
81                        NR_FORCEINLINE const boost::any& getValue() const { return mValue; }
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
89                       
90                        /**
91                         * Assign new value to the property
92                         **/
93                        Property& operator=(const boost::any& );
94
95                        /**
96                         * Compare two properties. Two properties are the same
97                         * if their names and type of the values are the same.
98                         *
99                         * NOTE: We can not compare the values itself because boost::any
100                         * library can not be casted here to any type. If you wish to have
101                         * more usefull comparing function, that refer to compare<T>()
102                         **/
103                        bool operator==(const Property& );
104
105                        bool operator!=(const Property& p) { return !(operator==(p)); }
106
107                       
108                        /**
109                         * Specific compare of the values with a certain type.
110                         * This will compare the properties like operator==()
111                         * do and also compare the values by converting them
112                         * to the certain type and looking if they are the same.
113                         **/
114                        template<class T> bool compare(const Property& p)
115                        {
116                                if (*this != p) return false;
117                                return boost::any_cast<T>(mValue) == boost::any_cast<T>(p.getValue());
118                        }
119
120                        /**
121                         * Get the value by casting to a certain type
122                         **/
123                        template<class T> T get(){
124                                return boost::any_cast<T>(mValue);
125                        }
126
127                        /**
128                         * Set user data. We use extra user data information if casting
129                         * will fail for the value types.
130                         **/
131                        NR_FORCEINLINE void setUserData(void* data) { mUserData = data; }
132
133                        /**
134                         * Get user data from the property
135                         **/
136                        NR_FORCEINLINE void* getUserData() { return mUserData; }
137
138                        /**
139                         * Does our property contains any user data. Just check if the user
140                         * data pointer equals to NULL. If yes, so we do not get any user data.
141                         **/
142                        NR_FORCEINLINE bool hasUserData() { return mUserData != NULL; }
143                       
144                private:
145
146                        //! Name of the property
147                        std::string mName;
148
149                        //! Full name of property (group.name)
150                        std::string mFullName;
151                       
152                        //! Value holding by the property
153                        boost::any      mValue;
154
155                        //! Userdata to be stored
156                        void*   mUserData;
157
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                        }
167        };
168
169        //! Property list to hold property objects
170        /**
171         * PropertyList is a derived class from std::list holding
172         * objects of type Property. We expand the functionality by
173         * adding some nicer operators and functions, so the list
174         * can be constructed in concatenated way.
175         * \ingroup gp
176         **/
177        class _NRExport PropertyList : public std::list<Property> {
178                public:
179
180                        /**
181                         * Add a new element into the property list
182                         **/
183                        PropertyList& operator, (const Property& p);
184
185                        /**
186                         * Pop an element from the front and return it back
187                         **/
188                        PropertyList& operator, (Property& p);
189
190                        /**
191                         * Check if a certain property exists
192                         **/
193                        bool exists(const std::string& name) const;
194
195                        /**
196                         * Get a property value by the given name.
197                         * The behaviour is the same as in std::map. If no
198                         * such property exists, so new one with such a name will be created
199                         **/
200                        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);
207                       
208        };
209       
210       
211}; // end namespace
212
213#endif
Note: See TracBrowser for help on using the repository browser.