DataStore.hpp

Go to the documentation of this file.

/*
 * DataStore.hpp
 *
 *  Created on: 14 Dec 2017
 *      Author: Nicola Mori
 */

#ifndef DATASTORE_HPP_
#define DATASTORE_HPP_

template <class DataType>
void DataStore::AddObject(const std::string &name, DataType &obj, const observer_ptr<ObjectProducer> &producer) {
  InsertionResult ir = ObjectMap::AddObject(name, obj);
  if (ir != InsertionResult::SUCCESS) {
    THROW_INSERTION_EXC(ir, name);
  }
  if (producer && _remObjTracker) {
    if (!(_remObjTracker->TrackObject(name, producer))) {
      ObjectMap::RemoveObject(name);
      throw Insertion::Error("Can't track object \"" + name + "\"");
    }
  }
}

template <class DataType>
void DataStore::AddObject(const std::string &name, observer_ptr<DataType> obj,
                          const observer_ptr<ObjectProducer> &producer) {
  InsertionResult ir = ObjectMap::AddObject(name, obj);
  if (ir != InsertionResult::SUCCESS) {
    THROW_INSERTION_EXC(ir, name);
  }
  if (producer && _remObjTracker) {
    if (!(_remObjTracker->TrackObject(name, producer))) {
      ObjectMap::RemoveObject(name);
      throw Insertion::Error("Can't track object \"" + name + "\"");
    }
  }
}

template <class DataType>
void DataStore::AddObject(const std::string &name, std::shared_ptr<DataType> obj,
                          const observer_ptr<ObjectProducer> &producer) {
  InsertionResult ir = ObjectMap::AddObject(name, obj);
  if (ir != InsertionResult::SUCCESS) {
    THROW_INSERTION_EXC(ir, name);
  }
  if (producer && _remObjTracker) {
    if (!(_remObjTracker->TrackObject(name, producer))) {
      ObjectMap::RemoveObject(name);
      throw Insertion::Error("Can't track object \"" + name + "\"");
    }
  }
}

template <class DataType>
void DataStore::AddObject(const std::string &name, std::unique_ptr<DataType> obj,
                          const observer_ptr<ObjectProducer> &) {
  InsertionResult ir = ObjectMap::AddObject(name, std::move(obj));
  if (ir != InsertionResult::SUCCESS) {
    THROW_INSERTION_EXC(ir, name);
  }
}

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

  // Retrieval of an object. The object will be fetched from the store and
  // from the data providers (if they exist) in this order.
  // The retrieve result is the best result obtained in the above steps.

  // 1. Try to retrieve the requested object from existing ones
  auto obj = GetFromMap<DataType>(name);
  if (obj.GetRetrievalResult() == RetrievalResult::SUCCESS) {
    return obj;
  }

  // 2. Try to retrieve the requested object from a registered provider
  ObjectWrapper w;
  RetrievalResult result = obj.GetRetrievalResult();
  // Insert the desired type into the wrapper
  w = (DataType *)(nullptr);
  // Retrieve from the provider
  std::string actualName;
  observer_ptr<ObjectProducer> provider;
  result = std::max(GetFromProvider(name, w, actualName, provider), result);

  // 3. Check the type if the object has been found.
  if (result == RetrievalResult::SUCCESS) {
    auto objAfterCast = CastAndWrap<DataType>(name, actualName, std::move(w), provider);
    if (!objAfterCast) {
      THROW_RETRIEVAL_EXC(objAfterCast.GetRetrievalResult(), name);
    }
    return objAfterCast;
  } else {
    if (result == RetrievalResult::NOTFOUND) {
      // The object is not found in data providers, so let's see if it is produced by an algorithm to eventually
      // return NOTAVAILABLE.
      if (IsAlgoProducedObject(name)) {
        throw Retrieval::NotAvailable("Object \"" + name + "\" is not available");
      }
    }
    THROW_RETRIEVAL_EXC(result, name);
  }
}

template <class DataType> ObjPtr<DataType> DataStore::GetFromMap(const std::string &name) {
  return ObjectMap::GetObject<DataType>(name);
}

template <class DataType>
ObjPtr<DataType> DataStore::CastAndWrap(const std::string &name, const std::string &actualName, ObjectWrapper &&wrapper,
                                        observer_ptr<ObjectProducer> provider) {
  ObjPtr<DataType> retObj;
  retObj._result = RetrievalResult::SUCCESS;

  // Object found. Now check for type.
  retObj = wrapper_cast<DataType>(wrapper);
  if (retObj) {
    if (actualName == "") {
      if (ObjectMap::AddObject(name, std::move(wrapper)) == InsertionResult::DUPLICATE) {
        // This can happen when an object with the same name but the wrong
        // type is present in the data store, so that it has not been retrieved
        // from stored objects in DataStore::GetObject due to a type mismatch but
        // it prevents the object fetched from the provider to be inserted in the
        // store
        retObj._result = RetrievalResult::ERROR;
      }
    } else {
      // name is actually an alias
      ObjectMap::AddObject(actualName, std::move(wrapper)); // This fails if the aliased object is already present,
                                                            // so don't check the return value.
      try {
        SetAlias(actualName, name);
      } catch (Insertion::Exception &exc) {
        ObjectMap::RemoveObject(actualName);
        retObj = nullptr;
        retObj._result = RetrievalResult::ERROR;
      }
    }
  } else {
    retObj._result = RetrievalResult::BADCLASS;
  }
  // Add the object to the RemovedObjectsManager
  if (provider && _remObjTracker) {
    if (!_remObjTracker->TrackObject(name, provider)) {
      retObj = nullptr;
      retObj._result = RetrievalResult::ERROR;
    }
  }

  return retObj;
}

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

  // Retrieval of an object. The object will be fetched from the store, from the cache
  // (if the cache exists) and from the data providers (if they exist) in this order.
  // The retrieve result is the best result obtained in the above steps.

  // 1. Try to retrieve the requested object from existing ones
  auto obj = GetFromMap<DataType>(name);
  if (obj.GetRetrievalResult() == RetrievalResult::SUCCESS) {
    return obj;
  }

  ObjectWrapper w;
  RetrievalResult result = obj.GetRetrievalResult();

  // 2. Try to retrieve the requested object from the cache
  if (_eventCache) {
    result = _eventCache->GetCachedValue(name, w);
  }

  // 3. Try to retrieve the requested object from a registered provider
  std::string actualName;
  observer_ptr<ObjectProducer> provider;
  if (result != RetrievalResult::SUCCESS) {
    // Insert the desired type into the wrapper
    w = (DataType *)(nullptr);
    // Retrieve from the provider
    result = std::max(GetFromProvider(name, w, actualName, provider), result);
  }

  // 4. Check the type if the object has been found.
  if (result == RetrievalResult::SUCCESS) {
    auto objPtr = CastAndWrap<DataType>(name, actualName, std::move(w), provider);
    if (!objPtr) {
      THROW_RETRIEVAL_EXC(objPtr.GetRetrievalResult(), name);
    }
    return objPtr;
  } else {
    if (result == RetrievalResult::NOTFOUND) {
      // The object is not found in data providers, so let's see if it is produced by an algorithm to eventually
      // return NOTAVAILABLE.
      if (IsAlgoProducedObject(name)) {
        throw Retrieval::NotAvailable("Object \"" + name + "\" is not available");
      }
    }
    THROW_RETRIEVAL_EXC(result, name);
  }
}

#endif /* DATASTORE_HPP_ */