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
#	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	#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	#include <log4cxx/logger.h>
16
17
18	typedef vector<RowInterface*> Rows;
19	typedef Rows::iterator RowIter;
20
21	class Manager {
22
23	public:
24
25	Manager();
26	Manager(DBManagement* dbManager);
27	Manager(std::string, std::string);
28
29	int doInsert(TableInterface* inTable);
30	int doUpdate(TableInterface* inTable, std::string name);
31	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	virtual ~Manager();
35	void cleanup();
36
37	protected:
38	DBManagement* dbManager;
39	Util util;
40	Dictionary* schema;
41	log4cxx::LoggerPtr logger;
42	void copyAndAddRow(TableInterface* table, RowInterface* aRow, RowInterface* aNewRow);
43	};
44
45	//class PrimaryDatasetAPIManager : public Manager {
46	class PrimaryDatasetAPIManager {
47	public:
48	PrimaryDatasetAPIManager();
49	int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
50	//int write(std::vector<Primarydatasetmultirow> rowVector, PrimarydatasetMultiTable table);
51	int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
52	~PrimaryDatasetAPIManager();
53
54	};
55
56	/*
57	class ProcessedDatasetManager : public Manager {
58	public:
59	ProcessedDatasetManager();
60	int write(std::vector<Processingpathmultirow> rowVector, ProcessingpathMultiTable table);
61	int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
62	~ProcessedDatasetManager();
63	};
64
65	class EvCollViewManager: public Manager {
66	public:
67	EvCollViewManager();
68	int write(std::vector<Evcollviewmultirow> rowVector, EvcollviewMultiTable table);
69	int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
70	~EvCollViewManager();
71	};
72
73	class FileViewManager: public Manager {
74	public:
75	FileViewManager();
76	int write(std::vector<Fileviewmultirow> rowVector, FileviewMultiTable table);
77	int read(Fileviewmultirow* aRow, FileviewMultiTable* table);
78	~FileViewManager();
79	};
80
81	class BlockManager : public Manager {
82	public:
83	BlockManager();
84	int write(std::vector<Blockviewmultirow> rowVector, BlockviewMultiTable table);
85	int read(Blockviewmultirow* aRow, BlockviewMultiTable* table);
86	~BlockManager();
87	};
88
89	class PDBlockViewManager: public Manager {
90	public:
91	PDBlockViewManager();
92	int write(std::vector<Pdblockviewmultirow> rowVector, PdblockviewMultiTable table);
93	int read(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
94	~PdblockManager();
95	};
96
97	/*
98	class DatasetProvcChildManager : public Manager {
99	public:
100	DatasetProvcChildManager();
101	int write(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
102	int read(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
103	~DatasetProvcChildManager();
104	};
105
106	class DatasetProvcParentManager : public Manager {
107	public:
108	DatasetProvcParentManager();
109	int write(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
110	int read(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
111	~DatasetProvcParentManager();
112	};
113	*/
114	/*
115	class CrabECManager : public Manager {
116	public:
117	CrabECManager();
118	int write(std::vector<Crabevcollviewmultirow> rowVector, CrabevcollviewMultiTable table);
119	int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
120	~CrabECManager();
121	};
122	*/
123	#endif
124