# | Line 1 | Line 1 | |
---|---|---|
1 | /* | |
2 | < | * Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project |
3 | < | * |
4 | < | * Contact: oopse@oopse.org |
5 | < | * |
6 | < | * This program is free software; you can redistribute it and/or |
7 | < | * modify it under the terms of the GNU Lesser General Public License |
8 | < | * as published by the Free Software Foundation; either version 2.1 |
9 | < | * of the License, or (at your option) any later version. |
10 | < | * All we ask is that proper credit is given for our work, which includes |
11 | < | * - but is not limited to - adding the above copyright notice to the beginning |
12 | < | * of your source code files, and to any copyright notice that you may distribute |
13 | < | * with programs based on this work. |
14 | < | * |
15 | < | * This program is distributed in the hope that it will be useful, |
16 | < | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | < | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
18 | < | * GNU Lesser General Public License for more details. |
19 | < | * |
20 | < | * You should have received a copy of the GNU Lesser General Public License |
21 | < | * along with this program; if not, write to the Free Software |
22 | < | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
2 | > | * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved. |
3 | * | |
4 | + | * The University of Notre Dame grants you ("Licensee") a |
5 | + | * non-exclusive, royalty free, license to use, modify and |
6 | + | * redistribute this software in source and binary code form, provided |
7 | + | * that the following conditions are met: |
8 | + | * |
9 | + | * 1. Acknowledgement of the program authors must be made in any |
10 | + | * publication of scientific results based in part on use of the |
11 | + | * program. An acceptable form of acknowledgement is citation of |
12 | + | * the article in which the program was described (Matthew |
13 | + | * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher |
14 | + | * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented |
15 | + | * Parallel Simulation Engine for Molecular Dynamics," |
16 | + | * J. Comput. Chem. 26, pp. 252-271 (2005)) |
17 | + | * |
18 | + | * 2. Redistributions of source code must retain the above copyright |
19 | + | * notice, this list of conditions and the following disclaimer. |
20 | + | * |
21 | + | * 3. Redistributions in binary form must reproduce the above copyright |
22 | + | * notice, this list of conditions and the following disclaimer in the |
23 | + | * documentation and/or other materials provided with the |
24 | + | * distribution. |
25 | + | * |
26 | + | * This software is provided "AS IS," without a warranty of any |
27 | + | * kind. All express or implied conditions, representations and |
28 | + | * warranties, including any implied warranty of merchantability, |
29 | + | * fitness for a particular purpose or non-infringement, are hereby |
30 | + | * excluded. The University of Notre Dame and its licensors shall not |
31 | + | * be liable for any damages suffered by licensee as a result of |
32 | + | * using, modifying or distributing the software or its |
33 | + | * derivatives. In no event will the University of Notre Dame or its |
34 | + | * licensors be liable for any lost revenue, profit or data, or for |
35 | + | * direct, indirect, special, consequential, incidental or punitive |
36 | + | * damages, however caused and regardless of the theory of liability, |
37 | + | * arising out of the use of or inability to use software, even if the |
38 | + | * University of Notre Dame has been advised of the possibility of |
39 | + | * such damages. |
40 | */ | |
41 | < | |
41 | > | |
42 | /** | |
43 | * @file GenericData.hpp | |
44 | * @brief | |
# | Line 40 | Line 56 | namespace oopse{ | |
56 | #include <vector> | |
57 | namespace oopse{ | |
58 | ||
59 | < | /** |
60 | < | * @ class GenericData GenericData.hpp "utils/GenericData.hpp" |
61 | < | * @brief Base class for generic data which is associated with an id |
62 | < | */ |
63 | < | class GenericData{ |
64 | < | public: |
65 | < | GenericData() : id_("UndefinedGenericData"){} |
59 | > | /** |
60 | > | * @ class GenericData GenericData.hpp "utils/GenericData.hpp" |
61 | > | * @brief Base class for generic data which is associated with an id |
62 | > | */ |
63 | > | class GenericData{ |
64 | > | public: |
65 | > | GenericData() : id_("UndefinedGenericData"){} |
66 | ||
67 | < | GenericData(const std::string& id) { setID(id); } |
67 | > | GenericData(const std::string& id) { setID(id); } |
68 | ||
69 | < | /** virtual destructor */ |
70 | < | virtual ~GenericData() {} |
69 | > | /** virtual destructor */ |
70 | > | virtual ~GenericData() {} |
71 | ||
72 | ||
73 | < | /** |
74 | < | * Returns the id of this generic data |
75 | < | * |
76 | < | * @return the id of this generic data |
77 | < | * |
78 | < | * @see #setID |
79 | < | */ |
80 | < | const std::string getID() const { return id_; } |
73 | > | /** |
74 | > | * Returns the id of this generic data |
75 | > | * |
76 | > | * @return the id of this generic data |
77 | > | * |
78 | > | * @see #setID |
79 | > | */ |
80 | > | const std::string getID() const { return id_; } |
81 | ||
82 | < | /** |
83 | < | * Sets the id of this generic data |
84 | < | * |
85 | < | * @param id the id to be set |
86 | < | * |
87 | < | * @see #getID |
88 | < | */ |
89 | < | void setID(const std::string& id) { id_ = id; } |
82 | > | /** |
83 | > | * Sets the id of this generic data |
84 | > | * |
85 | > | * @param id the id to be set |
86 | > | * |
87 | > | * @see #getID |
88 | > | */ |
89 | > | void setID(const std::string& id) { id_ = id; } |
90 | ||
91 | ||
92 | < | private: |
93 | < | GenericData(const GenericData&); |
94 | < | GenericData& operator=(GenericData&); |
95 | < | std::string id_; |
92 | > | private: |
93 | > | GenericData(const GenericData&); |
94 | > | GenericData& operator=(GenericData&); |
95 | > | std::string id_; |
96 | ||
97 | < | }; |
97 | > | }; |
98 | ||
99 | < | /** |
100 | < | * @class SimpleTypeData |
101 | < | * @brief SimpleTypeData class is a POD repository class |
102 | < | * @warning ElemDataType must be copy constructible, and copy assignable |
103 | < | */ |
104 | < | template<typename ElemDataType> class SimpleTypeData : public GenericData{ |
99 | > | /** |
100 | > | * @class SimpleTypeData |
101 | > | * @brief SimpleTypeData class is a POD repository class |
102 | > | * @warning ElemDataType must be copy constructible, and copy assignable |
103 | > | */ |
104 | > | template<typename ElemDataType> class SimpleTypeData : public GenericData{ |
105 | ||
106 | < | public: |
107 | < | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} |
108 | < | SimpleTypeData(const std::string& id) : GenericData(id), data_(ElemDataType()) {} |
106 | > | public: |
107 | > | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} |
108 | > | SimpleTypeData(const std::string& id) : GenericData(id), data_(ElemDataType()) {} |
109 | > | SimpleTypeData(const std::string&id , const ElemDataType& data) : GenericData(id), data_(data) {} |
110 | > | template<typename T> |
111 | > | SimpleTypeData(const SimpleTypeData<T>& s) { |
112 | > | data_ = s.getData(); |
113 | > | } |
114 | ||
115 | < | template<typename T> |
116 | < | SimpleTypeData(const SimpleTypeData<T>& s) { |
117 | < | data_ = s.getData(); |
97 | < | } |
98 | < | |
99 | < | SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<ElemDataType>& s) { |
100 | < | if (this == &s) |
101 | < | return *this; |
115 | > | SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<ElemDataType>& s) { |
116 | > | if (this == &s) |
117 | > | return *this; |
118 | ||
119 | < | data_ = s.getData(); |
120 | < | return *this; |
121 | < | } |
119 | > | data_ = s.getData(); |
120 | > | return *this; |
121 | > | } |
122 | ||
123 | < | template<typename T> |
124 | < | SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<T>& s) { |
125 | < | data_ = s.getData(); |
126 | < | return *this; |
127 | < | } |
123 | > | template<typename T> |
124 | > | SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<T>& s) { |
125 | > | data_ = s.getData(); |
126 | > | return *this; |
127 | > | } |
128 | ||
129 | < | /** Returns POD data */ |
130 | < | const ElemDataType& getData() const {return data_;} |
131 | < | ElemDataType& getData() {return data_;} |
132 | < | /** |
133 | < | * Sets POD data |
134 | < | * @data POD data to be set |
135 | < | */ |
136 | < | void setData(const ElemDataType& data) { data_ = data; } |
129 | > | /** Returns POD data */ |
130 | > | const ElemDataType& getData() const {return data_;} |
131 | > | ElemDataType& getData() {return data_;} |
132 | > | /** |
133 | > | * Sets POD data |
134 | > | * @data POD data to be set |
135 | > | */ |
136 | > | void setData(const ElemDataType& data) { data_ = data; } |
137 | ||
138 | < | private: |
139 | < | ElemDataType data_; |
140 | < | }; |
138 | > | private: |
139 | > | ElemDataType data_; |
140 | > | }; |
141 | ||
142 | < | /** BoolGenericData is a generic data type contains a bool variable */ |
143 | < | typedef SimpleTypeData<bool> BoolGenericData; |
142 | > | /** BoolGenericData is a generic data type contains a bool variable */ |
143 | > | typedef SimpleTypeData<bool> BoolGenericData; |
144 | ||
145 | < | /** IntGenericData is a generic data type contains an integer variable */ |
146 | < | typedef SimpleTypeData<int> IntGenericData; |
145 | > | /** IntGenericData is a generic data type contains an integer variable */ |
146 | > | typedef SimpleTypeData<int> IntGenericData; |
147 | ||
148 | < | /** FloatGenericData is a generic data type contains a float variable */ |
149 | < | typedef SimpleTypeData<float> FloatGenericData; |
148 | > | /** FloatGenericData is a generic data type contains a float variable */ |
149 | > | typedef SimpleTypeData<float> FloatGenericData; |
150 | ||
151 | < | /** DoubleGenericData is a generic data type contains a double variable */ |
152 | < | typedef SimpleTypeData<double> DoubleGenericData; |
151 | > | /** DoubleGenericData is a generic data type contains a double variable */ |
152 | > | typedef SimpleTypeData<double> DoubleGenericData; |
153 | ||
154 | < | /** |
155 | < | * @typedef StringGenericData |
156 | < | * A generic data type contains a string variable |
157 | < | * |
158 | < | * @code |
159 | < | * StringGenericData* s = new StringGenericData("MyStringGenericData"); |
160 | < | * PropertyMap propMap; |
161 | < | * GenericData* gdata; |
162 | < | * |
163 | < | * s->setData("OOPSE"); |
164 | < | * propMap->addProperty(s); |
165 | < | * |
166 | < | * gdata = propMap->getProperty("MyStringGenericData"); |
167 | < | * if (gdata != NULL){ |
168 | < | * s = dynamic_cast<StringGenericData*>(gdata); |
169 | < | * if (s != NULL) |
170 | < | * std::cout << s->getData() << std::endl; |
171 | < | * } |
172 | < | * |
173 | < | * @endcode |
174 | < | */ |
175 | < | typedef SimpleTypeData<std::string> StringGenericData; |
154 | > | /** |
155 | > | * @typedef StringGenericData |
156 | > | * A generic data type contains a std::string variable |
157 | > | * |
158 | > | * @code |
159 | > | * StringGenericData* s = new StringGenericData("MyStringGenericData"); |
160 | > | * PropertyMap propMap; |
161 | > | * GenericData* gdata; |
162 | > | * |
163 | > | * s->setData("OOPSE"); |
164 | > | * propMap->addProperty(s); |
165 | > | * |
166 | > | * gdata = propMap->getPropertyByName("MyStringGenericData"); |
167 | > | * if (gdata != NULL){ |
168 | > | * s = dynamic_cast<StringGenericData*>(gdata); |
169 | > | * if (s != NULL) |
170 | > | * std::cout << s->getData() << std::endl; |
171 | > | * } |
172 | > | * |
173 | > | * @endcode |
174 | > | */ |
175 | > | typedef SimpleTypeData<std::string> StringGenericData; |
176 | ||
177 | < | /** |
178 | < | * @class STLContainerTypeData |
179 | < | * @brief STL container type generic data which is associated with an id |
180 | < | * |
181 | < | * @template ContainerType |
182 | < | * @template ElemDataType |
183 | < | */ |
184 | < | template <template<typename ELEM, typename = std::allocator<ELEM> > class ContainerType, |
185 | < | typename ElemDataType > |
186 | < | class STLContainerTypeData : public GenericData, public ContainerType<ElemDataType>{ |
187 | < | public: |
172 | < | typedef STLContainerTypeData<ContainerType, ElemDataType> SelfType; |
173 | < | typedef ContainerType<ElemDataType> STLContainerType; |
177 | > | /** |
178 | > | * @class STLContainerTypeData |
179 | > | * @brief STL container type generic data which is associated with an id |
180 | > | * |
181 | > | * @template ContainerType |
182 | > | * @template ElemDataType |
183 | > | */ |
184 | > | template <typename ElemDataType > |
185 | > | class VectorTypeData : public GenericData { |
186 | > | public: |
187 | > | typedef VectorTypeData<ElemDataType> SelfType; |
188 | ||
189 | < | STLContainerTypeData(const std::string& id) |
190 | < | : GenericData(id), ContainerType<ElemDataType> () {} |
189 | > | VectorTypeData(const std::string& id) |
190 | > | : GenericData(id){} |
191 | ||
192 | < | STLContainerTypeData(const SelfType& s) : SelfType(s){} |
192 | > | VectorTypeData(const SelfType& s) : SelfType(s){} |
193 | ||
194 | < | SelfType& operator =(const SelfType& s){ |
195 | < | if (this == &s) |
196 | < | return *this; |
194 | > | SelfType& operator =(const SelfType& s){ |
195 | > | if (this == &s) |
196 | > | return *this; |
197 | ||
198 | < | STLContainerType::operator=(s); |
199 | < | return *this; |
200 | < | } |
201 | < | }; |
198 | > | this->data_ = s.data_; |
199 | > | return *this; |
200 | > | } |
201 | > | |
202 | > | private: |
203 | > | std::vector<ElemDataType> data_; |
204 | > | }; |
205 | ||
206 | < | /** |
207 | < | * @typedef IntVectorGenericData |
208 | < | * A generic data type contains a vector<int> variable. |
209 | < | */ |
210 | < | typedef STLContainerTypeData<std::vector, int> IntVectorGenericData; |
206 | > | /** |
207 | > | * @typedef IntVectorGenericData |
208 | > | * A generic data type contains a std::vector<int> variable. |
209 | > | */ |
210 | > | typedef VectorTypeData<int> IntVectorGenericData; |
211 | ||
212 | < | /** |
213 | < | * @typedef IntVectorGenericData |
214 | < | * A generic data type contains a vector<float> variable. |
215 | < | */ |
216 | < | typedef STLContainerTypeData<std::vector, float> FloatVectorGenericData; |
212 | > | /** |
213 | > | * @typedef IntVectorGenericData |
214 | > | * A generic data type contains a std::vector<float> variable. |
215 | > | */ |
216 | > | typedef VectorTypeData<float> FloatVectorGenericData; |
217 | ||
218 | < | /** |
219 | < | * @typedef IntVectorGenericData |
220 | < | * A generic data type contains a vector<double> variable. |
221 | < | */ |
222 | < | typedef STLContainerTypeData<std::vector, double> DoubleVectorGenericData; |
218 | > | /** |
219 | > | * @typedef IntVectorGenericData |
220 | > | * A generic data type contains a std::vector<double> variable. |
221 | > | */ |
222 | > | typedef VectorTypeData<double> DoubleVectorGenericData; |
223 | ||
224 | < | /** |
225 | < | * @typedef StringVectorGenericData |
226 | < | * A generic data type contains a vector<string> variable. |
227 | < | * |
228 | < | * @code |
229 | < | * StringVectorGenericData* sv = new StringVectorGenericData("MyStringVector"); |
230 | < | * GenericData* gdata; |
231 | < | * PropertyMap propMap; |
232 | < | * std::vector<std::string>::iterator iter; |
233 | < | * |
234 | < | * sv->push_back("Hello World"); |
235 | < | * sv->push_back("OOPSE"); |
236 | < | * |
237 | < | * propMap.addProperty(sv); |
238 | < | * |
239 | < | * gdata = propMap.getProperty("MyStringVector"); |
240 | < | * |
241 | < | * if (gdata != NULL){ |
242 | < | * |
243 | < | * sv = dynamic_cast<StringVectorGenericData*>(gdata); |
244 | < | * |
245 | < | * if (sv != NULL){ |
246 | < | * for (iter = sv->begin(); iter != sv->end(); ++ iter) |
247 | < | * std::cout << *iter << std::endl; |
248 | < | * } |
249 | < | * } |
250 | < | * @endcode |
251 | < | */ |
252 | < | typedef STLContainerTypeData<std::vector, std::string> StringVectorGenericData; |
236 | < | |
237 | < | /** |
238 | < | * @typedef IntVectorGenericData |
239 | < | * A generic data type contains a list<vector<string> > variable. |
240 | < | */ |
241 | < | typedef STLContainerTypeData<std::list, std::vector<int> > IntVectorListGenericData; |
224 | > | /** |
225 | > | * @typedef StringVectorGenericData |
226 | > | * A generic data type contains a std::vector<string> variable. |
227 | > | * |
228 | > | * @code |
229 | > | * StringVectorGenericData* sv = new StringVectorGenericData("MyStringVector"); |
230 | > | * GenericData* gdata; |
231 | > | * PropertyMap propMap; |
232 | > | * std::vector<std::string>::iterator iter; |
233 | > | * |
234 | > | * sv->push_back("Hello World"); |
235 | > | * sv->push_back("OOPSE"); |
236 | > | * |
237 | > | * propMap.addProperty(sv); |
238 | > | * |
239 | > | * gdata = propMap.getPropertyByName("MyStringVector"); |
240 | > | * |
241 | > | * if (gdata != NULL){ |
242 | > | * |
243 | > | * sv = dynamic_cast<StringVectorGenericData*>(gdata); |
244 | > | * |
245 | > | * if (sv != NULL){ |
246 | > | * for (iter = sv->begin(); iter != sv->end(); ++ iter) |
247 | > | * std::cout << *iter << std::endl; |
248 | > | * } |
249 | > | * } |
250 | > | * @endcode |
251 | > | */ |
252 | > | typedef VectorTypeData<std::string> StringVectorGenericData; |
253 | ||
243 | – | #define CHIVALUE_ID "CHIVALUE" |
244 | – | #define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT" |
245 | – | #define ETAVALUE_ID "ETAVALUE" |
254 | ||
255 | } // namespace oopse | |
256 | #endif //UTIL _GENERICDATA_HPP |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |