ObjectMap.h

Go to the documentation of this file.

/*
 * ObjectMap.h
 *
 *  Created on: 06 Feb 2017
 *      Author: Nicola Mori
 */

#ifndef OBJECTMAP_H_
#define OBJECTMAP_H_

// EventAnalysis headers
#include "core/InsertionResult.h"
#include "core/ObjPtr.h"
#include "core/ObjectWrapper.h"
#include "core/ObserverPtr.h"

// C/C++ headers
#include <algorithm>
#include <typeindex>
#include <unordered_map>
#include <vector>

namespace EA {

class ObjectMap {

public:
  ~ObjectMap();

  template <class DataType> InsertionResult AddObject(const std::string &name, DataType &obj);

  template <class DataType> InsertionResult AddObject(const std::string &name, observer_ptr<DataType> obj);

  InsertionResult AddObject(const std::string &name, const char *obj);

  template <class DataType> InsertionResult AddObject(const std::string &name, std::shared_ptr<DataType> obj);

  template <class DataType> InsertionResult AddObject(const std::string &name, std::unique_ptr<DataType> obj);

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

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

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

  const std::string &GetNameOfAliasedObject(const std::string &aliasName);

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

  std::vector<std::string> GetObjects() const;

  bool IsPresent(const std::string &nameOrAlias) const;

  std::vector<std::string> GetAliases(const std::string &name = "") const;

  bool Clean();

  bool CleanAliases();

  std::string GetObjectClass(const std::string &objName);

  bool IsAlias(const std::string &objName);

protected:
  InsertionResult AddObject(const std::string &name, ObjectWrapper &&wrapper);

private:
  using Map = std::unordered_map<std::string, ObjectWrapper>;
  Map _map;
  struct Alias {
    std::string objName, aliasName;
    std::type_index typeIndex;
  };
  using Aliases = std::vector<Alias>;
  Aliases _aliases;

  Aliases::iterator _FindAlias(const std::string &aliasName) {
    return std::find_if(_aliases.begin(), _aliases.end(),
                        [&aliasName](const Alias alias) { return (aliasName == alias.aliasName); });
  }

  std::vector<Aliases::iterator> _FindAliasesOf(const std::string &objName) {
    std::vector<Aliases::iterator> retValue;
    auto aliasIter = _aliases.begin();
    while (aliasIter != _aliases.end()) {
      aliasIter = std::find_if(_aliases.begin(), _aliases.end(),
                               [&objName](const Alias alias) { return (objName == alias.objName); });
      if (aliasIter != _aliases.end()) {
        retValue.push_back(aliasIter);
      }
    }
    return retValue;
  }
};

/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

template <class DataType> InsertionResult ObjectMap::AddObject(const std::string &name, DataType &obj) {
  if (_FindAlias(name) != _aliases.end()) {
    return InsertionResult::NAMEALIASCLASH;
  }

  // Avoid move insertion to be able to use the wrapper if the insertion fails
  // TODO: use try_emplace when C++17 will be available
  ObjectWrapper wrapper{observer_ptr<DataType>(&obj)};
  std::pair<Map::iterator, bool> insertResult =
      _map.insert(std::pair<const std::string &, ObjectWrapper>(name, wrapper));
  if (insertResult.second) {
    return InsertionResult::SUCCESS;
  } else {
    if (insertResult.first->second == wrapper) {
      return InsertionResult::SUCCESS;
    } else {
      return InsertionResult::DUPLICATE;
    }
  }
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

template <class DataType> InsertionResult ObjectMap::AddObject(const std::string &name, observer_ptr<DataType> obj) {
  if (_FindAlias(name) != _aliases.end()) {
    return InsertionResult::NAMEALIASCLASH;
  }

  // Avoid move insertion to be able to use the wrapper if the insertion fails
  // TODO: use try_emplace when C++17 will be available
  ObjectWrapper wrapper{obj};
  std::pair<Map::iterator, bool> insertResult =
      _map.insert(std::pair<const std::string &, ObjectWrapper>(name, wrapper));
  if (insertResult.second) {
    return InsertionResult::SUCCESS;
  } else {
    // The inserted object is already present. Check if it is exactly the same
    if (insertResult.first->second == wrapper) {
      return InsertionResult::SUCCESS;
    } else {
      return InsertionResult::DUPLICATE;
    }
  }
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

template <class DataType> InsertionResult ObjectMap::AddObject(const std::string &name, std::shared_ptr<DataType> obj) {
  if (_FindAlias(name) != _aliases.end()) {
    return InsertionResult::NAMEALIASCLASH;
  }

  // Avoid move insertion to be able to use the wrapper if the insertion fails
  // TODO: use try_emplace when C++17 will be available
  ObjectWrapper wrapper{obj};
  std::pair<Map::iterator, bool> insertResult =
      _map.insert(std::pair<const std::string &, ObjectWrapper>(name, wrapper));
  if (insertResult.second) {
    return InsertionResult::SUCCESS;
  } else {
    // The inserted object is already present. Check if it is exactly the same
    if (insertResult.first->second == wrapper) {
      return InsertionResult::SUCCESS;
    } else {
      return InsertionResult::DUPLICATE;
    }
  }
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

template <class DataType> InsertionResult ObjectMap::AddObject(const std::string &name, std::unique_ptr<DataType> obj) {
  if (_FindAlias(name) != _aliases.end()) {
    return InsertionResult::NAMEALIASCLASH;
  }

  // Avoid move insertion to be able to use the wrapper if the insertion fails
  // TODO: use try_emplace when C++17 will be available
  ObjectWrapper wrapper{std::move(obj)};
  std::pair<Map::iterator, bool> insertResult =
      _map.insert(std::pair<const std::string &, ObjectWrapper>(name, wrapper));
  if (insertResult.second) {
    return InsertionResult::SUCCESS;
  } else {
    // The inserted object is already present. Check if it is exactly the same
    if (insertResult.first->second == wrapper) {
      return InsertionResult::SUCCESS;
    } else {
      return InsertionResult::DUPLICATE;
    }
  }
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

template <class DataType> ObjPtr<DataType> ObjectMap::GetObject(const std::string &name) {

  Map::iterator iter;
  auto alias = _FindAlias(name);
  if (alias != _aliases.end()) {
    // "name" is an alias, so search for the aliased object
    iter = _map.find(alias->objName);
  } else {
    // "name" is the name of the object
    iter = _map.find(name);
  }
  if (iter == _map.end()) {
    ObjPtr<DataType> objPtr;
    objPtr._result = RetrievalResult::NOTFOUND;
    return objPtr; //
  }

  ObjPtr<DataType> objPtr(wrapper_cast<DataType>(iter->second));
  if (!objPtr) {
    objPtr._result = RetrievalResult::BADCLASS;
  } else {
    objPtr._result = RetrievalResult::SUCCESS;
  }
  return objPtr;
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

} // namespace EA

#endif /* OBJECTMAP_H_ */