DataStore.h

Go to the documentation of this file.

/*
 * DataStore.h
 *
 *  Created on: 03 Jan 2017
 *      Author: Nicola Mori
 */

#ifndef DATASTORE_H_
#define DATASTORE_H_

#include "core/Info.h"
#include "core/ObjectMap.h"
#include "core/ObserverPtr.h"
#include "core/RetrievalResult.h"
#include "data/DataProvider.h"
#include "data/EventDataCache.h"
#include "data/InsertionExceptions.h"
#include "data/ObjectCategory.h"
#include "data/RemovedObjectsTracker.h"
#include "data/RetrievalExceptions.h"

#include <vector>

namespace EA {

class AlgoSequence;

class DataStore : public Info, private ObjectMap {
public:
  // Constructors/destructor

  DataStore(const std::string &name, ObjectCategory category);

  // ObjectMap interface

  template <class DataType>
  void AddObject(const std::string &name, DataType &obj, const observer_ptr<ObjectProducer> &producer = nullptr);

  template <class DataType>
  void AddObject(const std::string &name, observer_ptr<DataType> obj,
                 const observer_ptr<ObjectProducer> &producer = nullptr);

  void AddObject(const std::string &name, const char *obj, const observer_ptr<ObjectProducer> & = nullptr);

  template <class DataType>
  void AddObject(const std::string &name, std::shared_ptr<DataType> obj,
                 const observer_ptr<ObjectProducer> &producer = nullptr);

  template <class DataType>
  void AddObject(const std::string &name, std::unique_ptr<DataType> obj,
                 const observer_ptr<ObjectProducer> & = nullptr);

  void SetAlias(const std::string &objName, const std::string &objAlias);

  template <class DataType> observer_ptr<DataType> GetObject(const std::string &name);

  bool RemoveObject(const std::string &name, bool removeAliased = false);

  std::vector<std::string> GetObjects() const { return ObjectMap::GetObjects(); }

  bool IsPresent(const std::string &nameOrAlias) { return ObjectMap::IsPresent(nameOrAlias); }

  struct KnownObject {
    std::string name;              
    std::set<std::string> aliases; 

    bool operator==(const std::string &rhs) const { return name == rhs; };
  };

  const std::vector<KnownObject> &GetKnownObjects();

  std::string GetAlias(const std::string &name) const { return ObjectMap::GetAlias(name); }

  std::vector<std::string> GetAliases() const { return ObjectMap::GetAliases(); }

  bool Clean();

  bool CleanAliases() { return ObjectMap::CleanAliases(); }

  bool IsAlias(const std::string &objName) { return ObjectMap::IsAlias(objName); }

  const std::string &GetNameOfAliasedObject(const std::string &aliasName) {
    return ObjectMap::GetNameOfAliasedObject(aliasName);
  }

  ObjectWrapper GetObjectWrapper(const std::string &objName);

  // DataStore interface
  bool AddProvider(observer_ptr<DataProvider> provider);

  const std::vector<observer_ptr<DataProvider>> GetAttachedProviders() { return _providers; }

  void TrackRemovedObjects(bool track = true);

  bool IsTrackingRemovedObjects() { return (bool)_remObjTracker; }

  bool FreeRemoved(Memory::Status memStatus);

  bool SetAlgoProducedObjects(const AlgoSequence &seq);

  bool IsAlgoProducedObject(const std::string nameOrAlias);

protected:
  template <class DataType> ObjPtr<DataType> GetFromMap(const std::string &name);

  RetrievalResult GetFromProvider(const std::string &name, ObjectWrapper &wrapper, std::string &actualName,
                                  observer_ptr<ObjectProducer> &provider);

  template <class DataType>
  ObjPtr<DataType> CastAndWrap(const std::string &name, const std::string &actualName, ObjectWrapper &&wrapper,
                               observer_ptr<ObjectProducer> provider);

  void AddKnownObjects(const ObjectProducer &producer);

private:
  std::vector<observer_ptr<DataProvider>> _providers;
  ObjectCategory _category;
  std::vector<KnownObject> _knownObjects;
  bool _providersCheckedForProducedObjects;

  std::unique_ptr<RemovedObjectsTracker> _remObjTracker;

  // The following two containers are kept ordered
  std::list<std::string> _algoProdObjects;
  std::list<std::string> _algoProdAliases;
};

class OwningDataStore : public DataStore {
public:
  OwningDataStore(const std::string &name, ObjectCategory category) : DataStore(name, category) {}

  template <class DataType> void AddObject(const std::string &name, std::shared_ptr<DataType> obj) {
    DataStore::AddObject(name, obj);
  }
};

class GlobalDataStore : public OwningDataStore {
public:
  GlobalDataStore(const std::string &name) : OwningDataStore(name, ObjectCategory::GLOBAL) {}
};

class PassDataStore : public DataStore {
public:
  PassDataStore(const std::string &name) : DataStore(name, ObjectCategory::PASS) {}
};

class EventDataStore : public DataStore {
public:
  EventDataStore(const std::string &name) : DataStore(name, ObjectCategory::EVENT) {}

  bool AddEventCache(observer_ptr<EventDataCache> cache);

  template <class DataType> observer_ptr<DataType> GetObject(const std::string &name);

private:
  observer_ptr<EventDataCache> _eventCache;
};

} // namespace EA

#include "data/DataStore.hpp"

#endif /* DATASTORE_H_ */