lib/opaque-holder.hpp

Go to the documentation of this file.

/*
  OPAQUE-HOLDER.hpp  -  buffer holding an object inline while hiding the concrete type 
 
  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_OPAQUE_HOLDER_H
#define LIB_OPAQUE_HOLDER_H


#include "lib/error.hpp"
#include "lib/bool-checkable.hpp"
#include "lib/access-casted.hpp"
#include "lib/util.hpp"

#include <boost/noncopyable.hpp>


namespace lib {
  
  using lumiera::error::LUMIERA_ERROR_WRONG_TYPE;
  using util::isSameObject;
  using util::unConst;
  
  
  namespace { // implementation helpers...
    
    using boost::disable_if;
    using boost::is_convertible;
    
    bool
    validitySelfCheck (bool boolConvertible)
      {
        return boolConvertible;
      }
    
    template<typename X>
        typename disable_if< is_convertible<X,bool>, 
    bool >::type
    validitySelfCheck (X const&)
      {
        return true; // just pass if this type doesn't provide a validity check...
      }
    
  }
  
  
  
  /* ==== Policy classes controlling re-Access ==== */
  
  template<class BA>
  struct InPlaceAnyHolder_useCommonBase
    {
      typedef BA Base;
      
      template<class SUB>
      static Base*
      convert2base (SUB& obj)
        {
          SUB* oPtr = &obj;
          BA* asBase = util::AccessCasted<BA*>::access (oPtr);
          if (asBase) 
            return asBase;
          
          throw lumiera::error::Logic ("Unable to convert concrete object to Base interface"
                                      , LUMIERA_ERROR_WRONG_TYPE
                                      );
        }
      
      template<class SUB>
      static SUB*
      access (Base* asBase)
        {
          // Because we don't know anything about the involved types,
          // we need to exclude a brute force static cast
          // (which might slice or reinterpret or even cause SEGV)
          if (!util::use_static_downcast<Base*,SUB*>::value)
            {
              SUB* content = util::AccessCasted<SUB*>::access (asBase);
              return content;
              // might be NULL
            }
          else
            return 0;
        }
    };
  
  struct InPlaceAnyHolder_unrelatedTypes
    {
      typedef void Base;
      
      template<class SUB>
      static void*
      convert2base (SUB& obj)
        {
          return static_cast<void*> (&obj);
        }
      
      template<class SUB>
      static SUB*
      access (Base*)
        {
          return 0;
        }
    };
  
  
  
  
  
  
  
  template
    < size_t siz           
    , class AccessPolicy = InPlaceAnyHolder_unrelatedTypes
    >
  class InPlaceAnyHolder
    : public BoolCheckable<InPlaceAnyHolder<siz, AccessPolicy> >
    {
      typedef typename AccessPolicy::Base * BaseP;
      
      struct Buffer
        {
          char content_[siz];
          void* ptr() { return &content_; }
          
          virtual ~Buffer() {}
          virtual bool  isValid()  const =0;
          virtual bool  empty()    const =0;
          virtual BaseP getBase()  const =0;
          
          virtual void  clone (void* targetStorage)  const =0;
        };
      
      struct EmptyBuff : Buffer
        {
          virtual bool isValid()  const { return false; }
          virtual bool empty()    const { return true; }
          
          BaseP
          getBase()  const
            {
              throw lumiera::error::Invalid("accessing empty holder");
            }
          
          virtual void
          clone (void* targetStorage)  const
            {
              new(targetStorage) EmptyBuff();
            }
        };
      
      
      template<typename SUB>
      struct Buff : Buffer
        {
          SUB&
          get()  const  
            {
              return *reinterpret_cast<SUB*> (unConst(this)->ptr());
            }
          
          ~Buff()
            {
              get().~SUB();
            }
          
          explicit
          Buff (SUB const& obj)
            {
              REQUIRE (siz >= sizeof(SUB));
              new(Buffer::ptr()) SUB (obj);
            }
          
          Buff (Buff const& oBuff)
            {
              new(Buffer::ptr()) SUB (oBuff.get());
            }
          
          Buff&
          operator= (Buff const& ref) 
            {
              if (&ref != this)
                get() = ref.get();
              return *this;
            }
          
          /* == virtual access functions == */
          
          virtual void
          clone (void* targetStorage)  const
            {
              new(targetStorage) Buff(get());
            }
          
          virtual BaseP
          getBase()  const
            {
              return AccessPolicy::convert2base (get());
            }
          
          virtual bool
          empty()  const
            {
              return false;
            }
          
          virtual bool
          isValid()  const
            {
              return validitySelfCheck (this->get());
            }
        };
      
      
      
      enum{ BUFFSIZE = sizeof(Buffer) };
      
      char storage_[BUFFSIZE];
      
      
      
      
      
      
    protected: /* === internal interface for managing the storage === */
      
      Buffer&
      buff()
        {
          return *reinterpret_cast<Buffer*> (&storage_);
        }
      const Buffer&
      buff()  const
        {
          return *reinterpret_cast<const Buffer *> (&storage_);
        }
      
      
      void
      killBuffer()                          
        {
          buff().~Buffer();
        }
      
      void
      make_emptyBuff()
        {
          new(&storage_) EmptyBuff();
        }
      
      template<class SUB>
      void
      place_inBuff (SUB const& obj)
        {
          new(&storage_) Buff<SUB> (obj);
        }
      
      void
      clone_inBuff (InPlaceAnyHolder const& ref)
        {
          ref.buff().clone (storage_);
        }
      
      BaseP
      asBase ()  const   
        {
          BaseP asBase = buff().getBase();
          ASSERT (asBase);
          return asBase;
        }
      
      
      
      
    public:
      
      ~InPlaceAnyHolder()
        {
          killBuffer();
        }
      
      void
      clear ()
        {
          killBuffer();
          make_emptyBuff();
        }
      
      
      InPlaceAnyHolder()
        { 
          make_emptyBuff();
        }
      
      template<class SUB>
      InPlaceAnyHolder(SUB const& obj)
        {
          place_inBuff (obj);
        }
      
      InPlaceAnyHolder (InPlaceAnyHolder const& ref)
        {
          clone_inBuff (ref);
        }
      
      InPlaceAnyHolder&
      operator= (InPlaceAnyHolder const& ref)
        {
          if (!isSameObject (*this, ref))
            {
              killBuffer();
              try
                {
                  clone_inBuff (ref);
                }
              catch (...)
                {
                  make_emptyBuff();
                  throw;
                }
            }
          return *this;
        }
      
      template<class SUB>
      InPlaceAnyHolder&
      operator= (SUB const& newContent)
        {
          if (  empty() 
             || !isSameObject (*buff().getBase(), newContent)
             )
            {
              killBuffer();
              try
                {
                  place_inBuff (newContent);
                }
              catch (...)
                {
                  make_emptyBuff();
                  throw;
                }
            }
          return *this;
        }
      
      
      
      template<class SUB>
      SUB& get()  const
        {
          typedef const Buffer* Iface;
          typedef const Buff<SUB> * Actual;
          Iface interface = &buff();
          Actual actual = dynamic_cast<Actual> (interface);
          if (actual)
            return actual->get();
          
          // second try: maybe we can perform a dynamic downcast
          // or direct conversion to the actual target type.
          SUB* content = AccessPolicy::template access<SUB> (asBase());
          if (content) 
            return *content;
          
          throw lumiera::error::Logic ("Attempt to access OpaqueHolder's contents "
                                       "specifying incompatible target type"
                                      , LUMIERA_ERROR_WRONG_TYPE
                                      );
        }
      
      
      
      bool
      empty() const
        {
          return buff().empty();
        }
      
      
      bool
      isValid() const
        {
          return buff().isValid();
        }
    };
  
  
  
  
  
  
  template
    < class BA                   
    , size_t siz = sizeof(BA)    
    >
  class OpaqueHolder
    : public InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> >
    {
      typedef InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> > InPlaceHolder;
      
    public:
      OpaqueHolder() : InPlaceHolder() {}
      
      template<class SUB>
      OpaqueHolder(SUB const& obj) : InPlaceHolder(obj) {}
      
      template<class SUB>
      OpaqueHolder&
      operator= (SUB const& newContent)
        {
          static_cast<InPlaceHolder&>(*this) = newContent;
          return *this;
        }
      
      // note: using standard copy operations
      
      
      
      /* === smart-ptr style access === */
      
      BA&
      operator* ()  const
        {
          ASSERT (!InPlaceHolder::empty());
          return *InPlaceHolder::buff().getBase();
        }
      
      BA* 
      operator-> ()  const
        {
          ASSERT (!InPlaceHolder::empty());
          return InPlaceHolder::buff().getBase();
        }
      
    };
  
  
  
  
  
  
  template
    < class BA                   
    , size_t siz = sizeof(BA)    
    , class DEFAULT = BA         
    >
  class InPlaceBuffer
    : boost::noncopyable
    {
      
      mutable char buf_[siz];
      
      
      BA&
      getObj()  const
        {
          return reinterpret_cast<BA&> (buf_);
        }
      
      void
      placeDefault()
        {
          new(&buf_) DEFAULT();
        }
      
      void
      destroy()
        {
          getObj().~BA();
        }
      
      
    public:
      InPlaceBuffer ()
        {
          placeDefault();
        }
      
     ~InPlaceBuffer ()
        {
          destroy();
        }
      
      
#define LIB_InPlaceBuffer_CTOR(_CTOR_CALL_) \
          destroy();                         \
          try                                 \
            {                                  \
              REQUIRE (siz >= sizeof(TY));      \
              return *new(&buf_) _CTOR_CALL_;    \
            }                                     \
          catch (...)                              \
            {                                       \
              placeDefault();                        \
              throw;                                  \
            }
      
      
      template<class TY>
      TY&
      create ()
        {
          LIB_InPlaceBuffer_CTOR ( TY() )
        }
      
      
      template<class TY, typename A1>
      TY&                                               //___________________________________________
      create (A1& a1)                                  
        {
          LIB_InPlaceBuffer_CTOR ( TY(a1) )
        }
      
      
      template< class TY
              , typename A1
              , typename A2
              >
      TY&                                               //___________________________________________
      create (A1& a1, A2& a2)                          
        {
          LIB_InPlaceBuffer_CTOR ( TY(a1,a2) )
        }
      
      
      template< class TY
              , typename A1
              , typename A2
              , typename A3
              >
      TY&                                               //___________________________________________
      create (A1& a1, A2& a2, A3& a3)                  
        {
          LIB_InPlaceBuffer_CTOR ( TY(a1,a2,a3) )
        }
      
      
      template< class TY
              , typename A1
              , typename A2
              , typename A3
              , typename A4
              >
      TY&                                               //___________________________________________
      create (A1& a1, A2& a2, A3& a3, A4& a4)          
        {
          LIB_InPlaceBuffer_CTOR ( TY(a1,a2,a3,a4) )
        }
      
      
      template< class TY
              , typename A1
              , typename A2
              , typename A3
              , typename A4
              , typename A5
              >
      TY&                                               //___________________________________________
      create (A1& a1, A2& a2, A3& a3, A4& a4, A5& a5)  
        {
          LIB_InPlaceBuffer_CTOR ( TY(a1,a2,a3,a4,a5) )
        }
      
      
      
      /* === smart-ptr style access === */
      
      BA&
      operator* ()  const
        {
          return getObj();
        }
      
      BA* 
      operator-> ()  const
        {
          return &getObj();
        }
      
      
      template<class SUB>
      static SUB*
      access ()
        {
          BA * asBase = &getObj();
          SUB* content = util::AccessCasted<SUB*>::access (asBase);
          return content;
        }     // NOTE: might be null.
    };
  
  
  
  
} // namespace lib
#endif

---