depend.hpp

Go to the documentation of this file.

/*
  DEPEND.hpp  -  access point to singletons and dependencies

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

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LIB_DEPEND_H
#define LIB_DEPEND_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/nobug-init.hpp"
#include "lib/sync-classlock.hpp"
#include "lib/zombie-check.hpp"
#include "lib/meta/util.hpp"

#include <type_traits>
#include <functional>
#include <atomic>
#include <memory>


namespace lib {
  namespace error = lumiera::error;
  
  
  template<class OBJ>
  class DependencyFactory
    : util::NonCopyable
    {
      using Creator = std::function<OBJ*()>;
      using Deleter = std::function<void()>;
      
      Creator creator_;
      Deleter deleter_;
      
    public:
      ZombieCheck zombieCheck{util::typeStr<OBJ>()};
      
      DependencyFactory() = default;
     ~DependencyFactory()
        {
          if (deleter_)
            deleter_();
        }
      
      OBJ*
      buildTarget()
        {
          return creator_? creator_()
                         : buildAndManage();
        }
      
      template<typename FUN>
      void
      defineCreator (FUN&& ctor)
        {
          creator_ = std::forward<FUN> (ctor);
        }
      
      template<typename FUN>
      void
      defineCreatorAndManage (FUN&& ctor)
        {
          creator_ = [this,ctor]
                      {
                        OBJ* obj = ctor();
                        atDestruction ([obj]{ delete obj; });
                        return obj;
                      };
        }
      
      void
      disable()
        {
          creator_ = []() -> OBJ*
                      {
                        throw error::Fatal("Service not available at this point of the Application Lifecycle"
                                          ,LERR_(LIFECYCLE));
                      };
        }
      
      template<typename FUN>
      void
      atDestruction (FUN&& additionalAction)
        {
          if (deleter_)
            {
              Deleter oldDeleter{std::move (deleter_)};
              deleter_ = [oldDeleter, additionalAction]
                          {
                            oldDeleter();
                            additionalAction();
                          };
            }
          else
            deleter_ = std::forward<FUN> (additionalAction);
        }
      
      void
      transferDefinition (DependencyFactory&& source)
        {
          creator_ = std::move (source.creator_);
          deleter_ = std::move (source.deleter_);
          source.creator_ = Creator();
          source.deleter_ = Deleter(); // clear possible leftover deleter
        }
      
    private:
      OBJ*
      buildAndManage()
        {
          OBJ* obj = buildInstance<OBJ>();
          atDestruction ([obj]{ delete obj; });
          return obj;
        }

                                   // try to instantiate the default ctor
      template<class X, typename = decltype(X())>
      static std::true_type  __try_instantiate(int);
      template<class>
      static std::false_type __try_instantiate(...);
      
      template<typename X>
      struct canDefaultConstruct
        : decltype(__try_instantiate<X>(0))
        { };
      
      
      template<class TAR>
      static     meta::enable_if<canDefaultConstruct<TAR>,
      TAR*                      >
      buildInstance()
        {
          return new TAR;
        }
      
      template<class ABS>
      static     meta::enable_if<std::is_abstract<ABS>,
      ABS*                      >
      buildInstance()
        {
          throw error::Fatal("Attempt to create a singleton instance of an abstract class. "
                             "Application architecture or lifecycle is seriously broken.");
        }
      template<class ABS>
      static     meta::disable_if<std::__or_<std::is_abstract<ABS>,canDefaultConstruct<ABS>>,
      ABS*                       >
      buildInstance()
        {
          throw error::Fatal("Desired singleton class is not default constructible. "
                             "Application architecture or lifecycle is seriously broken.");
        }
    };
  
  
  
  template<class SRV>
  class DependInject;
  
  
  template<class SRV>
  class Depend
    {
      using Instance = std::atomic<SRV*>;
      using Factory = DependencyFactory<SRV>;
      using Lock = ClassLock<SRV, NonrecursiveLock_NoWait>;
      
      static Instance instance;
      
      static Factory&
      factory() 
        {
          static Factory sharedFactory;
          return sharedFactory;
        }
      
      friend class DependInject<SRV>;
      
      
    public:
      SRV&
      operator() ()
        {
          SRV* object = instance.load (std::memory_order_acquire);
          if (!object)
            {
              factory().zombieCheck();
              Lock guard;
              
              object = instance.load (std::memory_order_relaxed);
              if (!object)
                {
                  object = factory().buildTarget();
                  factory().disable();
                  factory().atDestruction([]{ instance = nullptr; });
                }
              instance.store (object, std::memory_order_release);
            }
          ENSURE (object);
          return *object;
        }
      
      
      explicit
      operator bool()  const
        {
          return instance.load (std::memory_order_acquire);
        }
      
      Depend()
        {
          factory().zombieCheck();
        }
    };
  
  
  
  
  /* === allocate Storage for static per type instance management === */
  template<class SRV>
  std::atomic<SRV*> Depend<SRV>::instance;
  
  
  
} // namespace lib
#endif /*LIB_DEPEND_H*/