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"
#include <log4cxx/logger.h>


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*);
        virtual ~Manager();
        //virtual ~Manager(){};
        void cleanup();   
        //virtual int read(Message*, Message&){};
        //virtual void write(Message*, Message&);
  
protected:
        DBManagement* dbManager;
        Util util;
        Dictionary* schema;
        log4cxx::LoggerPtr logger;
};


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;
};

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

private:
        BlockviewMultiTable* blockTable;
};


#endif
Revision:	1.4
Committed:	Wed Dec 14 20:13:23 2005 UTC (19 years, 4 months ago) by sekhri
Branch:	MAIN
CVS Tags:	before_message_removal, preXOverChanges
Changes since 1.3:	+10 -0 lines
Log Message:	CreateBlock and getProcessedDataset api calls implemented and integrated with Top level API
#	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	afaq	1.3	#include <log4cxx/logger.h>
22	afaq	1.1
23
24			typedef vector<RowInterface*> Rows;
25			typedef Rows::iterator RowIter;
26
27			class Manager {
28
29			public:
30
31			Manager();
32			Manager(std::string, std::string);
33
34			int doInsert(TableInterface* inTable, Message& msgReturned);
35			//int doSelect(TableInterface* inTable, std::string whereClause, Message& msgReturned);
36			int makeMessage(TableInterface* inTable, RowIter b, RowIter e, Message& msgReturned);
37			int setRowValues(TableInterface* inTable, RowInterface* rowPtr, Message* message, std::string listName, int index);
38			string findKeyMakeQuery(Message* msgReceived);
39
40			std::string getElementValue(std::string name, Message*);
41	afaq	1.2	virtual ~Manager();
42			//virtual ~Manager(){};
43			void cleanup();
44	afaq	1.3	//virtual int read(Message*, Message&){};
45	afaq	1.1	//virtual void write(Message*, Message&);
46
47			protected:
48			DBManagement* dbManager;
49			Util util;
50			Dictionary* schema;
51	afaq	1.3	log4cxx::LoggerPtr logger;
52	afaq	1.1	};
53
54
55
56			class DatasetProvcManagerParent: public Manager {
57			public:
58			DatasetProvcManagerParent();
59			int read(Message*, Message&);
60			~DatasetProvcManagerParent();
61
62			private:
63			DatasetprovenenceevparentMultiTable* dspTable;
64			};
65
66
67
68			class DatasetProvcManagerChild: public Manager {
69			public:
70			DatasetProvcManagerChild();
71			int read(Message*, Message&);
72			~DatasetProvcManagerChild();
73
74			private:
75			DatasetprovenenceevchildMultiTable* dspTable;
76			};
77
78
79			class ECReadManager : public Manager {
80			public:
81			ECReadManager();
82			int read(Message*, Message&);
83			~ECReadManager();
84
85			private:
86			EvcollviewMultiTable* ecTable;
87			};
88
89
90			class CRABECReadManager : public Manager {
91			public:
92			CRABECReadManager();
93			int read(Message*, Message&);
94			~CRABECReadManager();
95
96			private:
97			CrabevcollviewMultiTable* ecTable;
98			};
99
100
101			class PrimaryDatasetManager : public Manager {
102			public:
103			PrimaryDatasetManager();
104			int write(Message*, Message&);
105			int read(Message*, Message&);
106			~PrimaryDatasetManager();
107
108			private:
109			PrimarydatasetMultiTable* priDatasetTable;
110			};
111
112
113
114			class ProcessedDatasetManager : public Manager {
115			public:
116			ProcessedDatasetManager();
117			int write(Message*, Message&);
118			int read(Message* , Message& );
119			~ProcessedDatasetManager();
120
121			private:
122			ProcessingpathMultiTable* processedDatasetTable;
123			};
124
125			/*
126			class GenParamManager : public Manager {
127			public:
128			GenParamManager();
129			int write(Message*, Message&);
130			~GenParamManager();
131
132			private:
133			GenparametersetsMultiTable* genparametersetsTable;
134			};
135			*/
136
137			class AppConfigManager : public Manager {
138			public:
139			AppConfigManager();
140			int write(Message*, Message&);
141			~AppConfigManager();
142
143			private:
144			InsertappsMultiTable* appsConfigTable;
145			};
146
147
148			class FileManager : public Manager {
149			public:
150			FileManager();
151			int write(Message*, Message&);
152			int read(Message*, Message&);
153			~FileManager();
154
155			private:
156			FileviewMultiTable* fileTable;
157			};
158
159
160			class ECWriteManager : public Manager {
161			public:
162			ECWriteManager();
163			int write(Message*, Message&);
164			~ECWriteManager();
165
166			private:
167			EvcollviewMultiTable* ecTable;
168			};
169
170			/*
171			class AssignRoleManager : public Manager {
172			public:
173			AssignRoleManager();
174			int write(Message*, Message&);
175			~AssignRoleManager();
176
177			private:
178			AdministrativeMultiTable* assignRoleTable;
179			};
180
181			*/
182			class PersonManager : public Manager {
183			public:
184			PersonManager();
185			int write(Message*, Message&);
186			~PersonManager();
187
188			private:
189			PersonMultiTable* personTable;
190			};
191			/*
192			class RoleManager : public Manager {
193			public:
194			RoleManager();
195			int write(Message*, Message&);
196			~RoleManager();
197
198			private:
199			RoleMultiTable* roleTable;
200			};
201			*/
202
203			class AnalysisDatasetManager : public Manager {
204			public:
205			AnalysisDatasetManager();
206			int write(Message*, Message&);
207			~AnalysisDatasetManager();
208
209			private:
210			AnalysisdatasetMultiTable* analysisDatasetTable;
211			};
212
213			class PhysicsGroupManager : public Manager {
214			public:
215			PhysicsGroupManager();
216			int write(Message*, Message&);
217			~PhysicsGroupManager();
218
219			private:
220			PhysicsgroupMultiTable* physicsgroupTable;
221			};
222
223	sekhri	1.4	class BlockManager : public Manager {
224			public:
225			BlockManager();
226			int write(Message*, Message&);
227			~BlockManager();
228
229			private:
230			BlockviewMultiTable* blockTable;
231			};
232
233	afaq	1.1
234			#endif