polymorphic-value.hpp

Go to the documentation of this file.

/*
  POLYMORPHIC-VALUE.hpp  -  building opaque polymorphic value objects

  Copyright (C)         Lumiera.org
    2011,               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_POLYMORPHIC_VALUE_H
#define LIB_POLYMORPHIC_VALUE_H


#include "lib/error.hpp"
#include "lib/meta/duck-detector.hpp"
#include "lib/util.hpp"

#include <cstddef>
#include <new>


namespace lib {
  
  namespace polyvalue { // implementation details...
    
    namespace error = lumiera::error;
    using lib::meta::enable_if;
    using lib::meta::Yes_t;
    using lib::meta::No_t;
    
    struct EmptyBase{ };
    
    template<class IFA         
            ,class BA = IFA    
            >
    class CopySupport
      : public BA
      {
      public:
        virtual ~CopySupport() { };
        virtual void cloneInto (void* targetBuffer)  const   =0;
        virtual void copyInto  (IFA& targetBase)     const   =0;
      };
    
    template<class BA>         
    class CloneValueSupport
      : public BA
      {
      public:
        virtual ~CloneValueSupport() { };
        virtual void cloneInto (void* targetBuffer)  const   =0;
      };
    
    
    template<typename T>
    class exposes_CloneFunction
      {
        
        META_DETECT_FUNCTION_NAME(cloneInto);
        
      public:
        enum{ value = HasFunName_cloneInto<T>::value
            };        // warning: match on the function name only
      };
    
    template<typename T>
    class allow_Clone_but_no_Copy
      {
        META_DETECT_MEMBER(copyInto);
        
      public:
        enum{ value = exposes_CloneFunction<T>::value
                 && ! HasMember_copyInto<T>::value
            };
      };
    
    template<class API, class YES =void>
    struct AssignmentPolicy
      {
        template<class IMP>
        static void
        assignEmbedded(IMP& dest,IMP const& src)
          {
            dest = src;
          }
      };
    
    template<class API>
    struct AssignmentPolicy<API,      enable_if< allow_Clone_but_no_Copy<API> >>
      {
        template<class IMP>
        static void
        assignEmbedded(IMP&,IMP const&)
          {
            throw error::Logic("attempt to overwrite unmodifiable value");
          }
      };
    
    
    
    template <class TY, class YES = void>
    struct Trait
      {
        using CopyAPI = CopySupport<TY,EmptyBase>;                      
        using Assignment = AssignmentPolicy<CopyAPI>;
        using AdapterAttachment = CopyAPI;
        enum{ ADMIN_OVERHEAD = 2 * sizeof(void*) };              // need second VTable for CopyAPI mix-in
        
        static CopyAPI&
        accessCopyHandlingInterface (TY& bufferContents)
          {
            REQUIRE (INSTANCEOF (CopyAPI, &bufferContents));
            return dynamic_cast<CopyAPI&> (bufferContents);
          }
      };
    
    
    template <class TY>
    struct Trait<TY,      enable_if< exposes_CloneFunction<TY> >>
      {
        using CopyAPI = TY;
        using Assignment = AssignmentPolicy<CopyAPI>;
        using AdapterAttachment = struct{ /* irrelevant */ };
        enum{ ADMIN_OVERHEAD = 1 * sizeof(void*) };              // just the VTable of the payload
        
        template<class IFA>
        static CopyAPI&
        accessCopyHandlingInterface (IFA& bufferContents)
          {
            REQUIRE (INSTANCEOF (CopyAPI, &bufferContents));
            return static_cast<CopyAPI&> (bufferContents);
          }
      };
    
  }//(End)implementation details
  
  
  
  
  
  
  
  
  
  template
    < class IFA                  
    , size_t storage             
    , class CPY = IFA            
    >
  class PolymorphicValue
    {
    private:
      typedef polyvalue::Trait<CPY>     _Traits;
      typedef typename _Traits::CopyAPI _CopyHandlingAdapter;
      typedef typename _Traits::Assignment _AssignmentPolicy;                     
      enum{
        siz = storage + _Traits::ADMIN_OVERHEAD
      };
      // WARNING: never add any member fields here                                /////////////////TICKET #1204
      
      
      /* === embedded object in buffer === */
      
      alignas(IFA) mutable
        std::byte buf_[siz];
      
      IFA&
      accessEmbedded()  const
        {
          return * std::launder (reinterpret_cast<IFA*> (&buf_));
        }
      
      void
      destroyEmbedded()
        {
          accessEmbedded().~IFA();
        }
      
      
      template<class IMP>
      class Adapter
        : public IMP
        , public _Traits::AdapterAttachment  // mix-in, might be empty
        {
          virtual void
          cloneInto (void* targetBuffer)  const
            {
              new(targetBuffer) Adapter(*this); // forward to copy ctor
            }
          
          virtual void
          copyInto (IFA& targetBase)  const
            {
              REQUIRE (INSTANCEOF (Adapter, &targetBase));
              Adapter& target = static_cast<Adapter&> (targetBase);
              _AssignmentPolicy::assignEmbedded(target,*this);
            }                                   // forward to assignment operator
          
        public: /* == forwarding ctor to implementation type == */
          
          template<typename...ARGS>
          Adapter (ARGS&&... args)
            : IMP(std::forward<ARGS>(args)...)
            { }
          
          /* using default copy and assignment */
        };
      
      template<typename IMP>
      using TypeSelector = Adapter<IMP>*;
      
      
      _CopyHandlingAdapter&
      accessHandlingInterface ()  const
        {
          IFA& bufferContents = accessEmbedded();
          return _Traits::accessCopyHandlingInterface (bufferContents);
        }
      
      template<class IMP, typename...ARGS>
      PolymorphicValue (TypeSelector<IMP>, ARGS&&... args)
        {
          static_assert (siz >= sizeof(Adapter<IMP>), "insufficient inline buffer size");
          new(&buf_) Adapter<IMP> (std::forward<ARGS>(args)...);
        }
      
      
    protected:
      template<class IMP, typename...ARGS>
      PolymorphicValue (IMP*, ARGS&&... args)
        : PolymorphicValue (TypeSelector<IMP>(), std::forward<ARGS>(args)...)
        { }
      
      
    public: /* === PolymorphicValue public API === */
      
      typedef IFA Interface;
      
      Interface&
      getPayload()
        {
          return accessEmbedded();
        }
      
      operator Interface& ()
        {
          return accessEmbedded();
        }
      operator Interface const& ()  const
        {
          return accessEmbedded();
        }
      Interface*
      operator-> ()  const
        {
          return &( accessEmbedded() );
        }
      
     ~PolymorphicValue()
        {
          destroyEmbedded();
        }
      
      PolymorphicValue (PolymorphicValue const& o)
        {
          o.accessHandlingInterface().cloneInto (&buf_);
        }
      
      PolymorphicValue&
      operator= (PolymorphicValue const& o)
        {
          o.accessHandlingInterface().copyInto (this->accessEmbedded());
          return *this;
        }
      
      /* === static factory functions === */
      
      template<class IMP, typename...ARGS>
      static PolymorphicValue
      build (ARGS&&... args)
        {
          Adapter<IMP>* type_to_build_in_buffer(0);
          return PolymorphicValue (type_to_build_in_buffer, std::forward<ARGS>(args)...);
        }
      
      
      /* === support Equality by forwarding to embedded === */
      
      friend bool
      operator== (PolymorphicValue const& v1, PolymorphicValue const& v2)
      {
        return v1.accessEmbedded() == v2.accessEmbedded();
      }
      friend bool
      operator!= (PolymorphicValue const& v1, PolymorphicValue const& v2)
      {
        return not (v1 == v2);
      }
    };
  
  
  
  
} // namespace lib
#endif