ObjectFacade.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_dbos_ObjectFacade_hpp
#define anna_dbos_ObjectFacade_hpp

#include <anna/core/RuntimeException.hpp>

#include <anna/dbms/DatabaseException.hpp>

#include <anna/dbos/StorageArea.hpp>
#include <anna/dbos/Creator.hpp>
#include <anna/dbos/Loader.hpp>
#include <anna/dbos/Recorder.hpp>
#include <anna/dbos/Eraser.hpp>

namespace anna {

namespace dbms {
class Connection;
}

namespace dbos {

class Object;

template <typename T> class ObjectFacade {
public:
  static StorageId getStorageAreaId() { return (StorageId) anna_ptrnumber_cast(&st_storageArea); }

  static StorageArea* getStorageArea() { return st_storageArea; }

  static void setStorageArea(StorageArea* storageArea) {
    (st_storageArea = storageArea)->setSizeof(sizeof(T));
  }

  static T* instance(dbms::Connection& connection, Loader& loader)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(loader.asString());
      msg += " | ObjectFacade uninitialized ";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return static_cast <T*>(st_storageArea->instance(connection, loader));
  }

  static T* instance(Loader& loader)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(loader.asString());
      msg += " | ObjectFacade uninitialized ";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return static_cast <T*>(st_storageArea->instance(loader));
  }

  static T* instance(dbms::Connection& connection, CrossedLoader& crossedLoader,  Loader& loader)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(loader.asString());
      msg += " | ObjectFacade uninitialized ";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return static_cast <T*>(st_storageArea->instance(connection, crossedLoader, loader));
  }

  static T* create(dbms::Connection& connection, Creator& creator)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(creator.asString());
      msg += " | ObjectFacade uninitialized ";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return static_cast <T*>(st_storageArea->create(connection, creator));
  }

  static T* find(Loader& loader)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(loader.asString());
      msg += " | ObjectFacade uninitialized ";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return static_cast <T*>(st_storageArea->find(loader));
  }

  static void release(T*& t)
  {
    if(st_storageArea == NULL)
      return;

    try {
      st_storageArea->release(reinterpret_cast <Object**>(&t));
    } catch(RuntimeException& ex) {
      ex.trace();
    }
  }

  static void clear()
  noexcept(false) {
    if(st_storageArea == NULL)
      throw RuntimeException("ObjectFacade uninitialized ", ANNA_FILE_LOCATION);

    st_storageArea->clear();
  }

  static T* duplicate(const T* t)
  noexcept(false) {
    if(st_storageArea == NULL)
      throw RuntimeException("ObjectFacade uninitialized ", ANNA_FILE_LOCATION);

    return static_cast <T*>(st_storageArea->duplicate(t));
  }

  static bool isLoaded(const Loader& loader)
  noexcept(false) {
    if(st_storageArea == NULL)
      throw RuntimeException("ObjectFacade uninitialized ", ANNA_FILE_LOCATION);

    return st_storageArea->isLoaded(loader);
  }

  static void apply(dbms::Connection& connection, Recorder& recorder)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(recorder.asString());
      msg += " | ObjectFacade uninitialized";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    st_storageArea->apply(connection, recorder);
  }

  static void apply(dbms::Connection& connection, Eraser& eraser)
  noexcept(false) {
    if(st_storageArea == NULL) {
      std::string msg(eraser.asString());
      msg += " | ObjectFacade uninitialized";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    st_storageArea->apply(connection, eraser);
  }

  static void erase(T*& t)
  noexcept(false) {
    if(st_storageArea == NULL)
      return;

    st_storageArea->erase(reinterpret_cast <Object**>(&t));
  }

  static T* data(StorageArea::iterator& ii) { return static_cast <T*>(StorageArea::data(ii)); }

  static const T* data(StorageArea::const_iterator& ii) { return static_cast <const T*>(StorageArea::data(ii)); }

  static Object* allocator() { return new T; }

protected:
  static StorageArea* st_storageArea;

  ObjectFacade() {}
};

}
}

#define dbos_prepare_object(T) \
   template <> anna::dbos::StorageArea* anna::dbos::ObjectFacade< T >::st_storageArea = NULL

#define dbos_declare_object(T) \
   friend class anna::dbos::ObjectFacade <T>


#endif