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 <unordered_map>
#include <memory> // std::unique_ptr()
#include <utility> // std::forward()
#include <typeinfo>



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 boost::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