StorageArea.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_StorageArea_hpp
#define anna_dbos_StorageArea_hpp

#include <vector>
#include <map>
#include <list>
#include <deque>

#include <algorithm>

#include <anna/core/mt/Mutex.hpp>
#include <anna/config/defines.hpp>
#include <anna/core/util/SortedVector.hpp>

#include <anna/dbms/DatabaseException.hpp>

#include <anna/dbos/defines.hpp>
#include <anna/dbos/ObjectAllocator.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace dbms {
class Connection;
}

namespace dbos {

class Accesor;
class Object;
class Creator;
class Loader;
class Recorder;
class Eraser;
class Repository;
class CrossedLoader;

class StorageArea : public Mutex {
  struct Instance;
  class Block;
  class Holes;

public:
  struct AccessMode {
    enum _v {
      ReadOnly,
      ReadWrite,
      ReadEver
    };

    /*
       Devuelve el literal correspondiente al codigo recibido.
       \param v Codigo a traducir a literal.
       \return el literal correspondiente al codigo recibido.
    */
    static const char* asString(const _v v) ;
  };

  struct Flag {
    enum _v {
      None = 0, Dirty = 1, Incoherent = 2, Empty = 4, HasHole = 8, Ready = 16, InProgress = 32,
      NoDirty = ~Dirty, NoIncoherent = ~Incoherent, NoEmpty = ~Empty, NoHasHole = ~HasHole, NoReady = ~Ready, Done = ~InProgress
    };
  };

  struct StandardSize {
    enum Value {
      Tiny = 16, 
      Little = 64, 
      Small = 256, 
      Medium = 2048, 
      Large = 8192, 
      Huge = 32768, 
      LargeHuge = 65536, 
      Biggest = 131072 
    };
  };

  static const int NoExceptionWhenNotFound = -1;

  typedef std::vector <Block*> Blocks; 
  typedef std::map <Index, Instance*>::iterator iterator; 
  typedef std::map <Index, Instance*>::const_iterator const_iterator; 
  virtual ~StorageArea();

  int getErrorCode() const { return a_errorCode; }

  /*
   * Devuelve el nombre de la este área de almacenamiento.
   * \return el nombre de la este área de almacenamiento.
   */
  const std::string& getName() const { return a_name; }

  Object* instance(dbms::Connection& connection, Loader& loader) noexcept(false) {
    return instance(&connection, loader);
  }

  Object* instance(dbms::Connection* connection, Loader& loader) noexcept(false);

  Object* instance(dbms::Connection& connection, CrossedLoader& crossedLoader,  Loader& loader)
  noexcept(false) {
    return instance(&connection, crossedLoader, loader);
  }

  Object* instance(dbms::Connection* connection, CrossedLoader& crossedLoader,  Loader& loader)
  noexcept(false);

  Object* instance(Loader& loader) noexcept(false) {
    return instance(NULL, loader);
  }

  Object* create(dbms::Connection& connection, Creator& creator) noexcept(false) {
    return create(&connection, creator);
  }

  Object* create(dbms::Connection* connection, Creator& creator) noexcept(false);

  Object* create(Creator& creator) noexcept(false) { return create(NULL, creator); }

  Object* find(Loader& loader) noexcept(false);

  Object* duplicate(const Object* object) noexcept(false);

  bool isLoaded(const Loader& loader) noexcept(false);

  void apply(dbms::Connection& connection, Recorder& recorder) noexcept(false);

  void apply(dbms::Connection& connection, Eraser& eraser) noexcept(false);

  void release(Object** object) noexcept(false);

  void erase(Object** object) noexcept(false);

  void dirty(Object* object) noexcept(false);

  void setSizeof(const Size _sizeof) { a_sizeof = _sizeof + sizeof(Instance); }

  Size getMaxSizeOf() const { return a_maxSize * a_sizeof; }

  Size getSizeOf() const { return a_directory.size() * a_sizeof; }

