dbListManager.h

/***************************************************************************
 *   Copyright (C) 2006 by Graeme Foster                                   *
 *   email    foster.graeme@gmail.com                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef __DB_LIST_MANAGER_H
#define __DB_LIST_MANAGER_H

#include "dbList.h"
#include "sql.h"

#include "../DataClasses/DataClass.h"
#include "../DataClasses/Institute.h"
#include "../DataClasses/Programme.h"
#include "../DataClasses/Module.h"
#include "../DataClasses/Faculty.h"
#include "../DataClasses/Department.h"
#include "../DataClasses/Staff.h"
#include "../DataClasses/Room.h"
#include "../DataClasses/ModLecAlloc.h"
#include "../DataClasses/TimeSlot.h"

#include "../ModelClasses/RootModel.h"
#include "../ItemClasses/RootItem.h"

class RootModel;

class dbListManager
{
        public:
                enum registeredLists
                        {regInstitute  = 1
                        ,regProgramme  = 2
                        ,regModule     = 4
                        ,regFaculty    = 8
                        ,regDepartment = 16
                        ,regStaff      = 32
                        ,regRoom       = 64
                        ,regMLAlloc    = 128
                        ,regTimeSlot   = 256
                        };
        
        class registeredModels
        {
                public:
                        RootModel * pModel;     
                        QList<dbList *> listOfLists; 
                        registeredModels(RootModel * model){pModel = model;} 
                        void registerList(dbList * list){listOfLists.append(list);} 
                        bool listIsMember(dbList * list){return listOfLists.contains(list);} 
                        void dump(); 
        }; // end of nested class registeredModels

        private: // Singleton Instance
                static dbListManager * _instance;        
        private: // Properties
                sql* dbConn;    
                dbList * pInstituteList;        
                dbList * pProgrammeList;        
                dbList * pModuleList;           
                dbList * pFacultyList;          
                dbList * pDepartmentList;       
                dbList * pStaffList;                    
                dbList * pRoomList;                     
                dbList * pMLAllocList;          
                dbList * pTimeSlotList;         

                QList<registeredModels *> pRegisteredModels; 
        private: // methods
                dbListManager();
                dbListManager(dbListManager & clone);
        public:  // static methods
                static dbListManager * Instance();      
        public: // member functions
                // RegisterModel functions
                void registerModel(RootModel * model, int lists);

                // Access functions, returns the list as a dbList container
                inline dbList * InstituteList(){return pInstituteList;} 
                inline dbList * ProgrammeList(){return pProgrammeList;} 
                inline dbList * ModuleList(){return pModuleList;}                       
                inline dbList * FacultyList(){return pFacultyList;}             
                inline dbList * DepartmentList(){return pDepartmentList;}
                inline dbList * StaffList(){return pStaffList;}                         
                inline dbList * RoomList(){return pRoomList;}                           
                inline dbList * MLAllocList(){return pMLAllocList;}             
                inline dbList * TimeSlotList(){return pTimeSlotList;}           
                // Access functions cont., returns the list as a QList container
                QList<Institute * >  * getInstituteList()
                        {return List<Institute *>(pInstituteList->list());}
                QList<Programme * >  * getProgrammeList()
                        {return List<Programme *>(pProgrammeList->list());}
                QList<Programme * >  * getProgrammeList(Institute * inst)
                        {if (inst == 0) return getProgrammeList();
                         else return List<Programme *>(pProgrammeList->allChildren(inst));}
                QList<Module * >     * getModuleList()
                        {return List<Module *>(pModuleList->list());}
                QList<Module * >     * getModuleList(Programme * prog)
                        {return List<Module *>(pModuleList->allChildren(prog));}
                QList<Faculty * >    * getFacultyList()
                        {return List<Faculty *>(pFacultyList->list());}
                QList<Faculty * >    * getFacultyList(Institute * inst)
                        {if (inst == 0) return getFacultyList();
                         else return List<Faculty *>(pFacultyList->allChildren(inst));}
                QList<Department * > * getDepartmentList()
                        {return List<Department*>(pDepartmentList->list());}
                QList<Department * > * getDepartmentList(Faculty * faculty)
                        {if (faculty == 0) return getDepartmentList();
                         else return List<Department*>(pDepartmentList->allChildren(faculty));}
                QList<Department * > * getDepartmentList(Institute * inst)
                        {if (inst == 0) return getDepartmentList();
                         else return List<Department*>(pDepartmentList->allChildren(inst,true));}
                QList<Staff * >      * getStaffList()
                        {return List<Staff*>(pStaffList->list());}
                QList<Staff * >      * getStaffList(Department * dept)
                        {if (dept == 0) return getStaffList();
                         else return List<Staff*>(pStaffList->allChildren(dept,true));}
                QList<Staff * > * getStaffList(Institute * inst)
                        {if (inst == 0) return getStaffList();
                         else return List<Staff*>(pStaffList->allChildren(inst,true));}
                QList<Room * >       * getRoomList()
                        {return List<Room *>(pRoomList->list());}
                QList<Room * >       * getRoomList(Institute * inst)
                        {return List<Room *>(pRoomList->allChildren(inst));}
                QList<ModLecAlloc * >       * getMLAllocList()
                        {return List<ModLecAlloc*>(pMLAllocList->list());}
                QList<ModLecAlloc * >       * getMLAllocList(Programme * prog)
                        {return List<ModLecAlloc*>(pMLAllocList->allChildren(prog));}
                QList<ModLecAlloc * >       * getMLAllocList(Institute * inst)
                        {return List<ModLecAlloc*>(pMLAllocList->allChildren(inst, true));}

                QList<TimeSlot * >          * getTimeSlotList()
                        {return List<TimeSlot *>(pTimeSlotList->list());}
                QList<TimeSlot * >          * getTimeSlotList(Institute * inst)
                        {return List<TimeSlot *>(pTimeSlotList->allChildren(inst));}
                
                // Object Location methods, returns an object from its ID
                Institute * getInstituteFromID(int id)          {return getObjFromID<Institute *>(pInstituteList,id);}
                Programme * getProgrammeFromID(int id)          {return getObjFromID<Programme *>(pProgrammeList,id);}
                Module * getModuleFromID(int id)                                {return getObjFromID<Module *>(pModuleList,id);}
                Faculty * getFacultyFromID(int id)                      {return getObjFromID<Faculty *>(pFacultyList,id);}
                Department * getDepartmentFromID(int id)        {return getObjFromID<Department *>(pDepartmentList,id);}
                Staff  * getStaffFromID(int id)                         {return getObjFromID<Staff *>(pStaffList,id);}
                Room * getRoomFromID(int id)                                    {return getObjFromID<Room *>(pRoomList,id);}
                ModLecAlloc * getMLAllocFromID(int id)          {return getObjFromID<ModLecAlloc *>(pMLAllocList,id);}
                // Object Location methods cont., returns an object from its name
                Institute  * getInstFromName(QString &InstName){return getObjFromName(getInstituteList(),InstName);}
                Programme  * getProgFromName(Institute * instObj, QString &ProgName){return getObjFromName(getProgrammeList(instObj),ProgName);}
                Department * getDeptFromName(Institute * instObj, QString &deptName){return getObjFromName(getDepartmentList(instObj),deptName);}
                
                // Insert, Update and delete action functions
                void insert(RootItem * item, dbList * list, QModelIndex & index, CompareDC lessThan);
                void update(RootItem * item, dbList * list, CompareRI compare);
                void remove(RootItem * item, dbList * list, bool cascade=true);

                // diagnostic functions
                void dump(bool details = false);
                
        private: // member functions
                // Creation methods
                void newInstitute  ();
                void newProgramme  (Institute  * parent);
                void newModule     (Programme  * parent);
                void newFaculty    (Institute  * parent);
                void newDepartment (Faculty    * parent);
                void newStaff      (Department * parent);
                void newRoom       (Institute  * parent);
                void newAlloc      ();
                void newTimeSlot   ();
                
                void updateRMInsert(dbList * list, RootItem * item, QModelIndex & index, int posn);
                void updateRMUpdate(dbList * list, DataClass * dcObj, CompareRI compare);
                void updateRMDelete(dbList * list, DataClass * dcObj);
                void removeAllChilden(DataClass * dcObj);
                void removeChild(DataClass * dcObj, dbList * list);
                template<typename T>
                QList<T> * List(QList<DataClass*> * list);
                template<typename T>
                T getObjFromID(dbList* pList, int id);
                template<typename T>
                T getObjFromName(QList<T>* list, QString &name);
};

template<typename T>
QList<T> * dbListManager::List(QList<DataClass*> * list)
{
        QList<T> * theList = new QList<T>();
        for (int i = 0; i < list->size(); i++)
        {
                theList->append(static_cast<T>(list->at(i)));
        }
        return theList;
}

template<typename T>
T dbListManager::getObjFromID(dbList* pList, int id)
{
        for (int i=0; i<pList->size(); i++)
        {
                if (pList->at(i)->getID() == id)
                        return static_cast<T>(pList->at(i));
        }
        return 0;
}

template<typename T>
T dbListManager::getObjFromName(QList<T>* list, QString &name)
{
        T instObj = 0;
        for (int i = 0; i<list->size(); i++)
        {
                if (list->at(i)->getName().compare(name)==0)
                {
                        instObj = list->at(i);
                        break;
                }
        } // end for loop through each object in the list
        return instObj;
}

#endif

---