ObjectProducer.h

Go to the documentation of this file.

/*
 * ObjectProducer.h
 *
 *  Created on: 22 Oct  2019
 *      Author: Nicola Mori
 */
#ifndef OBJECTPRODUCER_H_
#define OBJECTPRODUCER_H_

#include "core/Exception.h"
#include "data/ObjectCategory.h"
#include "utils/Memory.h"

#include <algorithm>
#include <memory>
#include <set>
#include <string>
#include <vector>

namespace EA {

class ObjectProducer {
public:
  ObjectProducer();

  virtual ~ObjectProducer() {}

  struct ProducedObject {
    std::string name;
    ObjectCategory category;
    std::set<std::string> aliases;
    std::string store;
    ProducedObject() : name{""}, category{ObjectCategory::NONE}, store{""} {}
    template <typename C>
    ProducedObject(std::string objName, ObjectCategory objCategory, C objAliases, std::string objStore);

    bool operator==(const ProducedObject &rhs) const {
      return (name == rhs.name) && (category == rhs.category) && (store == rhs.store);
    }
  };

  template <typename C>
  void DeclareProducedObject(std::string name, ObjectCategory category, C aliases, std::string store);

  // In-class exceptions
  class BadName : public Exception {
    using Exception::Exception;
  };
  class BadCategory : public Exception {
    using Exception::Exception;
  };

  using ProducedObjects = std::vector<ProducedObject>;

  const ProducedObjects &GetProducedObjects() const { return _repr->objs; }

  virtual std::vector<std::string> FreeObjects(const std::vector<std::string> &objs, Memory::Status memStatus);

protected:
  class Representation {
    friend class ObjectProducer;
    ProducedObjects objs;
  };

  ObjectProducer(const std::shared_ptr<Representation> &impl) : _repr{impl} {}
  std::shared_ptr<Representation> &GetRepresentation() { return _repr; }

private:
  std::shared_ptr<Representation> _repr;
};

// Definition of template member functions

// C is required to be a container of std::string. User specializations may relax these requirements.
template <typename C>
ObjectProducer::ProducedObject::ProducedObject(std::string objName, ObjectCategory objCategory, C objAliases,
                                               std::string objStore)
    : name{std::move(objName)}, category{std::move(objCategory)}, store{std::move(objStore)} {

  for (auto &alias : objAliases) {
    if (alias != "") {
      aliases.emplace(std::move(alias));
    }
  }
}

template <typename C>
void ObjectProducer::DeclareProducedObject(std::string name, ObjectCategory category, C aliases, std::string store) {

  const std::string routineName("ObjectProducer::DeclareProducedObject");

  if (name == "") {
    throw BadName(routineName + ": no name given for produced object");
  }
  if (category == ObjectCategory::NONE) {
    throw BadCategory(routineName + ": bad category for produced object " + name);
  }

  ProducedObject declaredObj(std::move(name), std::move(category), "", std::move(store));
  auto objIter = std::find(_repr->objs.begin(), _repr->objs.end(), declaredObj);
  auto &effectiveObj = (objIter != _repr->objs.end() ? *objIter : declaredObj);
  for (auto &alias : aliases) {
    if (alias != "") {
      effectiveObj.aliases.emplace(std::move(alias));
    }
  }
  if (objIter == _repr->objs.end()) {
    _repr->objs.emplace_back(declaredObj);
  }
}

// To avoid the template code being compiled in multiple translation units repeatedly for the most common template
// arguments, explicitly instantiate them as extern templates (except when compiling ObjectProducer.cpp where some full
// specialization is defined and the actual instantiation occurs).
#ifndef OBJECTPRODUCER_CPP
extern template ObjectProducer::ProducedObject::ProducedObject(std::string objName, ObjectCategory objCategory,
                                                               std::set<std::string> objAliases, std::string objStore);
extern template ObjectProducer::ProducedObject::ProducedObject(std::string objName, ObjectCategory objCategory,
                                                               std::string objAlias, std::string objStore);
extern template ObjectProducer::ProducedObject::ProducedObject(std::string objName, ObjectCategory objCategory,
                                                               const char *objAlias, std::string objStore);

extern template void ObjectProducer::DeclareProducedObject(std::string name, ObjectCategory category,
                                                           std::set<std::string> alias, std::string store);
extern template void ObjectProducer::DeclareProducedObject(std::string name, ObjectCategory category, std::string alias,
                                                           std::string store);
extern template void ObjectProducer::DeclareProducedObject(std::string name, ObjectCategory category, const char *alias,
                                                           std::string store);
#endif

} // namespace EA

#endif /* OBJECTPRODUCER_H_ */