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;
};


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.6
Committed:	Mon Feb 6 23:18:52 2006 UTC (19 years, 3 months ago) by afaq
Branch:	MAIN
CVS Tags:	AfterJan2006SchemaChanges_v01_00_00, AfterJan2006SchemaChanges
Changes since 1.5:	+10 -0 lines
Log Message:	Non working set, Checking IN for securing the changes, will resume working
#	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(std::string, std::string);
27
28	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	virtual ~Manager();
33	void cleanup();
34
35	protected:
36	DBManagement* dbManager;
37	Util util;
38	Dictionary* schema;
39	log4cxx::LoggerPtr logger;
40	};
41
42
43	class PrimaryDatasetManager : public Manager {
44	public:
45	PrimaryDatasetManager();
46	int write(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
47	int read(Primarydatasetmultirow* aRow, PrimarydatasetMultiTable* table);
48	~PrimaryDatasetManager();
49
50	};
51
52	class ProcessedDatasetManager : public Manager {
53	public:
54	ProcessedDatasetManager();
55	int write(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
56	int read(Processingpathmultirow* aRow, ProcessingpathMultiTable* table);
57	~ProcessedDatasetManager();
58	};
59
60	class ECManager : public Manager {
61	public:
62	ECManager();
63	int write(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
64	int read(Evcollviewmultirow* aRow, EvcollviewMultiTable* table);
65	~ECManager();
66	};
67
68	class FileManager : public Manager {
69	public:
70	FileManager();
71	int write(std::vector<Fileviewmultirow> rowVector, FileviewMultiTable table);
72	int read(Fileviewmultirow* aRow, FileviewMultiTable* table);
73	~FileManager();
74	};
75
76	class BlockManager : public Manager {
77	public:
78	BlockManager();
79	int write(Blockviewmultirow* aRow, BlockviewMultiTable* table);
80	int read(Blockviewmultirow* aRow, BlockviewMultiTable* table);
81	~BlockManager();
82	};
83
84
85	class PdblockManager : public Manager {
86	public:
87	PdblockManager();
88	int write(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
89	int read(Pdblockviewmultirow* aRow, PdblockviewMultiTable* table);
90	~PdblockManager();
91	};
92
93	/*
94	class DatasetProvcChildManager : public Manager {
95	public:
96	DatasetProvcChildManager();
97	int write(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
98	int read(Datasetprovenenceevchildmultirow* aRow, DatasetprovenenceevchildMultiTable* table);
99	~DatasetProvcChildManager();
100	};
101
102	class DatasetProvcParentManager : public Manager {
103	public:
104	DatasetProvcParentManager();
105	int write(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
106	int read(Datasetprovenenceevparentmultirow* aRow, DatasetprovenenceevparentMultiTable* table);
107	~DatasetProvcParentManager();
108	};
109	*/
110
111	class CrabECManager : public Manager {
112	public:
113	CrabECManager();
114	int write(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
115	int read(Crabevcollviewmultirow* aRow, CrabevcollviewMultiTable* table);
116	~CrabECManager();
117	};
118
119	#endif