common/variant.hpp

Go to the documentation of this file.

/*
  VARIANT.hpp  -  simple variant wrapper (typesafe union)
 
  Copyright (C)         Lumiera.org
    2008,               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 LUMIERA_VARIANT_H
#define LUMIERA_VARIANT_H


#include "common/meta/typelistutil.hpp"
#include "common/meta/generator.hpp"

#include <boost/noncopyable.hpp>



namespace lumiera {
  
  namespace variant {
    
    using lumiera::typelist::count;
    using lumiera::typelist::maxSize;
    using lumiera::typelist::InstantiateWithIndex;
    
    template<typename TYPES>
    struct Holder
      {
        
        enum { TYPECNT = count<TYPES>::value
             , SIZE  = maxSize<TYPES>::value
             };
        
        
        struct Buffer
          {
            char buffer_[SIZE];
            uint which_;
            
            Buffer() : which_(TYPECNT) {}
            
            void* 
            put (void)
              {
                deleteCurrent();
                return 0;
              }
            
            void
            deleteCurrent ();  // depends on the Deleter, see below
          };
        
        template<typename T, class BASE, uint idx>
        struct PlacementAdapter : BASE
          {
            T& 
            put (T const& toStore)
              {
                BASE::deleteCurrent(); // remove old content, if any
                
                T& storedObj = *new(BASE::buffer_) T (toStore);
                BASE::which_ = idx; //    remember the actual type selected
                return storedObj;
              }
            
            using BASE::put;
          };
        
        typedef InstantiateWithIndex< TYPES
                                    , PlacementAdapter
                                    , Buffer
                                    > 
                                    Storage;
        
        
        
        template<class FUNCTOR>
        struct CaseSelect
          {
            typedef typename FUNCTOR::Ret Ret;
            typedef Ret (*Func)(Buffer&);
            
            Func table_[TYPECNT];
            
            CaseSelect ()
              {
                for (uint i=0; i<TYPECNT; ++i)
                  table_[i] = 0;
              }
            
            template<typename T>
            static Ret
            trampoline (Buffer& storage)
              {
                T& content = reinterpret_cast<T&> (storage.buffer_);
                return FUNCTOR::access (content);
              }
            
            Ret
            invoke (Buffer& storage)
              {
                if (TYPECNT <= storage.which_)
                  return FUNCTOR::ifEmpty ();
                else
                  return (*table_[storage.which_]) (storage);
              }
          };
        
        
        template< class T, class BASE, uint i >
        struct CasePrepare
          : BASE
          {
            CasePrepare () : BASE()
              {
                BASE::table_[i] = &BASE::template trampoline<T>;
              }
          };
        
          
        template<class FUNCTOR>
        static typename FUNCTOR::Ret
        access (Buffer& buf)
        {
          typedef InstantiateWithIndex< TYPES
                                      , CasePrepare
                                      , CaseSelect<FUNCTOR>
                                      > 
                                      Accessor;
          static Accessor select_case;
          return select_case.invoke(buf);
        }
        
        
        struct Deleter
          {
            typedef void Ret;
            
            template<typename T>
            static void access (T& elem) { elem.~T(); }
            
            static void ifEmpty () { }
          };
      };
      
      
      template<typename TYPES>
      inline void
      Holder<TYPES>::Buffer::deleteCurrent ()
      {
        access<Deleter>(*this); // remove old content, if any
        which_ = TYPECNT;      //  mark as empty
      }
      
  } // namespace variant
  
  
  
  
  
  
  
  
  template< typename TYPES
          , template<typename> class Access  
          >
  class Variant 
    : boost::noncopyable
    {
      
      typedef variant::Holder<TYPES> Holder;
      typedef typename Holder::Deleter Deleter;
      
      
      typename Holder::Storage holder_;
      
      
    public:
      void reset () { holder_.deleteCurrent();}
      
      template<typename SRC>
      Variant&
      operator= (SRC src)
        {
          if (src) holder_.put (src);  // see Holder::PlacementAdaptor::put
          else     reset();
          return *this;
        }
      
      template<typename TAR>
      TAR
      get ()
        {
          typedef Access<TAR> Extractor;
          return Holder::template access<Extractor> (this->holder_);
        }
    };
  
} // namespace lumiera 
#endif

---