OOPSE/libmdtools/GenericData.hpp

#ifndef __GENERICDATA_H__
#define __GENERICDATA_H__

#include <algorithm>
#include <string>
#include <vector>

#define ZCONSTIME_ID            "ZCONSTIME"
#define ZCONSPARADATA_ID    "ZCONSPARA"
#define ZCONSFILENAME_ID     "ZCONSFILENAME"
#define ZCONSTOL_ID              "ZCONSTOL"
#define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
#define ZCONSGAP_ID "ZCONSGAP"
#define ZCONSFIXTIME_ID "ZCONSFIXTIME"

#define CHIVALUE_ID "CHIVALUE"
#define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
#define ETAVALUE_ID "ETAVALUE"

using namespace std;

class GenericData
{
  public:
    GenericData();
    GenericData(const GenericData& rhs)  {  id = rhs.getID(); }
    GenericData& operator =(const GenericData& rhs);
    virtual ~GenericData() {}

    const string& getID() const {  return id; }
    void setID(string rhs)     {  id = rhs;  }

  protected:
    string id;
};

/** Something we can improve it here is to use template
 **
 */
class DoubleData : public GenericData{

  public:

    double getData()         { return data; }
    void setData(double rhs) { data = rhs;  }

  protected:
    double data;
};

class StringData : public GenericData{

  public:
    const string& getData() const  {  return data; }
    void setData(const string& rhs) {  data = rhs;  }
  protected:
    string data;
};

struct ZConsParaItem {
  int zconsIndex;
  bool havingZPos;
  double zPos;
  double kRatio;
};

class ZConsParaData : public GenericData{

  public:
    ZConsParaData();
    void addItem(ZConsParaItem& item) {data.push_back(item);}
    vector<ZConsParaItem>* getData() {return &data;}
    void setData(vector<ZConsParaItem>& theData) {data = theData;}
    void sortByIndex();
    bool isIndexUnique();

  private:
    vector<ZConsParaItem> data;
  };

class ZConsParaSortCriterion{
  public:
    bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
      return item1.zconsIndex < item2.zconsIndex;
    }

};

class DoubleArrayData : public GenericData{

 public:
   vector<double> getData() const  {  return data; }
   void setData(double* source, int num){
    data.clear();
    for(int i = 0; i < num; i++)
     data.push_back(source[i]);
   }
 protected:
   vector<double> data;
};
#endif
Revision:	1091
Committed:	Tue Mar 16 19:22:56 2004 UTC (20 years, 5 months ago) by tim
File size:	2204 byte(s)
Log Message:	ZConstraint now can support sequential moving. Refactorying is needed to support SMD in ZConstraint
#	User	Rev	Content
1	tim	658	#ifndef __GENERICDATA_H__
2			#define __GENERICDATA_H__
3
4	tim	682	#include <algorithm>
5	tim	658	#include <string>
6			#include <vector>
7
8	tim	682	#define ZCONSTIME_ID "ZCONSTIME"
9			#define ZCONSPARADATA_ID "ZCONSPARA"
10			#define ZCONSFILENAME_ID "ZCONSFILENAME"
11			#define ZCONSTOL_ID "ZCONSTOL"
12	tim	699	#define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
13	tim	1091	#define ZCONSGAP_ID "ZCONSGAP"
14			#define ZCONSFIXTIME_ID "ZCONSFIXTIME"
15	tim	682
16	tim	837	#define CHIVALUE_ID "CHIVALUE"
17			#define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
18			#define ETAVALUE_ID "ETAVALUE"
19
20	tim	658	using namespace std;
21
22			class GenericData
23			{
24			public:
25			GenericData();
26			GenericData(const GenericData& rhs) { id = rhs.getID(); }
27			GenericData& operator =(const GenericData& rhs);
28			virtual ~GenericData() {}
29	tim	837
30	tim	658	const string& getID() const { return id; }
31	tim	837	void setID(string rhs) { id = rhs; }
32
33	tim	658	protected:
34			string id;
35			};
36
37			/** Something we can improve it here is to use template
38	tim	837	**
39	tim	658	*/
40			class DoubleData : public GenericData{
41
42			public:
43
44			double getData() { return data; }
45			void setData(double rhs) { data = rhs; }
46	tim	837
47	tim	658	protected:
48			double data;
49			};
50
51			class StringData : public GenericData{
52	tim	837
53			public:
54	tim	658	const string& getData() const { return data; }
55			void setData(const string& rhs) { data = rhs; }
56			protected:
57	tim	837	string data;
58	tim	658	};
59	tim	682
60	mmeineke	789	struct ZConsParaItem {
61	tim	682	int zconsIndex;
62			bool havingZPos;
63			double zPos;
64			double kRatio;
65			};
66
67			class ZConsParaData : public GenericData{
68	tim	837
69			public:
70	tim	682	ZConsParaData();
71			void addItem(ZConsParaItem& item) {data.push_back(item);}
72			vector<ZConsParaItem>* getData() {return &data;}
73			void setData(vector<ZConsParaItem>& theData) {data = theData;}
74			void sortByIndex();
75	tim	736	bool isIndexUnique();
76	tim	837
77			private:
78	tim	682	vector<ZConsParaItem> data;
79			};
80
81			class ZConsParaSortCriterion{
82			public:
83			bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
84			return item1.zconsIndex < item2.zconsIndex;
85			}
86
87			};
88
89	tim	837	class DoubleArrayData : public GenericData{
90
91			public:
92			vector<double> getData() const { return data; }
93			void setData(double* source, int num){
94			data.clear();
95			for(int i = 0; i < num; i++)
96			data.push_back(source[i]);
97			}
98			protected:
99			vector<double> data;
100			};
101	tim	658	#endif