AppServer/include/Managers.hpp

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


#include "DBManagement.hpp"
#include "TableInterface.hpp"
#include "ObjectLayerTables.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);
        int doWrite(TableInterface* inTable, std::string name);
        int doWrite(TableInterface* inTable, RowInterface* aRow, std::string name);
        std::string makeClause(TableInterface* inTable, RowInterface* aRow);
        virtual ~Manager();
        void cleanup();   
  
protected:
        DBManagement* dbManager;
        Util util;
        Dictionary* schema;
        log4cxx::LoggerPtr logger;
        void copyAndAddRow(TableInterface* table, RowInterface* aRow, RowInterface* aNewRow);
};


class PrimaryDatasetManager : public Manager {
public:
        PrimaryDatasetManager();
        int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
        int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
        ~PrimaryDatasetManager();

};

class ProcessedDatasetManager : public Manager {
public:
        ProcessedDatasetManager();
        int write(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
        int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
        ~ProcessedDatasetManager();  
};

class ECManager : public Manager {
public:
        ECManager();
        int write(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
        int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
        ~ECManager();  
};

class FileManager : public Manager {
public:
        FileManager();
        int write(std::vector<Fileviewmultirow*> rowVector, FileviewMultiTable* table);
        int read(Fileviewmultirow* aRow, FileviewMultiTable* table);
        ~FileManager();  
};

class BlockManager : public Manager {
public:
        BlockManager();
        int write(Blockviewmultirow* aRow, BlockviewMultiTable* table);
        int read(Blockviewmultirow* aRow, BlockviewMultiTable* table);
        ~BlockManager();  
};


class PdblockManager : public Manager {
public:
        PdblockManager();
        int write(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
        int read(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
        ~PdblockManager();  
};

/*
class DatasetProvcChildManager : public Manager {
public:
        DatasetProvcChildManager();
        int write(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
        int read(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
        ~DatasetProvcChildManager();  
};

class DatasetProvcParentManager : public Manager {
public:
        DatasetProvcParentManager();
        int write(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
        int read(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
        ~DatasetProvcParentManager();  
};
*/

class CrabECManager : public Manager {
public:
        CrabECManager();
        int write(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
        int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
        ~CrabECManager();  
};

#endif
Revision:	1.7
Committed:	Fri Feb 10 19:58:37 2006 UTC (19 years, 2 months ago) by sekhri
Branch:	MAIN
CVS Tags:	AfterJan2006SchemaChanges_v01_00_01
Branch point for:	BranchForCPPWebServiceTesting
Changes since 1.6:	+1 -0 lines
Log Message:	New schme incorporated and Ale's issues fixed
#	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			#include "DBManagement.hpp"
9			#include "TableInterface.hpp"
10			#include "ObjectLayerTables.hpp"
11			#include "TableInterface.hpp"
12			#include "Util.hpp"
13			#include <string>
14			#include "RowInterface.hpp"
15	afaq	1.3	#include <log4cxx/logger.h>
16	afaq	1.1
17
18			typedef vector<RowInterface*> Rows;
19			typedef Rows::iterator RowIter;
20
21			class Manager {
22
23			public:
24
25			Manager();
26			Manager(std::string, std::string);
27
28	sekhri	1.5	int doInsert(TableInterface* inTable);
29			int doWrite(TableInterface* inTable, std::string name);
30			int doWrite(TableInterface* inTable, RowInterface* aRow, std::string name);
31			std::string makeClause(TableInterface* inTable, RowInterface* aRow);
32	afaq	1.2	virtual ~Manager();
33			void cleanup();
34	afaq	1.1
35			protected:
36			DBManagement* dbManager;
37			Util util;
38			Dictionary* schema;
39	afaq	1.3	log4cxx::LoggerPtr logger;
40	sekhri	1.7	void copyAndAddRow(TableInterface* table, RowInterface* aRow, RowInterface* aNewRow);
41	afaq	1.1	};
42
43
44			class PrimaryDatasetManager : public Manager {
45			public:
46			PrimaryDatasetManager();
47	sekhri	1.5	int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
48			int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
49	afaq	1.1	~PrimaryDatasetManager();
50
51			};
52
53			class ProcessedDatasetManager : public Manager {
54			public:
55			ProcessedDatasetManager();
56	sekhri	1.5	int write(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
57			int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
58	afaq	1.1	~ProcessedDatasetManager();
59			};
60
61	sekhri	1.5	class ECManager : public Manager {
62	afaq	1.1	public:
63	sekhri	1.5	ECManager();
64			int write(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
65			int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
66			~ECManager();
67	afaq	1.1	};
68
69			class FileManager : public Manager {
70			public:
71			FileManager();
72	sekhri	1.5	int write(std::vector<Fileviewmultirow> rowVector, FileviewMultiTable table);
73			int read(Fileviewmultirow* aRow, FileviewMultiTable* table);
74	afaq	1.1	~FileManager();
75			};
76
77	sekhri	1.5	class BlockManager : public Manager {
78	afaq	1.1	public:
79	sekhri	1.5	BlockManager();
80			int write(Blockviewmultirow* aRow, BlockviewMultiTable* table);
81			int read(Blockviewmultirow* aRow, BlockviewMultiTable* table);
82			~BlockManager();
83	afaq	1.1	};
84
85
86	afaq	1.6	class PdblockManager : public Manager {
87			public:
88			PdblockManager();
89			int write(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
90			int read(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
91			~PdblockManager();
92			};
93
94			/*
95	sekhri	1.5	class DatasetProvcChildManager : public Manager {
96	afaq	1.1	public:
97	sekhri	1.5	DatasetProvcChildManager();
98			int write(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
99			int read(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
100			~DatasetProvcChildManager();
101	afaq	1.1	};
102
103	sekhri	1.5	class DatasetProvcParentManager : public Manager {
104	afaq	1.1	public:
105	sekhri	1.5	DatasetProvcParentManager();
106			int write(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
107			int read(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
108			~DatasetProvcParentManager();
109	afaq	1.1	};
110	afaq	1.6	*/
111	afaq	1.1
112	sekhri	1.5	class CrabECManager : public Manager {
113	afaq	1.1	public:
114	sekhri	1.5	CrabECManager();
115			int write(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
116			int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
117			~CrabECManager();
118	afaq	1.1	};
119
120			#endif