factory.h

/* THIS LICENSE ONLY APPLIES TO THIS FILE, FACTORY.H. THE REMAINDER OF THE FILES */
/* IN THIS PROJECT ARE RELEASED UNDER THE GNU GENERAL PUBLIC LICENSE VERSION 3 */

/* # MIT License */

/* Copyright (c) 2018 NHERI SimCenter */
/* Copyright (c) 2017 CB-Geo MPM */

/* Permission is hereby granted, free of charge, to any person obtaining a copy */
/* of this software and associated documentation files (the "Software"), to deal */
/* in the Software without restriction, including without limitation the rights */
/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell */
/* copies of the Software, and to permit persons to whom the Software is */
/* furnished to do so, subject to the following conditions: */

/* The above copyright notice and this permission notice shall be included in all */
/* copies or substantial portions of the Software. */

/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR */
/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, */
/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE */
/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER */
/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, */
/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE */
/* SOFTWARE. */


#ifndef _FACTORY_H_
#define _FACTORY_H_

#include <functional>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

template <typename Tbaseclass, typename... Targs>
class Factory {
 public:
  static Factory* instance() {
    static Factory factory;
    return &factory;
  }

  template <typename Tderivedclass>
  void register_factory(const std::string& key) {
    registry[key].reset(new Creator<Tderivedclass>);
  }

  std::shared_ptr<Tbaseclass> create(const std::string& key, Targs&&... args) {
    if (!this->check(key))
      throw std::runtime_error("Invalid key: " + key +
                               ", not found in the factory register!");
    return registry.at(key)->create(std::forward<Targs>(args)...);
  }

  bool check(const std::string& key) const {
    bool status = false;
    for (const auto& keyvalue : registry)
      if (keyvalue.first == key) status = true;
    return status;
  }
  
  std::vector<std::string> list() const {
    std::vector<std::string> factory_items;
    for (const auto& keyvalue : registry)
      factory_items.push_back(keyvalue.first);
    return factory_items;
  }

 private:
  Factory() = default;

  struct CreatorBase {
    // A virtual create function
    virtual std::shared_ptr<Tbaseclass> create(Targs&&...) = 0;
  };

  template <typename Tderivedclass>
  struct Creator : public CreatorBase {
    std::shared_ptr<Tbaseclass> create(Targs&&... args) override {
      return std::make_shared<Tderivedclass>(std::forward<Targs>(args)...);
    }
  };

  std::map<std::string, std::shared_ptr<CreatorBase>> registry; 
};

template <typename Tbaseclass, typename Tderivedclass, typename... Targs>
class Register {
 public:
  explicit Register(const std::string& key) {
    // register the class factory function
    Factory<Tbaseclass, Targs...>::instance()
        ->template register_factory<Tderivedclass>(key);
  }
};

#endif  // _FACTORY_H_