source: nrEngine/include/Property.h @ 1

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