ProviderList.h

Go to the documentation of this file.

#ifndef LARCORE_TESTUTILS_PROVIDERLIST_H
#define LARCORE_TESTUTILS_PROVIDERLIST_H 1

// LArSoft libraries
#include "larcorealg/TestUtils/ProviderTestHelpers.h"

// C/C++ standard libraries
#include <memory>    // std::unique_ptr()
#include <stdexcept> // std::runtime_error
#include <typeinfo>
#include <unordered_map>
#include <utility> // std::forward()

namespace testing {

  namespace details {

    struct MovableClassWrapperBase {
      virtual ~MovableClassWrapperBase() = default;

    }; // struct MovableClassWrapperBase

    template <typename T>
    class MovableClassWrapper : public details::MovableClassWrapperBase {
      using datum_t = T;                          
      using this_t = MovableClassWrapper<T>;      
      using pointer_t = std::shared_ptr<datum_t>; 

      template <typename U>
      friend class MovableClassWrapper;

    public:
      struct share_t {}; 

      static constexpr share_t share = {};

      MovableClassWrapper() : ptr(std::make_unique<datum_t>()) {}

      template <typename U>
      MovableClassWrapper(std::unique_ptr<U>&& from) : ptr(std::move(from))
      {}

      MovableClassWrapper(pointer_t&& from) : ptr(std::move(from)) {}
      MovableClassWrapper& operator=(pointer_t&& from)
      {
        ptr = std::move(from);
        return *this;
      }

      template <typename U>
      MovableClassWrapper(MovableClassWrapper<U> const& from, share_t) : ptr(from.ptr)
      {}

      datum_t& ref() { return *ptr; }

      datum_t const& ref() const { return *ptr; }

      datum_t* get() { return ptr.get(); }

      datum_t const* get() const { return ptr.get(); }

      bool valid() const { return bool(ptr); }

      operator bool() const { return valid(); }

    private:
      pointer_t ptr;

    }; // namespace testing

  } // namespace details

  class ProviderList {
    // Sparse implementation notes:
    // - we use MovableClassWrapperBase in place of std::any because our
    //   providers are recommended to be not copiable

    template <typename T>
    using smart_pointer_t = std::unique_ptr<T>;

    using pointer_t = smart_pointer_t<details::MovableClassWrapperBase>;

    template <typename T>
    using concrete_type_t = details::MovableClassWrapper<std::decay_t<T>>;
    template <typename T>
    using concrete_pointer_t = smart_pointer_t<concrete_type_t<T>>;

  public:
    struct exception : public std::runtime_error {
      using std::runtime_error::runtime_error;
    };
    struct provider_not_available : public exception {
      using exception::exception;
    };
    struct provider_deleted : public exception {
      using exception::exception;
    };
    struct provider_wrong : public exception {
      using exception::exception;
    };

    template <typename T, typename SetupProc, typename... Args>
    bool custom_setup_instance(std::string label, SetupProc&& provSetup, Args&&... args)
    {
      auto k = key<T>(label); // key
      auto it = data.find(k);
      if (it != data.end()) return false;

      pointer_t ptr = std::make_unique<concrete_type_t<T>>(provSetup(std::forward<Args>(args)...));
      data.emplace_hint(it, std::move(k), std::move(ptr));
      return true;
    } // custom_setup_instance()

    template <typename T, typename SetupProc, typename... Args>
    bool custom_setup(SetupProc&& provSetup, Args&&... args)
    {
      return custom_setup_instance<T, SetupProc, Args...>(
        "", std::forward<SetupProc>(provSetup), std::forward<Args>(args)...);
    } // custom_setup()

    template <typename T, typename... Args>
    bool setup_instance(std::string label, Args&&... args)
    {
      auto k = key<T>(label); // key
      auto it = data.find(k);
      if (it != data.end()) return false;

      pointer_t ptr =
        std::make_unique<concrete_type_t<T>>(setupProvider<T>(std::forward<Args>(args)...));
      data.emplace_hint(it, std::move(k), std::move(ptr));
      return true;
      //   return custom_setup_instance<T>
      //     (label, setupProvider<T, Args...>, std::forward<Args>(args)...);
    } // setup_instance()

    template <typename T, typename... Args>
    bool setup(Args&&... args)
    {
      return setup_instance<T>("", std::forward<Args>(args)...);
    }

