Factory.h

Go to the documentation of this file.

/*
 * Factory.h
 *
 *  Created on: 07 May 2014
 *      Author: Nicola Mori
 */

#ifndef FACTORY_H_
#define FACTORY_H_

#include "utils/Demangler.h"
#include "utils/SmartLog.h"

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

namespace EA {

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

public:
  static Factory &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:
  Factory();
  std::string _factoryName;
  typedef std::map<std::string, T *(*)(ConstructorArgs...)> BuildersMap;
  BuildersMap _builders;
  std::vector<std::string> _builderNames;
};

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

// Private default constructor
template <class T, typename... ConstructorArgs>
Factory<T, ConstructorArgs...>::Factory() : _factoryName(std::string("Factory<").append(Demangler::ClassName<T>())) {
  const std::string routineName(_factoryName + "::Factory");
  COUT(DEEPDEB) << routineName << ENDL;
}

template <class T, typename... ConstructorArgs>
bool Factory<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);
    return true;
  } else {
    COUT(ERROR) << "Impossible to register class builder " << builderName
                << ": a class builder with the same name is already registered." << ENDL;
    return false;
  }
}

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

template <class T, typename... ConstructorArgs>
std::unique_ptr<T> Factory<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()) {
    COUT(ERROR) << "No available class builder with name " << builderName << "." << ENDL;
    return std::unique_ptr<T>((T *)(NULL));
  }

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

} // namespace EA

#endif /* FACTORY_H_ */