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

Comparing trunk/OOPSE-3.0/src/utils/GenericData.hpp (file contents):
Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 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 + namespace oopse{
58  
59 < #define ZCONSTIME_ID            "ZCONSTIME"
60 < #define ZCONSPARADATA_ID    "ZCONSPARA"
61 < #define ZCONSFILENAME_ID     "ZCONSFILENAME"
62 < #define ZCONSTOL_ID              "ZCONSTOL"
63 < #define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
64 < #define ZCONSGAP_ID "ZCONSGAP"
65 < #define ZCONSFIXTIME_ID "ZCONSFIXTIME"
15 < #define ZCONSUSINGSMD_ID "ZCONSUSINGSMD"
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 < #define CHIVALUE_ID "CHIVALUE"
18 < #define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
19 < #define ETAVALUE_ID "ETAVALUE"
67 >            GenericData(const std::string& id) {  setID(id);  }
68  
69 < using namespace std;
70 < ////////////////////////////////////////////////////////////////////////////////
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);
31 <    virtual ~GenericData() {}
69 >            /** virtual destructor */
70 >            virtual ~GenericData() {}
71  
33 –    const string& getID() const {  return id; }
34 –    void setID(const string& rhs)     {  id = rhs;  }
72  
73 <  protected:
74 <    string id;
75 < };
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 < * Something we can improve it here is to use template
84 < */
85 < ////////////////////////////////////////////////////////////////////////////////
86 < //Declaration of IntData
87 < ////////////////////////////////////////////////////////////////////////////////
88 < class IntData : public GenericData{
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 <  public:
91 >            
92 >        private:
93 >            GenericData(const GenericData&);
94 >            GenericData& operator=(GenericData&);
95 >            std::string id_;
96  
97 <    double getData()         { return data; }
51 <    void setData(int rhs) { data = rhs;  }
97 >    };
98  
99 <  protected:
100 <    int data;
101 < };
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 < ////////////////////////////////////////////////////////////////////////////////
107 < //Declaration of DoubleData
108 < ////////////////////////////////////////////////////////////////////////////////
109 < class DoubleData : public GenericData{
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 <  public:
115 >            SimpleTypeData<ElemDataType>& operator =(const SimpleTypeData<ElemDataType>& s) {
116 >                if (this == &s)
117 >                    return *this;
118 >                
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 >            }
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;  }
137  
138 <    double getData()         { return data; }
139 <    void setData(double rhs) { data = rhs;  }
138 >        private:
139 >            ElemDataType data_;
140 >    };
141  
142 <  protected:
143 <    double data;
69 < };
142 >    /** BoolGenericData is a generic data type contains a bool variable */
143 >    typedef SimpleTypeData<bool> BoolGenericData;
144  
145 < ////////////////////////////////////////////////////////////////////////////////
146 < //Declaration of StringData
73 < ////////////////////////////////////////////////////////////////////////////////
74 < class StringData : public GenericData{
145 >    /** IntGenericData is a generic data type contains an integer variable */
146 >    typedef SimpleTypeData<int> IntGenericData;
147  
148 <  public:
149 <    const string& getData() const  {  return data; }
78 <    void setData(const string& rhs) {  data = rhs;  }
79 <  protected:
80 <    string data;
81 < };
148 >    /** FloatGenericData is a generic data type contains a float variable */
149 >    typedef SimpleTypeData<float> FloatGenericData;
150  
151 < ////////////////////////////////////////////////////////////////////////////////
152 < //Declaration of BoolData
153 < ////////////////////////////////////////////////////////////////////////////////
154 < class BoolData : public GenericData{
155 <  public:
156 <    bool getData() const  {  return data; }
157 <    void setData(const bool rhs) {  data = rhs;  }
158 <  protected:
159 <    bool data;
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  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 < };
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:
188 >            typedef STLContainerTypeData<ContainerType, ElemDataType> SelfType;
189 >            typedef ContainerType<ElemDataType> STLContainerType;
190  
191 < ////////////////////////////////////////////////////////////////////////////////
192 < //Declaration of ZConsParaData
193 < ////////////////////////////////////////////////////////////////////////////////
194 < struct ZConsParaItem {
99 <  int zconsIndex;
100 <  bool havingZPos;
101 <  double zPos;
102 <  double kRatio;
103 <  bool havingCantVel;
104 <  double cantVel;
105 < };
191 >            STLContainerTypeData(const std::string& id)
192 >                : GenericData(id),  ContainerType<ElemDataType> () {}
193 >            
194 >            STLContainerTypeData(const SelfType& s) : SelfType(s){}
195  
196 < class ZConsParaData : public GenericData{
196 >            SelfType& operator =(const SelfType& s){
197 >                if (this == &s)
198 >                    return *this;
199  
200 <  public:
201 <    ZConsParaData();
202 <    void addItem(ZConsParaItem& item) {data.push_back(item);}
203 <    vector<ZConsParaItem>* getData() {return &data;}
113 <    void setData(vector<ZConsParaItem>& theData) {data = theData;}
114 <    void sortByIndex();
115 <    bool isIndexUnique();
200 >                STLContainerType::operator=(s);
201 >                return *this;
202 >            }
203 >    };
204  
205 <  private:
206 <    vector<ZConsParaItem> data;
207 <  };
205 >    /**
206 >     * @typedef IntVectorGenericData
207 >     * A generic data type contains a  std::vector<int> variable.
208 >     */  
209 >    typedef STLContainerTypeData<std::vector, int> IntVectorGenericData;
210  
211 < class ZConsParaSortCriterion{
212 <  public:
213 <    bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
214 <      return item1.zconsIndex < item2.zconsIndex;
215 <    }
211 >    /**
212 >     * @typedef IntVectorGenericData
213 >     * A generic data type contains a  std::vector<float> variable.
214 >     */  
215 >    typedef STLContainerTypeData<std::vector, float> FloatVectorGenericData;
216  
217 < };
217 >    /**
218 >     * @typedef IntVectorGenericData
219 >     * A generic data type contains a  std::vector<double> variable.
220 >     */  
221 >    typedef STLContainerTypeData<std::vector, double> DoubleVectorGenericData;
222  
223 < ////////////////////////////////////////////////////////////////////////////////
224 < //Declaration of IntData
225 < ////////////////////////////////////////////////////////////////////////////////
226 < class DoubleArrayData : public GenericData{
223 >    /**
224 >     * @typedef StringVectorGenericData
225 >     *  A generic data type contains a  std::vector<string> variable.
226 >     *
227 >     * @code
228 >     *  StringVectorGenericData* sv = new StringVectorGenericData("MyStringVector");
229 >     *  GenericData* gdata;
230 >     *  PropertyMap propMap;
231 >     *  std::vector<std::string>::iterator iter;
232 >     *  
233 >     *  sv->push_back("Hello World");
234 >     *  sv->push_back("OOPSE");
235 >     *
236 >     *  propMap.addProperty(sv);
237 >     *  
238 >     *  gdata = propMap.getPropertyByName("MyStringVector");
239 >     *
240 >     *  if (gdata != NULL){
241 >     *
242 >     *    sv = dynamic_cast<StringVectorGenericData*>(gdata);
243 >     *
244 >     *    if (sv != NULL){
245 >     *      for (iter = sv->begin(); iter != sv->end(); ++ iter)
246 >     *        std::cout << *iter << std::endl;
247 >     *    }
248 >     *  }
249 >     * @endcode
250 >     */  
251 >    typedef STLContainerTypeData<std::vector, std::string> StringVectorGenericData;
252  
253 < public:
254 <   vector<double> getData() const  {  return data; }
255 <   void setData(double* source, int num){
256 <    data.clear();
257 <    for(int i = 0; i < num; i++)
258 <     data.push_back(source[i]);
259 <   }
260 < protected:
261 <   vector<double> data;
143 < };
253 >    /**
254 >     * @typedef IntVectorGenericData
255 >     * A generic data type contains a   std::list<vector<string> >  variable.
256 >     */  
257 >    typedef STLContainerTypeData<std::list, std::vector<int> > IntVectorListGenericData;
258 >  
259 > #define CHIVALUE_ID "CHIVALUE"
260 > #define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
261 > #define ETAVALUE_ID "ETAVALUE"
262  
263 < ////////////////////////////////////////////////////////////////////////////////
264 < //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
263 > } // namespace oopse
264 > #endif //UTIL _GENERICDATA_HPP

Diff Legend

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