GGSFactory.h

Go to the documentation of this file.

/*
 * GGSFactory.h
 *
 *  Created on: 03 Jan 2018
 *      Author: Nicola Mori
 */

#ifndef GGSFACTORY_H_
#define GGSFACTORY_H_

#include "utils/GGSSmartLog.h"

#include <cxxabi.h>
#include <map>
#include <memory>
#include <typeinfo>
#include <vector>

template <class T, typename... ConstructorArgs> class GGSFactory {

public:
  static GGSFactory &GetInstance();

  bool RegisterBuilder(const std::string &builderName, T *(*objectBuilder)(ConstructorArgs...));

  std::unique_ptr<T> CreateObject(const std::string &name, ConstructorArgs... arguments);

  const std::vector<std::string> &GetListOfRegisteredBuilders();

private:
  GGSFactory();
  std::string _factoryName;
  typedef std::map<std::string, T *(*)(ConstructorArgs...)> BuildersMap;
  BuildersMap _builders;
  std::vector<std::string> _builderNames;
};

template <class T, typename... ConstructorArgs>
GGSFactory<T, ConstructorArgs...> &GGSFactory<T, ConstructorArgs...>::GetInstance() {
  static GGSFactory<T, ConstructorArgs...> instance;
  return instance;
}

// Private default constructor
template <class T, typename... ConstructorArgs> GGSFactory<T, ConstructorArgs...>::GGSFactory() {
  _factoryName = std::string("GGSFactory<");
  int result;
  char *demangled = abi::__cxa_demangle(typeid(T).name(), NULL, NULL, &result);
  if (result == 0) {
    std::string demangledStr(demangled);
    _factoryName.append(demangledStr);
  } else {
    _factoryName.append("UNKNOWN_CLASS");
  }
  free(demangled);
  _factoryName.append(">");
}

template <class T, typename... ConstructorArgs>
bool GGSFactory<T, ConstructorArgs...>::RegisterBuilder(const std::string &builderName,
                                                        T *(*objectBuilder)(ConstructorArgs...)) {
  const std::string &routineName(_factoryName + "::RegisterBuilder");

  std::pair<typename BuildersMap::iterator, bool> insertResult =
      _builders.insert(std::pair<std::string, T *(*)(ConstructorArgs...)>(builderName, objectBuilder));
  if (insertResult.second) {
    _builderNames.push_back(builderName);
    GGSCOUT(DEBUG) << "Registered builder " << builderName << GGSENDL;
    return true;
  } else {
    GGSCOUT(ERROR) << "Impossible to register class builder " << builderName
                   << ": a class builder with the same name is already registered." << GGSENDL;
    return false;
  }
}

template <class T, typename... ConstructorArgs>
const std::vector<std::string> &GGSFactory<T, ConstructorArgs...>::GetListOfRegisteredBuilders() {
  return _builderNames;
}

template <class T, typename... ConstructorArgs>
std::unique_ptr<T> GGSFactory<T, ConstructorArgs...>::CreateObject(const std::string &builderName,
                                                                   ConstructorArgs... arguments) {
  const std::string &routineName(_factoryName + "::CreateObject");

  // 1. Search for a suitable builder
  typename BuildersMap::iterator builderIter = _builders.find(builderName);
  if (builderIter == _builders.end()) {
    GGSCOUT(ERROR) << "No available class builder with name " << builderName << "." << GGSENDL;
    return std::unique_ptr<T>((T *)(NULL));
  }

  // 2. Build the object and return it
  return std::unique_ptr<T>((*(builderIter->second))(arguments...));
}

#endif /* GGSFACTORY_H_ */