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.1.1 (vendor branch)
Committed:	Mon Oct 31 22:10:36 2005 UTC (19 years, 6 months ago) by afaq
Branch:	v00
CVS Tags:	start
Changes since 1.1:	+0 -0 lines
Log Message:	Adding Server code to the repository
#	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
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