ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/utils/GenericData.hpp
(Generate patch)

Comparing trunk/src/utils/GenericData.hpp (file contents):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC

# Line 1 | Line 1
1 < #ifndef __GENERICDATA_H__
2 < #define __GENERICDATA_H__
1 > /*
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 >
42 > /**
43 > * @file GenericData.hpp
44 > * @brief
45 > * @author tlin
46 > * @date 09/20/2004
47 > * @time 9:30am
48 > * @version 1.0
49 > */
50 >
51 > #ifndef UTIL_GENERICDATA_HPP
52 > #define UTIL_GENERICDATA_HPP
53  
54 < #include <algorithm>
54 > #include <list>
55   #include <string>
56   #include <vector>
57 + #include "config.h"
58 + namespace oopse{
59  
60 < #define ZCONSTIME_ID            "ZCONSTIME"
61 < #define ZCONSPARADATA_ID    "ZCONSPARA"
62 < #define ZCONSFILENAME_ID     "ZCONSFILENAME"
63 < #define ZCONSTOL_ID              "ZCONSTOL"
64 < #define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
65 < #define ZCONSGAP_ID "ZCONSGAP"
66 < #define ZCONSFIXTIME_ID "ZCONSFIXTIME"
15 < #define ZCONSUSINGSMD_ID "ZCONSUSINGSMD"
60 >  /**
61 >   * @ class GenericData GenericData.hpp "utils/GenericData.hpp"
62 >   * @brief Base class for generic data which is associated with an id
63 >   */
64 >  class GenericData{
65 >  public:
66 >    GenericData() :  id_("UndefinedGenericData"){}
67  
68 < #define CHIVALUE_ID "CHIVALUE"
18 < #define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
19 < #define ETAVALUE_ID "ETAVALUE"
68 >    GenericData(const std::string& id) {  setID(id);  }
69  
70 < using namespace std;
22 < ////////////////////////////////////////////////////////////////////////////////
23 < //Declaration of GenericData
24 < ////////////////////////////////////////////////////////////////////////////////
25 < class GenericData
26 < {
27 <  public:
28 <    GenericData();
29 <    GenericData(const GenericData& rhs)  {  id = rhs.getID(); }
30 <    GenericData& operator =(const GenericData& rhs);
70 >    /** virtual destructor */
71      virtual ~GenericData() {}
72  
33 –    const string& getID() const {  return id; }
34 –    void setID(const string& rhs)     {  id = rhs;  }
73  
74 <  protected:
75 <    string id;
76 < };
74 >    /**
75 >     *  Returns the id of this generic data
76 >     *
77 >     * @return the id of this generic data
78 >     *
79 >     * @see #setID
80 >     */
81 >    const std::string getID() const { return id_;  }
82  
83 < /**
84 < * Something we can improve it here is to use template
85 < */
86 < ////////////////////////////////////////////////////////////////////////////////
87 < //Declaration of IntData
88 < ////////////////////////////////////////////////////////////////////////////////
89 < class IntData : public GenericData{
83 >    /**
84 >     *  Sets the id of this generic data
85 >     *
86 >     * @param id the id to be set
87 >     *
88 >     * @see #getID
89 >     */
90 >    void setID(const std::string& id) { id_ = id;  }
91  
92 <  public:
92 >            
93 >  private:
94 >    GenericData(const GenericData&);
95 >    GenericData& operator=(GenericData&);
96 >    std::string id_;
97  
98 <    double getData()         { return data; }
51 <    void setData(int rhs) { data = rhs;  }
98 >  };
99  
100 <  protected:
101 <    int data;
102 < };
100 >  /**
101 >   * @class SimpleTypeData
102 >   * @brief SimpleTypeData class is a POD  repository class
103 >   * @warning ElemDataType must be copy constructible, and copy assignable
104 >   */
105 >  template<typename ElemDataType> class SimpleTypeData : public GenericData{
106  
57 – ////////////////////////////////////////////////////////////////////////////////
58 – //Declaration of DoubleData
59 – ////////////////////////////////////////////////////////////////////////////////
60 – class DoubleData : public GenericData{
61 –
107    public:
108 +    SimpleTypeData() :  GenericData(), data_(ElemDataType()) {}
109 +    SimpleTypeData(const std::string& id) : GenericData(id), data_(ElemDataType()) {}
110 +    SimpleTypeData(const std::string&id , const ElemDataType& data) : GenericData(id), data_(data) {}
111 +    template<typename T>
112 +    SimpleTypeData(const SimpleTypeData<T>& s) {
113 +      data_ = s.getData();
114 +    }
115  
116 <    double getData()         { return data; }
117 <    void setData(double rhs) { data = rhs;  }
116 >    SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<ElemDataType>& s) {
117 >      if (this == &s)
118 >        return *this;
119 >                
120 >      data_ = s.getData();
121 >      return *this;                
122 >    }
123 >            
124 >    template<typename T>
125 >    SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<T>& s) {                
126 >      data_ = s.getData();
127 >      return *this;
128 >    }
129 >            
130 >    /** Returns POD data */    
131 >    const ElemDataType& getData() const {return data_;}
132 >    ElemDataType& getData()  {return data_;}
133 >    /**
134 >     * Sets POD data
135 >     * @data POD data to be set
136 >     */
137 >    void setData(const ElemDataType& data) { data_ = data;  }
138  
139 <  protected:
140 <    double data;
141 < };
139 >  private:
140 >    ElemDataType data_;
141 >  };
142  
143 < ////////////////////////////////////////////////////////////////////////////////
144 < //Declaration of StringData
73 < ////////////////////////////////////////////////////////////////////////////////
74 < class StringData : public GenericData{
143 >  /** BoolGenericData is a generic data type contains a bool variable */
144 >  typedef SimpleTypeData<bool> BoolGenericData;
145  
146 <  public:
147 <    const string& getData() const  {  return data; }
78 <    void setData(const string& rhs) {  data = rhs;  }
79 <  protected:
80 <    string data;
81 < };
146 >  /** IntGenericData is a generic data type contains an integer variable */
147 >  typedef SimpleTypeData<int> IntGenericData;
148  
149 < ////////////////////////////////////////////////////////////////////////////////
150 < //Declaration of BoolData
85 < ////////////////////////////////////////////////////////////////////////////////
86 < class BoolData : public GenericData{
87 <  public:
88 <    bool getData() const  {  return data; }
89 <    void setData(const bool rhs) {  data = rhs;  }
90 <  protected:
91 <    bool data;
149 >  /** FloatGenericData is a generic data type contains a float variable */
150 >  typedef SimpleTypeData<float> FloatGenericData;
151  
152 < };
152 >  /** DoubleGenericData is a generic data type contains a RealType variable */
153 >  typedef SimpleTypeData<RealType> DoubleGenericData;
154 >  
155 >  /**
156 >   * @typedef StringGenericData
157 >   * A generic data type contains a  std::string variable
158 >   *
159 >   * @code
160 >   *   StringGenericData* s = new StringGenericData("MyStringGenericData");
161 >   *   PropertyMap propMap;
162 >   *   GenericData* gdata;
163 >   *
164 >   *   s->setData("OOPSE");
165 >   *   propMap->addProperty(s);
166 >   *  
167 >   *   gdata = propMap->getPropertyByName("MyStringGenericData");
168 >   *   if (gdata != NULL){
169 >   *     s = dynamic_cast<StringGenericData*>(gdata);
170 >   *     if (s != NULL)
171 >   *       std::cout << s->getData() << std::endl;
172 >   *   }
173 >   *
174 >   * @endcode
175 >   */  
176 >  typedef SimpleTypeData<std::string> StringGenericData;
177  
178 < ////////////////////////////////////////////////////////////////////////////////
179 < //Declaration of ZConsParaData
180 < ////////////////////////////////////////////////////////////////////////////////
181 < struct ZConsParaItem {
182 <  int zconsIndex;
183 <  bool havingZPos;
184 <  double zPos;
185 <  double kRatio;
186 <  bool havingCantVel;
187 <  double cantVel;
188 < };
178 >  /**
179 >   * @class STLContainerTypeData
180 >   * @brief STL container type generic data which is associated with an id
181 >   *
182 >   * @template ContainerType
183 >   * @template ElemDataType
184 >   */
185 >  template <typename ElemDataType >
186 >  class VectorTypeData : public GenericData {
187 >  public:
188 >    typedef VectorTypeData<ElemDataType> SelfType;
189  
190 < class ZConsParaData : public GenericData{
190 >    VectorTypeData(const std::string& id)
191 >      : GenericData(id){}
192 >            
193 >    VectorTypeData(const SelfType& s) : data_(s){}
194  
195 <  public:
196 <    ZConsParaData();
197 <    void addItem(ZConsParaItem& item) {data.push_back(item);}
112 <    vector<ZConsParaItem>* getData() {return &data;}
113 <    void setData(vector<ZConsParaItem>& theData) {data = theData;}
114 <    void sortByIndex();
115 <    bool isIndexUnique();
195 >    SelfType& operator =(const SelfType& s){
196 >      if (this == &s)
197 >        return *this;
198  
199 +      this->data_ = s.data_;
200 +      return *this;
201 +    }
202 +            
203    private:
204 <    vector<ZConsParaItem> data;
204 >    std::vector<ElemDataType> data_;
205    };
206  
207 < class ZConsParaSortCriterion{
208 <  public:
209 <    bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
210 <      return item1.zconsIndex < item2.zconsIndex;
211 <    }
207 >  /**
208 >   * @typedef IntVectorGenericData
209 >   * A generic data type contains a  std::vector<int> variable.
210 >   */  
211 >  typedef VectorTypeData<int> IntVectorGenericData;
212  
213 < };
213 >  /**
214 >   * @typedef IntVectorGenericData
215 >   * A generic data type contains a  std::vector<float> variable.
216 >   */  
217 >  typedef VectorTypeData<float> FloatVectorGenericData;
218  
219 < ////////////////////////////////////////////////////////////////////////////////
220 < //Declaration of IntData
221 < ////////////////////////////////////////////////////////////////////////////////
222 < class DoubleArrayData : public GenericData{
219 >  /**
220 >   * @typedef IntVectorGenericData
221 >   * A generic data type contains a  std::vector<RealType> variable.
222 >   */  
223 >  typedef VectorTypeData<RealType> DoubleVectorGenericData;
224  
225 < public:
226 <   vector<double> getData() const  {  return data; }
227 <   void setData(double* source, int num){
228 <    data.clear();
229 <    for(int i = 0; i < num; i++)
230 <     data.push_back(source[i]);
231 <   }
232 < protected:
233 <   vector<double> data;
234 < };
225 >  /**
226 >   * @typedef StringVectorGenericData
227 >   *  A generic data type contains a  std::vector<string> variable.
228 >   *
229 >   * @code
230 >   *  StringVectorGenericData* sv = new StringVectorGenericData("MyStringVector");
231 >   *  GenericData* gdata;
232 >   *  PropertyMap propMap;
233 >   *  std::vector<std::string>::iterator iter;
234 >   *  
235 >   *  sv->push_back("Hello World");
236 >   *  sv->push_back("OOPSE");
237 >   *
238 >   *  propMap.addProperty(sv);
239 >   *  
240 >   *  gdata = propMap.getPropertyByName("MyStringVector");
241 >   *
242 >   *  if (gdata != NULL){
243 >   *
244 >   *    sv = dynamic_cast<StringVectorGenericData*>(gdata);
245 >   *
246 >   *    if (sv != NULL){
247 >   *      for (iter = sv->begin(); iter != sv->end(); ++ iter)
248 >   *        std::cout << *iter << std::endl;
249 >   *    }
250 >   *  }
251 >   * @endcode
252 >   */  
253 >  typedef VectorTypeData<std::string> StringVectorGenericData;
254 >  
255  
256 < ////////////////////////////////////////////////////////////////////////////////
257 < //Declaration of AtomData
147 < ////////////////////////////////////////////////////////////////////////////////
148 < struct AtomInfo : public GenericData{
149 <  public:
150 <    string AtomType;
151 <    double pos[3];
152 <    double dipole[3];  
153 < };
154 <
155 < class AtomData : public GenericData{
156 <  public:
157 <    ~AtomData();
158 <    void addAtomInfo(AtomInfo* info) {data.push_back(info);}
159 <    void clearAllAtomInfo();
160 <    AtomInfo* beginAtomInfo(vector<AtomInfo*>::iterator& i){
161 <      i = data.begin();
162 <      return i != data.end()? *i : NULL;
163 <    }
164 <    AtomInfo* nextAtomInfo(vector<AtomInfo*>::iterator& i){
165 <      ++i;
166 <      return i != data.end()? *i: NULL;
167 <    }
168 <    vector<AtomInfo*> getData() {return data;}
169 <    int getSize() {return data.size();}
170 <  protected:
171 <    vector<AtomInfo*> data;
172 < };
173 <
174 < #endif
256 > } // namespace oopse
257 > #endif //UTIL _GENERICDATA_HPP

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines