AppServer/include/Managers.hpp

#ifndef _MANAGER_H_
#define _MANAGER_H_
///Class that creates a manager
///parent class of all managers
/// creates DBManager 


#define USERDSN "mydsnvijay"
//#define USERDSN "thinservertest"
#define USERNAME "ggraham"
//#define USERNAME "anzar"

#include "DBManagement.hpp"
#include "TableInterface.hpp"
#include "ObjectLayerTables.hpp"
#include "Message.hpp"
#include "TableInterface.hpp"
#include "Util.hpp"
#include <string>
#include "RowInterface.hpp"


typedef vector<RowInterface*> Rows;
typedef Rows::iterator RowIter;

class Manager {

public:

        Manager();
        Manager(std::string, std::string);

        int doInsert(TableInterface* inTable, Message& msgReturned);
        //int doSelect(TableInterface* inTable, std::string whereClause, Message& msgReturned);
        int makeMessage(TableInterface* inTable, RowIter b, RowIter e, Message& msgReturned);
        int setRowValues(TableInterface* inTable, RowInterface* rowPtr, Message* message, std::string listName, int index);
        string findKeyMakeQuery(Message* msgReceived);

        std::string getElementValue(std::string name, Message*);
        ~Manager();
        //virtual void read(Message*, Message&);
        //virtual void write(Message*, Message&);
  
protected:
        DBManagement* dbManager;
        Util util;
        Dictionary* schema;
};


class DatasetProvcManagerParent: public Manager {
public:
        DatasetProvcManagerParent();
        int read(Message*, Message&);
        ~DatasetProvcManagerParent();

private:
        DatasetprovenenceevparentMultiTable* dspTable;
};


class DatasetProvcManagerChild: public Manager {
public:
        DatasetProvcManagerChild();
        int read(Message*, Message&);
        ~DatasetProvcManagerChild();

private:
        DatasetprovenenceevchildMultiTable* dspTable;
};


class ECReadManager : public Manager {
public:
        ECReadManager();
        int read(Message*, Message&);
        ~ECReadManager();

private:
        EvcollviewMultiTable* ecTable;
};


class CRABECReadManager : public Manager {
public: 
        CRABECReadManager();
        int read(Message*, Message&);
        ~CRABECReadManager();

private:
        CrabevcollviewMultiTable* ecTable;
};


class PrimaryDatasetManager : public Manager {
public:
        PrimaryDatasetManager();
        int write(Message*, Message&);
        int read(Message*, Message&);
        ~PrimaryDatasetManager();

private:
        PrimarydatasetMultiTable* priDatasetTable;
};


class ProcessedDatasetManager : public Manager {
public:
        ProcessedDatasetManager();
        int write(Message*, Message&);
        int read(Message* , Message& );
        ~ProcessedDatasetManager();  

private:
        ProcessingpathMultiTable* processedDatasetTable;
};

/*
class GenParamManager : public Manager {
public:
        GenParamManager();
        int write(Message*, Message&);
        ~GenParamManager();  

private:
        GenparametersetsMultiTable* genparametersetsTable;
};
*/

class AppConfigManager : public Manager {
public:
        AppConfigManager();
        int write(Message*, Message&);
        ~AppConfigManager();  

private:
        InsertappsMultiTable* appsConfigTable;
};


class FileManager : public Manager {
public:
        FileManager();
        int write(Message*, Message&);
        int read(Message*, Message&);
        ~FileManager();  

private:
        FileviewMultiTable* fileTable;
};


class ECWriteManager : public Manager {
public:
        ECWriteManager();
        int write(Message*, Message&);
        ~ECWriteManager();  

private:
        EvcollviewMultiTable* ecTable;
};

/*
class AssignRoleManager : public Manager {
public:
        AssignRoleManager();
        int write(Message*, Message&);
        ~AssignRoleManager();  

private:
        AdministrativeMultiTable* assignRoleTable;
};

*/
class PersonManager : public Manager {
public:
        PersonManager();
        int write(Message*, Message&);
        ~PersonManager();  

private:
        PersonMultiTable* personTable;
};
/*
class RoleManager : public Manager {
public:
        RoleManager();
        int write(Message*, Message&);
        ~RoleManager();  

private:
        RoleMultiTable* roleTable;
};
*/

class AnalysisDatasetManager : public Manager {
public:
        AnalysisDatasetManager();
        int write(Message*, Message&);
        ~AnalysisDatasetManager();  

private:
        AnalysisdatasetMultiTable* analysisDatasetTable;
};

class PhysicsGroupManager : public Manager {
public:
        PhysicsGroupManager();
        int write(Message*, Message&);
        ~PhysicsGroupManager();  

private:
        PhysicsgroupMultiTable* physicsgroupTable;
};


#endif
Revision:	1.1
Committed:	Mon Oct 31 22:10:36 2005 UTC (19 years, 6 months ago) by afaq
Branch:	MAIN
Branch point for:	v00
Log Message:	Initial revision
#	User	Rev	Content
1	afaq	1.1	#ifndef _MANAGER_H_
2			#define _MANAGER_H_
3			///Class that creates a manager
4			///parent class of all managers
5			/// creates DBManager
6
7
8			#define USERDSN "mydsnvijay"
9			//#define USERDSN "thinservertest"
10			#define USERNAME "ggraham"
11			//#define USERNAME "anzar"
12
13			#include "DBManagement.hpp"
14			#include "TableInterface.hpp"
15			#include "ObjectLayerTables.hpp"
16			#include "Message.hpp"
17			#include "TableInterface.hpp"
18			#include "Util.hpp"
19			#include <string>
20			#include "RowInterface.hpp"
21
22
23			typedef vector<RowInterface*> Rows;
24			typedef Rows::iterator RowIter;
25
26			class Manager {
27
28			public:
29
30			Manager();
31			Manager(std::string, std::string);
32
33			int doInsert(TableInterface* inTable, Message& msgReturned);
34			//int doSelect(TableInterface* inTable, std::string whereClause, Message& msgReturned);
35			int makeMessage(TableInterface* inTable, RowIter b, RowIter e, Message& msgReturned);
36			int setRowValues(TableInterface* inTable, RowInterface* rowPtr, Message* message, std::string listName, int index);
37			string findKeyMakeQuery(Message* msgReceived);
38
39			std::string getElementValue(std::string name, Message*);
40			~Manager();
41			//virtual void read(Message*, Message&);
42			//virtual void write(Message*, Message&);
43
44			protected:
45			DBManagement* dbManager;
46			Util util;
47			Dictionary* schema;
48			};
49
50
51
52			class DatasetProvcManagerParent: public Manager {
53			public:
54			DatasetProvcManagerParent();
55			int read(Message*, Message&);
56			~DatasetProvcManagerParent();
57
58			private:
59			DatasetprovenenceevparentMultiTable* dspTable;
60			};
61
62
63
64			class DatasetProvcManagerChild: public Manager {
65			public:
66			DatasetProvcManagerChild();
67			int read(Message*, Message&);
68			~DatasetProvcManagerChild();
69
70			private:
71			DatasetprovenenceevchildMultiTable* dspTable;
72			};
73
74
75			class ECReadManager : public Manager {
76			public:
77			ECReadManager();
78			int read(Message*, Message&);
79			~ECReadManager();
80
81			private:
82			EvcollviewMultiTable* ecTable;
83			};
84
85
86			class CRABECReadManager : public Manager {
87			public:
88			CRABECReadManager();
89			int read(Message*, Message&);
90			~CRABECReadManager();
91
92			private:
93			CrabevcollviewMultiTable* ecTable;
94			};
95
96
97			class PrimaryDatasetManager : public Manager {
98			public:
99			PrimaryDatasetManager();
100			int write(Message*, Message&);
101			int read(Message*, Message&);
102			~PrimaryDatasetManager();
103
104			private:
105			PrimarydatasetMultiTable* priDatasetTable;
106			};
107
108
109
110			class ProcessedDatasetManager : public Manager {
111			public:
112			ProcessedDatasetManager();
113			int write(Message*, Message&);
114			int read(Message* , Message& );
115			~ProcessedDatasetManager();
116
117			private:
118			ProcessingpathMultiTable* processedDatasetTable;
119			};
120
121			/*
122			class GenParamManager : public Manager {
123			public:
124			GenParamManager();
125			int write(Message*, Message&);
126			~GenParamManager();
127
128			private:
129			GenparametersetsMultiTable* genparametersetsTable;
130			};
131			*/
132
133			class AppConfigManager : public Manager {
134			public:
135			AppConfigManager();
136			int write(Message*, Message&);
137			~AppConfigManager();
138
139			private:
140			InsertappsMultiTable* appsConfigTable;
141			};
142
143
144			class FileManager : public Manager {
145			public:
146			FileManager();
147			int write(Message*, Message&);
148			int read(Message*, Message&);
149			~FileManager();
150
151			private:
152			FileviewMultiTable* fileTable;
153			};
154
155
156			class ECWriteManager : public Manager {
157			public:
158			ECWriteManager();
159			int write(Message*, Message&);
160			~ECWriteManager();
161
162			private:
163			EvcollviewMultiTable* ecTable;
164			};
165
166			/*
167			class AssignRoleManager : public Manager {
168			public:
169			AssignRoleManager();
170			int write(Message*, Message&);
171			~AssignRoleManager();
172
173			private:
174			AdministrativeMultiTable* assignRoleTable;
175			};
176
177			*/
178			class PersonManager : public Manager {
179			public:
180			PersonManager();
181			int write(Message*, Message&);
182			~PersonManager();
183
184			private:
185			PersonMultiTable* personTable;
186			};
187			/*
188			class RoleManager : public Manager {
189			public:
190			RoleManager();
191			int write(Message*, Message&);
192			~RoleManager();
193
194			private:
195			RoleMultiTable* roleTable;
196			};
197			*/
198
199			class AnalysisDatasetManager : public Manager {
200			public:
201			AnalysisDatasetManager();
202			int write(Message*, Message&);
203			~AnalysisDatasetManager();
204
205			private:
206			AnalysisdatasetMultiTable* analysisDatasetTable;
207			};
208
209			class PhysicsGroupManager : public Manager {
210			public:
211			PhysicsGroupManager();
212			int write(Message*, Message&);
213			~PhysicsGroupManager();
214
215			private:
216			PhysicsgroupMultiTable* physicsgroupTable;
217			};
218
219
220			#endif