src/dashserver/xdbms/manager.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                      *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21
  22 #include "manager.h"
  23 #include "table.h"
  24 #include "objectfactory.h"
  25
  26 #include <QHash>
  27 #include <QDir>
  28
  29 #include <dcore/globaldeleter.h>
  30 #include <dcore/debug.h>
  31
  32 static DCore::GlobalDeleter<XDBMS::Manager> deleter;
  33
  34 namespace XDBMS {
  35
  36 struct Manager::Private
  37 {
  38         Private() : initialized(false), factory(new ObjectFactory) {}
  39
  40         Manager *self;
  41         QHash<QString, Table *> tables;
  42         QString databasePath;
  43
  44         bool initialized;
  45         ObjectFactory *factory;
  46 };
  47
  48 Manager::Private *const Manager::d = new Manager::Private;
  49
  50 Manager::Manager(QObject *parent)
  51  : QObject(parent)
  52 {
  53 }
  54
  55
  56 Manager::~Manager()
  57 {
  58         delete d->factory;
  59         delete d;
  60 }
  61
  62 bool Manager::initialize(const QString &databasePath)
  63 {
  64         if( d->initialized ) return false;
  65
  66         QDir dir(databasePath);
  67
  68         if( !dir.exists() )
  69         {
  70                 bool ok = dir.mkdir(dir.absolutePath());
  71
  72                 if( ok )
  73                 {
  74                         d->initialized = true;
  75                         d->databasePath = dir.absolutePath();
  76                 }
  77
  78                 return ok;
  79         }
  80
  81         d->databasePath = dir.absolutePath();
  82         d->initialized = true;
  83
  84         // Read all tables
  85         foreach(QFileInfo table, dir.entryInfoList(QStringList() << "*.xdt"))
  86         {
  87                 QString name = table.baseName();
  88
  89                 dDebug() << "=> Loading table: " << name;
  90
  91                 Table *t = this->table(name);
  92                 Q_UNUSED(t);
  93         }
  94
  95         return d->initialized;
  96 }
  97
  98 Table *Manager::table(const QString &tableId)
  99 {
 100         Table *table = d->tables.value(tableId);
 101
 102         if( !table )
 103         {
 104                 table = new Table(tableId);
 105                 d->tables[tableId] = table;
 106         }
 107
 108         return table;
 109 }
 110
 111 bool Manager::addObject(const QString &tableId, Object *object)
 112 {
 113         Table *table = this->table(tableId);
 114         if( table )
 115         {
 116                 return table->addObject(object);
 117         }
 118
 119         return false;
 120 }
 121
 122 bool Manager::load(const QString &tableId, Object *object) const
 123 {
 124         Table *table = d->tables.value(tableId);
 125         if( table )
 126         {
 127                 return table->load(object);
 128         }
 129
 130         return false;
 131 }
 132
 133 Object *Manager::object(const QString &tableId, const QString &id) const
 134 {
 135         Table *table = d->tables.value(tableId);
 136         if( table )
 137         {
 138                 return table->object(id);
 139         }
 140
 141         return 0;
 142 }
 143
 144 bool Manager::update(const QString &tableId, Object *object)
 145 {
 146         Table *table = d->tables.value(tableId);
 147         if( table )
 148         {
 149                 return table->update(object);
 150         }
 151
 152         return false;
 153 }
 154
 155 bool Manager::remove(const QString &tableId, Object *object)
 156 {
 157         Table *table = d->tables.value(tableId);
 158         if( table )
 159         {
 160                 return table->remove(object);
 161         }
 162
 163         return false;
 164 }
 165
 166 QDir Manager::databaseDir() const
 167 {
 168         return QDir(d->databasePath);
 169 }
 170
 171 void Manager::setObjectFactory(ObjectFactory *factory)
 172 {
 173         if(d->factory == factory)
 174                 return;
 175
 176         delete d->factory;
 177         d->factory = factory;
 178 }
 179
 180 ObjectFactory *Manager::objectFactory() const
 181 {
 182         return d->factory;
 183 }
 184
 185
 186 Manager *Manager::self()
 187 {
 188         if( d->self )
 189         {
 190                 d->self = new Manager;
 191                 deleter.setObject(d->self);
 192         }
 193
 194         return d->self;
 195 }
 196
 197 }