depend-inject.hpp

Go to the documentation of this file.

/*
  DEPEND-INJECT.hpp  -  managing the lifecycle of singletons and dependencies

   Copyright (C)
     2018,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_DEPEND_INJECT_H
#define LIB_DEPEND_INJECT_H



#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/depend.hpp"
#include "lib/meta/trait.hpp"
#include "lib/meta/function.hpp"
#include "lib/sync-classlock.hpp"

#include <type_traits>
#include <utility>
#include <memory>


namespace lib {
  namespace error = lumiera::error;
  
  using std::forward;
  using std::move;
  
  
  
  
  template<class SRV>
  class DependInject
    : util::NoInstance
    {
      using Factory = typename Depend<SRV>::Factory;
      using Lock    = typename Depend<SRV>::Lock;
      
    public:
      template<class SUB>
      static void
      useSingleton()
        {
          __assert_compatible<SUB>();
          installFactory<SUB>();
        }
      
      template<class FUN>
      static void
      useSingleton (FUN&& ctor)
        {
          using Sub = typename SubclassFactoryType<FUN>::Subclass;
          using Fun = typename SubclassFactoryType<FUN>::Functor;
          
          __assert_compatible<Sub>();
          installFactory<Sub,Fun> (forward<FUN> (ctor));
        }
      
      
      template<class IMP =SRV>
      class ServiceInstance
        : util::MoveOnly
        {
          std::unique_ptr<IMP> instance_;
          
        public:
          template<typename...ARGS>
          ServiceInstance(ARGS&& ...ctorArgs)
            : instance_{new IMP(forward<ARGS> (ctorArgs)...)}
            {
              __assert_compatible<IMP>();
              activateServiceAccess (*instance_);
            }
          
          enum StartMode { NOT_YET_STARTED };
          
          ServiceInstance(StartMode)
            : instance_{}
            {
              __assert_compatible<IMP>();
            }
          
         ~ServiceInstance()
            {
              shutdown();
            }
          
          template<typename...ARGS>
          IMP&
          createInstance(ARGS&& ...ctorArgs)
            {
              instance_.reset (new IMP(forward<ARGS> (ctorArgs)...));
              activateServiceAccess (*instance_);
              return *instance_;
            }
          
          void
          shutdown()  noexcept
            {
              if (instance_)
                {
                  deactivateServiceAccess();
                  instance_.reset();
                }
            }
          
          
          explicit
          operator bool()  const
            {
              return bool(instance_);
            }
          
          IMP&
          operator* ()  const
            {
              ENSURE (instance_);
              return *instance_;
            }
          
          IMP*
          operator->()  const
            {
              ENSURE (instance_);
              return instance_.get();
            }
        };
      
      
      template<class MOC =SRV>
      class Local
        : util::MoveOnly
        {
          std::unique_ptr<MOC> mock_;
          
          SRV* origInstance_;
          Factory origFactory_;
          
        public:
          Local()
            : Local([]{ return new MOC{}; })
          { }
          
          template<class FUN>
          explicit
          Local (FUN&& buildInstance)
            {
              __assert_compatible<MOC>();
              __assert_compatible<typename SubclassFactoryType<FUN>::Subclass>();
              
              temporarilyInstallAlternateFactory (origInstance_, origFactory_
                                                 ,[=]()
                                                     {
                                                        mock_.reset (buildInstance());
                                                        return mock_.get();
                                                     });
            }
         ~Local()
            {
              restoreOriginalFactory (origInstance_, move(origFactory_));
            }
          
          explicit
          operator bool()  const
            {
              return bool(mock_);
            }
          
          MOC&
          triggerCreate()
            {
              Depend<SRV>{}.operator()();
              ENSURE (mock_);
              return *mock_;
            }
          
          MOC&
          operator* ()  const
            {
              REQUIRE (mock_);
              return *mock_;
            }
          
          MOC*
          operator-> ()  const
            {
              REQUIRE (mock_);
              return mock_.get();
            }
        };
      
      
      
    protected: /* ======= internal access-API for those configurations to manipulate Depend<SRV> ======= */
      template<class IMP>
      friend class ServiceInstance;
      template<class MOC>
      friend class Local;
      
      
      template<class SUB>
      static void
      __assert_compatible()
        {
          static_assert (meta::is_Subclass<SUB,SRV>()
                        ,"Installed implementation class must be compatible to the interface.");
        }
      
      static void
      __ensure_pristine()
        {
          if (Depend<SRV>::instance)
            throw error::Logic("Attempt to reconfigure dependency injection after the fact. "
                               "The previously installed factory (typically Singleton) was already used."
                              , error::LUMIERA_ERROR_LIFECYCLE);
        }
      
      template<typename FUN>
      struct SubclassFactoryType
        {
          static_assert (meta::_Fun<FUN>(),
                         "Need a Lambda or Function object to create a heap allocated instance");
          
          using Functor   = typename meta::_Fun<FUN>::Functor; // suitable type to store for later invocation
          using ResultVal = typename meta::_Fun<FUN>::Ret;
          using Subclass  = typename meta::Strip<ResultVal>::TypePlain;
          
          static_assert (std::is_pointer<ResultVal>::value,
                         "Function must yield a pointer to a heap allocated instance");
        };
      
      
      template<class SUB, typename FUN>
      static void
      installFactory (FUN&& ctor)
        {
          Lock guard;
          if (std::is_same<SRV,SUB>())
            {
              __ensure_pristine();
              Depend<SRV>::factory().defineCreatorAndManage (forward<FUN> (ctor));
            }
          else
            {
              __ensure_pristine();
              Depend<SRV>::factory().defineCreator ([]{ return & Depend<SUB>{}(); });
              DependInject<SUB>::useSingleton (forward<FUN> (ctor));
            }                 // delegate actual instance creation to Depend<SUB>
        }
      
      template<class SUB>
      static void
      installFactory ()
        {
          if (not std::is_same<SRV,SUB>())
            {
              Lock guard;
              __ensure_pristine();
              Depend<SRV>::factory().defineCreator ([]{ return & Depend<SUB>{}(); });
            }
          // note: we do not install an actual factory; rather we use the default for SUB
        }
      
      
      template<typename FUN>
      static void
      temporarilyInstallAlternateFactory (SRV*& stashInstance, Factory& stashFac, FUN&& newFac)
        {
          Lock guard;
          stashFac.transferDefinition (move (Depend<SRV>::factory()));
          stashInstance = Depend<SRV>::instance;
          Depend<SRV>::factory().defineCreator (forward<FUN>(newFac));
          Depend<SRV>::instance = nullptr;
        }
      
      static void
      restoreOriginalFactory (SRV*& stashInstance, Factory&& stashFac)
        {
          Lock guard;
          Depend<SRV>::factory().transferDefinition (move (stashFac));
          Depend<SRV>::instance = stashInstance;
        }
      
      static void
      activateServiceAccess (SRV& newInstance)
        {
          Lock guard;
          if (Depend<SRV>::instance)
            throw error::Logic("Attempt to activate an external service implementation, "
                               "but another instance has already been dependency-injected."
                              , error::LUMIERA_ERROR_LIFECYCLE);
          Depend<SRV>::instance = &newInstance;
          Depend<SRV>::factory().disable();
        }
      
      static void
      deactivateServiceAccess()
        {
          Lock guard;
          Depend<SRV>::instance = nullptr;
          Depend<SRV>::factory().disable();
        }
    };
  
  
  
} // namespace lib
#endif /*LIB_DEPEND_INJECT_H*/