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
#	Content
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	#include <log4cxx/logger.h>
22
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	virtual ~Manager();
42	//virtual ~Manager(){};
43	void cleanup();
44	//virtual int read(Message*, Message&){};
45	//virtual void write(Message*, Message&);
46
47	protected:
48	DBManagement* dbManager;
49	Util util;
50	Dictionary* schema;
51	log4cxx::LoggerPtr logger;
52	};
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	class BlockManager : public Manager {
224	public:
225	BlockManager();
226	int write(Message*, Message&);
227	~BlockManager();
228
229	private:
230	BlockviewMultiTable* blockTable;
231	};
232
233
234	#endif