    template <typename T>
    bool acquire(std::unique_ptr<T>&& obj_ptr, std::string label = "")
    {
      auto k = key<T>(label); // key
      auto it = data.find(k);
      if (it != data.end()) return false;

      pointer_t ptr = std::make_unique<concrete_type_t<T>>(std::move(obj_ptr));
      data.emplace_hint(it, std::move(k), std::move(ptr));
      return true;
    } // acquire()

    template <typename T>
    bool erase(std::string label = "")
    {
      auto k = key<T>(label); // key
      auto target_it = data.find(k);
      if (target_it == data.end()) return false;

      // erase this and all the aliases pointing to it
      auto const* target_ptr = target_it->second.get();
      auto it = data.begin();
      while (it != data.end()) {
        if (it->second.get() == target_ptr)
          it = data.erase(it);
        else
          ++it;
      } // while
      return true;
    } // erase()

    template <typename Prov, typename Alias>
    bool set_alias(std::string alias_label = "", std::string prov_label = "")
    {
      // find the alias location
      auto alias_k = key<Alias>(alias_label); // key
      auto alias_it = data.find(alias_k);
      if (alias_it != data.end()) return false;

      // find the original provider location
      auto prov_elem = get_elem<Prov>(prov_label);

      // register the shared object to the alias
      data.emplace_hint(alias_it,
                        std::move(alias_k),
                        std::make_unique<concrete_type_t<Alias>>(
                          prov_elem, typename concrete_type_t<Alias>::share_t()));
      return true;
    } // set_alias()


    template <typename T>
    T const& get(std::string label = "") const
    {
      return get_elem<T>(label).ref();
    }

    template <typename T>
    T& get(std::string label = "")
    {
      return get_elem<T>(label).ref();
    }


    template <typename T>
    T const* getPointer(std::string label = "") const
    {
      return get_elem<T>(label).get();
    }

    template <typename T>
    T* getPointer(std::string label = "")
    {
      return get_elem<T>(label).get();
    }

    template <typename T>
    bool known(std::string label = "") const
    {
      return find<T>(label) != data.end();
    }

    template <typename T>
    bool valid(std::string label = "") const
    {
      auto it = find<T>(label);
      return (it != data.end()) && bool(it->second);
    }

  private:
    using key_type = size_t; 

    std::unordered_map<key_type, pointer_t> data; 

    template <typename T>
    static std::string type_name()
    {
      return typeid(T).name();
    }

    template <typename T>
    static std::string type_name(T const* ptr)
    {
      return typeid(*ptr).name();
    }

    template <typename T>
    auto find(std::string label = "") const
    {
      return data.find(key<T>(label));
    }

    template <typename T>
    auto find(std::string label = "")
    {
      return data.find(key<T>(label));
    }

    template <typename T>
    concrete_type_t<T> const& get_elem(std::string label = "") const
    {
      auto it = find<T>(label);
      if (it == data.end()) throw provider_not_available("Not available: " + type_name<T>());
      if (!(it->second)) throw provider_deleted("Deleted: " + type_name<T>());
      auto* ptr = dynamic_cast<details::MovableClassWrapper<T>*>(it->second.get());
      if (!ptr) {
        throw provider_wrong("Wrong: " + type_name(it->second.get()) +
                             " [requested: " + type_name<T>() + "]");
      }
      return *ptr;
    } // get_elem()

    template <typename T>
    concrete_type_t<T>& get_elem(std::string label = "")
    {
      auto it = find<T>(label);
      if (it == data.end()) throw provider_not_available("Not available: " + type_name<T>());
      if (!(it->second)) throw provider_deleted("Deleted: " + type_name<T>());
      auto* ptr = dynamic_cast<details::MovableClassWrapper<T>*>(it->second.get());
      if (!ptr) {
        throw provider_wrong("Wrong: " + type_name(it->second.get()) +
                             " [requested: " + type_name<T>() + "]");
      }
      return *ptr;
    } // get_elem()

    template <typename T>
    static key_type key(std::string label = "")
    {
      return typeid(std::decay_t<T>).hash_code() ^ std::hash<std::string>()(label);
    }

  }; // class ProviderList

} // namespace testing

#endif // LARCORE_TESTUTILS_PROVIDERLIST_H