multifact.hpp

Go to the documentation of this file.

/*
  MULTIFACT.hpp  -  flexible family-of-object factory template

  Copyright (C)         Lumiera.org
    2009,               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_MULTIFACT_H
#define LIB_MULTIFACT_H


#include "lib/error.hpp"
#include "lib/depend.hpp"
#include "util.hpp"

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



namespace lib {
  namespace factory {
    
    // Helpers to wrap the factory's product
    
    template<typename TAR>
    struct PassAsIs
      {
        typedef TAR RawType;
        typedef TAR BareType;
        typedef TAR ResultType;
        
        template<class FUN, typename... ARGS>
        ResultType
        wrap (FUN create, ARGS&&... args)  noexcept
          {
            return create(std::forward<ARGS>(args)...);
          }
      };
    
    
    template<typename RAW>
    struct BuildRefcountPtr
      {
        using RawType    = typename std::remove_pointer<RAW>::type;
        using BareType   = RawType *;
        using ResultType = std::shared_ptr<RawType>;
        
        template<class FUN, typename... ARGS>
        ResultType
        wrap (FUN create, ARGS&&... args)
          {
            return ResultType (create(std::forward<ARGS>(args)...));
          }
      };
    
    
    template<typename TAR>
    struct Build
      {
        template<typename RAW>
        struct Wrapper
          {
            using RawType    = RAW;
            using BareType   = RAW;
            using ResultType = TAR;
            
            using WrapFunc = std::function<ResultType(BareType)>;
            
            void
            defineFinalWrapper (WrapFunc&& fun)
              {
                this->wrapper_ = fun;
              }
            
            template<class FUN, typename... ARGS>
            ResultType
            wrap (FUN create, ARGS&&... args)
              {
                return wrapper_(std::forward<BareType> (create(std::forward<ARGS>(args)...)));
              }
            
          private:
            WrapFunc wrapper_;
          };
      };
    
    
    
    
    
    template<typename SIG, typename ID>
    struct Fab
      {
        typedef std::function<SIG> FactoryFunc;
        
        
        FactoryFunc&
        select (ID const& id)
          {
            if (!contains (id))
              throw lumiera::error::Invalid("unknown factory product requested.");
            
            return producerTable_[id];
          }
        
        void
        defineProduction (ID const& id, FactoryFunc fun)
          {
            producerTable_[id] = fun;
          }
        
        
        /* === diagnostics === */
        
        bool empty ()         const { return producerTable_.empty(); }
        bool contains (ID id) const { return util::contains (producerTable_,id); }
        
      private:
        std::map<ID, FactoryFunc> producerTable_;
      };
    
    
    
    template< typename TY
            , template<class> class Wrapper
            >
    struct FabConfig
      {
        using WrapFunctor    = Wrapper<TY>;
        using BareProduct    = typename WrapFunctor::BareType;
        using WrappedProduct = typename WrapFunctor::ResultType;
        
        typedef BareProduct SIG_Fab(void);
        
        enum{ ARGUMENT_CNT = 0 };
      };
    template< typename RET
            , typename... ARGS
            , template<class> class Wrapper
            >
    struct FabConfig<RET(ARGS...), Wrapper>
      {
        using WrapFunctor    = Wrapper<RET>;
        using BareProduct    = typename WrapFunctor::BareType;
        using WrappedProduct = typename WrapFunctor::ResultType;
        
        typedef BareProduct SIG_Fab(ARGS...);
        
        enum{ ARGUMENT_CNT = sizeof...(ARGS)};
      };
    
    
    
    
    /* === Main type === */
    
    template< typename SIG
            , typename ID
            , template<class> class Wrapper = PassAsIs
            >
    class MultiFact
      : public FabConfig<SIG,Wrapper>::WrapFunctor
      {
        using   _Conf = FabConfig<SIG,Wrapper>;
        using SIG_Fab = typename _Conf::SIG_Fab;
        using    _Fab = Fab<SIG_Fab,ID>;
        
        _Fab funcTable_;
        
        
      protected:
        using Creator = typename _Fab::FactoryFunc;
        
        Creator&
        selectProducer (ID const& id)
          {
            return funcTable_.select(id);
          }
        
        
      public:
        using Product = typename _Conf::WrappedProduct;
        
        template<typename... ARGS>
        Product
        operator() (ID const& id, ARGS&& ...args)
          {
            static_assert (sizeof...(ARGS) == _Conf::ARGUMENT_CNT,
                           "MultiFac instance invoked with the wrong number "
                           "of fabrication arguments. See template parameter SIG");
            
            Creator& creator = selectProducer (id);
            return this->wrap (creator, std::forward<ARGS>(args)...);
          }
        
        template<typename... ARGS>
        Product
        invokeFactory (ID const& id, ARGS&& ...args)
          {
            return this->operator() (id, std::forward<ARGS>(args)...);
          }
        
        
        template<typename FUNC>
        void
        defineProduction (ID id, FUNC&& fun)
          {
            funcTable_.defineProduction (id, fun);
          }
        
        
        template<class IMP>
        class Singleton
          : lib::Depend<IMP>
          {
            typedef lib::Depend<IMP> SingleFact;
            
            Creator
            createSingleton_accessFunction()
              {
                return std::bind (&SingleFact::operator()
                                 , static_cast<SingleFact*>(this));
              }
            
          public:
            Singleton (MultiFact& factory, ID id)
              {
                factory.defineProduction(id, createSingleton_accessFunction());
              }
          };
          
        
        /* === diagnostics === */
        
        bool empty ()         const { return funcTable_.empty();       }
        bool contains (ID id) const { return funcTable_.contains (id); }
      };
    
    
    
}} // namespace lib::factory
#endif