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(DBManagement* dbManager);
        Manager(std::string, std::string);

        int doInsert(TableInterface* inTable);
        int doUpdate(TableInterface* inTable, std::string name);
        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 PrimaryDatasetAPIManager : public Manager {
class PrimaryDatasetAPIManager  {
public:
        PrimaryDatasetAPIManager();
        int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
        //int write(std::vector<Primarydatasetmultirow*> rowVector, PrimarydatasetMultiTable* table);
        int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
        ~PrimaryDatasetAPIManager();

};

/*
class ProcessedDatasetManager : public Manager {
public:
        ProcessedDatasetManager();
        int write(std::vector<Processingpathmultirow*> rowVector, ProcessingpathMultiTable* table);
        int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
        ~ProcessedDatasetManager();  
};

class EvCollViewManager: public Manager {
public:
        EvCollViewManager();
        int write(std::vector<Evcollviewmultirow*> rowVector, EvcollviewMultiTable* table);
        int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
        ~EvCollViewManager();  
};

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

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

class PDBlockViewManager: public Manager {
public:
        PDBlockViewManager();
        int write(std::vector<Pdblockviewmultirow*> rowVector, 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(std::vector<Crabevcollviewmultirow*> rowVector, CrabevcollviewMultiTable* table);
        int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
        ~CrabECManager();  
};
*/
#endif

Revision:	1.11
Committed:	Fri Apr 21 18:40:42 2006 UTC (19 years ago) by afaq
Branch:	MAIN
CVS Tags:	DBS_0_0_2, DBS_0_0_1, pre_DBS_0_0_1, post_dict_type_checking_merge, post_MiniPythonAPI_merged_to_trunk, pre_MiniPythonAPI_merge_to_trunk, HEAD
Changes since 1.10:	+2 -0 lines
Log Message:	Performance enhanced code
#	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	afaq	1.11	Manager(DBManagement* dbManager);
27	afaq	1.1	Manager(std::string, std::string);
28
29	sekhri	1.5	int doInsert(TableInterface* inTable);
30	afaq	1.11	int doUpdate(TableInterface* inTable, std::string name);
31	sekhri	1.5	int doWrite(TableInterface* inTable, std::string name);
32			int doWrite(TableInterface* inTable, RowInterface* aRow, std::string name);
33			std::string makeClause(TableInterface* inTable, RowInterface* aRow);
34	afaq	1.2	virtual ~Manager();
35			void cleanup();
36	afaq	1.1
37			protected:
38			DBManagement* dbManager;
39			Util util;
40			Dictionary* schema;
41	afaq	1.3	log4cxx::LoggerPtr logger;
42	sekhri	1.7	void copyAndAddRow(TableInterface* table, RowInterface* aRow, RowInterface* aNewRow);
43	afaq	1.1	};
44
45	afaq	1.8	//class PrimaryDatasetAPIManager : public Manager {
46			class PrimaryDatasetAPIManager {
47	afaq	1.1	public:
48	afaq	1.8	PrimaryDatasetAPIManager();
49	sekhri	1.5	int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
50	afaq	1.8	//int write(std::vector<Primarydatasetmultirow> rowVector, PrimarydatasetMultiTable table);
51	sekhri	1.5	int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
52	afaq	1.8	~PrimaryDatasetAPIManager();
53	afaq	1.1
54			};
55
56	afaq	1.8	/*
57	afaq	1.1	class ProcessedDatasetManager : public Manager {
58			public:
59			ProcessedDatasetManager();
60	afaq	1.8	int write(std::vector<Processingpathmultirow> rowVector, ProcessingpathMultiTable table);
61	sekhri	1.5	int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
62	afaq	1.1	~ProcessedDatasetManager();
63			};
64
65	afaq	1.8	class EvCollViewManager: public Manager {
66	afaq	1.1	public:
67	afaq	1.8	EvCollViewManager();
68			int write(std::vector<Evcollviewmultirow> rowVector, EvcollviewMultiTable table);
69	sekhri	1.5	int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
70	afaq	1.8	~EvCollViewManager();
71	afaq	1.1	};
72
73	afaq	1.8	class FileViewManager: public Manager {
74	afaq	1.1	public:
75	afaq	1.8	FileViewManager();
76	sekhri	1.5	int write(std::vector<Fileviewmultirow> rowVector, FileviewMultiTable table);
77			int read(Fileviewmultirow* aRow, FileviewMultiTable* table);
78	afaq	1.8	~FileViewManager();
79	afaq	1.1	};
80
81	sekhri	1.5	class BlockManager : public Manager {
82	afaq	1.1	public:
83	sekhri	1.5	BlockManager();
84	afaq	1.8	int write(std::vector<Blockviewmultirow> rowVector, BlockviewMultiTable table);
85	sekhri	1.5	int read(Blockviewmultirow* aRow, BlockviewMultiTable* table);
86			~BlockManager();
87	afaq	1.1	};
88
89	afaq	1.8	class PDBlockViewManager: public Manager {
90	afaq	1.6	public:
91	afaq	1.8	PDBlockViewManager();
92			int write(std::vector<Pdblockviewmultirow> rowVector, PdblockviewMultiTable table);
93	afaq	1.6	int read(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
94			~PdblockManager();
95			};
96
97			/*
98	sekhri	1.5	class DatasetProvcChildManager : public Manager {
99	afaq	1.1	public:
100	sekhri	1.5	DatasetProvcChildManager();
101			int write(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
102			int read(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
103			~DatasetProvcChildManager();
104	afaq	1.1	};
105
106	sekhri	1.5	class DatasetProvcParentManager : public Manager {
107	afaq	1.1	public:
108	sekhri	1.5	DatasetProvcParentManager();
109			int write(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
110			int read(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
111			~DatasetProvcParentManager();
112	afaq	1.1	};
113	afaq	1.6	*/
114	afaq	1.8	/*
115	sekhri	1.5	class CrabECManager : public Manager {
116	afaq	1.1	public:
117	sekhri	1.5	CrabECManager();
118	afaq	1.8	int write(std::vector<Crabevcollviewmultirow> rowVector, CrabevcollviewMultiTable table);
119	sekhri	1.5	int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
120			~CrabECManager();
121	afaq	1.1	};
122	afaq	1.8	*/
123			#endif
124	afaq	1.1