  iterator begin() { return a_directory.begin(); }

  const_iterator begin() const { return a_directory.begin(); }

  iterator end() { return a_directory.end(); }

  const_iterator end() const { return a_directory.end(); }

  static Object* data(iterator ii) { return ii->second->object; }

  static const Object* data(const_iterator ii) { return ii->second->object; }

  std::string asString() const ;

  xml::Node* asXML(xml::Node* parent) const ;

protected:
  void clear() noexcept(false);

  static std::string asMemorySize(const Size size) ;

private:
  typedef std::map <Index, Instance*>::value_type value_type;

  friend class Holes;

  class Holes {
  public:
    struct Mode { enum _v { ReadyToReuse, TimeWait }; };

    typedef std::list <Instance*> hole_container;
    typedef hole_container::iterator hole_iterator;

    Holes() : a_size(0) {;}

    bool insert(Instance* instance, const Mode::_v mode) ;
    void erase(Instance* instance) ;
    Instance* front() { return a_holes.front(); }
    int size() const { return a_size; }
    int empty() const { return a_holes.empty(); }
    void pop_front() { a_holes.pop_front(); a_size --; }
    void clear() { a_holes.clear(); a_size = 0; }

  private:
    hole_container a_holes;
    int a_size;
  };

  //------------------------------------------------------------------------
  // - object: Puntero a la instancia con el objeto cacheado.
  // - msHoleTime: Millisecond en el que entra en la lista de huecos.
  // - copyCounter: Numero de copias del objeto.
  // - flags: Flags (Dirty, Incoherent, Empty).
  //------------------------------------------------------------------------
  friend struct Instance;

  struct Instance {
    Object* object;
    Counter copyCounter;
    int flags;
    Holes::hole_iterator holeIterator;

    Instance() : copyCounter(0), object(NULL), flags(Flag::None) {;}
  };

  friend class Block;

  class Block {
  public:
    Block(ObjectAllocator objectAllocator, const Size maxSize);
    Instance* getInstance() { return (a_size < a_maxSize) ? &a_instances [a_size ++] : NULL; }
    void reset() { a_size = 0; }

  private:
    Instance* a_instances;
    Size a_maxSize;
    Size a_size;
  };

  const std::string a_name;
  const Size a_maxSize;
  ObjectAllocator a_objectAllocator;
  const AccessMode::_v a_accessMode;
  int a_errorCode;
  Size a_sizeof;

  Blocks a_blocks;
  std::map <Index, Instance*> a_directory;
  Holes a_holes;
  Block* a_currentBlock;
  int a_indexBlock;
  Counter a_hit;
  Counter a_fault;
  Counter a_doneReuse;

  /*
     typedef std::deque <std::pair <DBIndex> inprogress_container;
     typedef inprogress_container::iterator inprogress_iterator;
     inprogress_container a_inprogress;

     inprogress_iterator inprogress_begin () const { return a_inprogress.begin (); }
     inprogress_iterator inprogress_end () const { return a_inprogress.end (); }
     static DBIndex index (inprogress_iterator ii) { return *ii; }
     bool isInProgress (const DBIndex index) const ;
  */

  /*
   * Constructor.
   * \warning Este método sólo debería usarse desde el método dbos::Repository::allocateStorageArea.
   */
  StorageArea(const char* name, const Size maxSize, ObjectAllocator, const AccessMode::_v, const int errorCode);
  StorageArea(const StorageArea&);

  Object* reload(dbms::Connection*, Loader&, Instance*) noexcept(false);
  void checkIncoherence(Instance*) ;
  bool quickReusing(Instance*) ;
  void verifyStatus(StorageArea::Instance*, const bool ignoreDirty = false) noexcept(false);
  Instance* allocate() ;
  Instance* reuse() ;

  static Instance* instance(iterator& ii) { return ii->second; }
  static std::string asString(const Instance*) ;

  friend class Repository;
};

}
}

#endif