variant.hpp

Go to the documentation of this file.

/*
  VARIANT.hpp  -  lightweight typesafe union record

  Copyright (C)         Lumiera.org
    2015,               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_VARIANT_H
#define LIB_VARIANT_H


#include "lib/error.hpp"
#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-util.hpp"
#include "lib/meta/generator.hpp"
#include "lib/meta/virtual-copy-support.hpp"
#include "lib/format-obj.hpp"
#include "lib/util.hpp"

#include <type_traits>
#include <cstddef>
#include <utility>
#include <string>


namespace lib {
  
  using std::string;
  
  using std::move;
  using std::forward;
  using util::unConst;
  
  namespace error = lumiera::error;
  
  
  namespace variant { // implementation metaprogramming helpers
    
    using std::remove_reference;
    using meta::NullType;
    using meta::Types;
    using meta::Node;
    
    
    template<typename X, typename TYPES>
    struct CanBuildFrom
      : CanBuildFrom<typename remove_reference<X>::type
                    ,typename TYPES::List
                    >
      { };
    
    template<typename X, typename TYPES>
    struct CanBuildFrom<X, Node<X, TYPES>>
      : std::true_type
      {
        using Type = X;
      };
    
    template<typename X, typename TYPES>
    struct CanBuildFrom<const X, Node<X, TYPES>>
      : std::true_type
      {
        using Type = X;
      };
    
    template<typename TYPES, size_t len>
    struct CanBuildFrom<const char [len], Node<string, TYPES>> 
      : std::true_type
      {
        using Type = string;
      };
    
    template<typename X, typename T,typename TYPES>
    struct CanBuildFrom<X, Node<T, TYPES>>
      : CanBuildFrom<X,TYPES>
      { };
    
    template<typename X>
    struct CanBuildFrom<X, NullType>
      : std::false_type
      { };
    
    
    template<typename T>
    struct Identity { using Type = T; };
    
    template<class TYPES, template<class> class _P_>
    struct FirstMatchingType
      {
        static_assert(not sizeof(TYPES), "None of the possible Types fulfils the condition");
      };
    
    template<class...TYPES, template<class> class _P_>
    struct FirstMatchingType<Types<TYPES...>, _P_>
      : FirstMatchingType<typename Types<TYPES...>::List, _P_>
      { };
    
    template<class T, class TYPES, template<class> class _P_>
    struct FirstMatchingType<Node<T,TYPES>, _P_>
      : std::conditional_t<_P_<T>::value, Identity<T>, FirstMatchingType<TYPES, _P_>>
      {  };
    
    
    
    template<typename RET>
    struct VFunc
      {
        template<class VAL>
        struct ValueAcceptInterface
          {
            virtual RET handle(VAL&) { /* do nothing */ return RET(); };
          };
        
        
        template<typename TYPES>
        using VisitorInterface
            = meta::InstantiateForEach<typename TYPES::List, ValueAcceptInterface>;
        
      };
    
    
  }//(End) implementation helpers
  
  
  
  
  template<typename TYPES>
  class Variant
    {
      
    public:
      enum { SIZ   = meta::maxSize<typename TYPES::List>::value
           , ALIGN = meta::maxAlign<typename TYPES::List>::value
           };
      
      template<typename RET>
      using VisitorFunc      = typename variant::VFunc<RET>::template VisitorInterface<TYPES>;
      template<typename RET>
      using VisitorConstFunc = typename variant::VFunc<RET>::template VisitorInterface<meta::ConstAll<typename TYPES::List>>;
      
      class Visitor
        : public VisitorFunc<void>
        {
        public:
          virtual ~Visitor() { } 
        };
      
      class Predicate
        : public VisitorConstFunc<bool>
        {
        public:
          virtual ~Predicate() { } 
        };
      
      class Renderer
        : public VisitorConstFunc<string>
        {
        public:
          virtual ~Renderer() { } 
        };                                                      
      
      template<template<class> class _P_>
      using FirstMatching = variant::FirstMatchingType<TYPES, _P_>;
      
      
    private:
      struct Buffer
        : meta::VirtualCopySupportInterface<Buffer>
        {
          alignas(ALIGN)
            std::byte content_[SIZ];
          
          void* ptr() { return &content_; }
          
          
          virtual ~Buffer() {}           
          
          virtual void   dispatch (Visitor&)         =0;
          virtual bool   dispatch (Predicate&) const =0;
          virtual string dispatch (Renderer&)  const =0;
          virtual operator string()            const =0;
        };
      
      
      template<typename TY>
      struct Buff
        : meta::CopySupport<TY>::template Policy<Buffer,Buff<TY>>
        {
          static_assert (SIZ >= sizeof(TY), "Variant record: insufficient embedded Buffer size");
          
          TY&
          access()  const  
            {
              return * std::launder (reinterpret_cast<TY*> (unConst(this)->ptr()));
            }
          
         ~Buff()
            {
              access().~TY();
            }
          
          Buff (TY const& obj)
            {
              new(Buffer::ptr()) TY(obj);
            }
          
          Buff (TY && robj)
            {
              new(Buffer::ptr()) TY(move(robj));
            }
          
          Buff (Buff const& oBuff)
            {
              new(Buffer::ptr()) TY(oBuff.access());
            }
          
          Buff (Buff && rBuff)
            {
              new(Buffer::ptr()) TY(move (rBuff.access()));
            }
          
          void
          operator= (Buff const& buff)
            {
              *this = buff.access();
            }
          
          void
          operator= (Buff&& rref)
            {
              *this = move (rref.access());
            }
          
          void
          operator= (TY const& ob)
            {
              if (&ob != Buffer::ptr())
                this->access() = ob;
            }
          
          void
          operator= (TY && rob)
            {
              if (&rob != Buffer::ptr())
                this->access() = move(rob);
            }
          
          
          
          static string indicateTypeMismatch (Buffer&);
          
          
          static Buff&
          downcast (Buffer& b)
            {
              Buff* buff = dynamic_cast<Buff*> (&b);
              
              if (!buff)
                throw error::Logic(indicateTypeMismatch(b)
                                  ,LERR_(WRONG_TYPE));
              else
               return *buff;
            }
          
          void
          dispatch (Visitor& visitor)
            {
              using Dispatcher = variant::VFunc<void>::template ValueAcceptInterface<TY>;
              
              Dispatcher& typeDispatcher = visitor;
              typeDispatcher.handle (this->access());
            }
          
          bool
          dispatch (Predicate& visitor)  const
            {
              using Dispatcher = variant::VFunc<bool>::template ValueAcceptInterface<const TY>;
              
              Dispatcher& typeDispatcher = visitor;
              return typeDispatcher.handle (this->access());
            }
          
          string
          dispatch (Renderer& visitor)  const
            {
              using Dispatcher = variant::VFunc<string>::template ValueAcceptInterface<const TY>;
              
              Dispatcher& typeDispatcher = visitor;
              return typeDispatcher.handle (this->access());
            }
          
          operator string()  const;
        };
      
      enum{ BUFFSIZE = sizeof(Buffer) };
      
      char storage_[BUFFSIZE];
      
      
      
      
      
    protected: /* === internal interface for managing the storage === */
      
      Buffer&
      buffer()
        {
          return * std::launder (reinterpret_cast<Buffer*> (&storage_));
        }
      Buffer const&
      buffer()  const
        {
          return * std::launder (reinterpret_cast<const Buffer*> (&storage_));
        }
      
      template<typename X>
      Buff<X>&
      buff()
        {
          return Buff<X>::downcast(this->buffer());
        }
      
      template<typename X>
      X*
      maybeGet()
        {
          Buff<X>* buff = dynamic_cast<Buff<X>*> (& this->buffer());
          if (buff)
            return & buff->access();
          else
            return nullptr;
        }
      
      
    public:
     ~Variant()
        {
          buffer().~Buffer();
        }
      
      Variant()
        {
          using DefaultType = typename TYPES::List::Head;
          
          new(storage_) Buff<DefaultType> (DefaultType());
        }
      
      template<typename X>
      Variant(X&& x)
        {
          static_assert (variant::CanBuildFrom<X, TYPES>(), "No type in Typelist can be built from the given argument");
          
          using StorageType = typename variant::CanBuildFrom<X, TYPES>::Type;
          
          new(storage_) Buff<StorageType> (forward<X>(x));
        }
      
      Variant (Variant& ref)
        {
          ref.buffer().copyInto (&storage_);
        }
      
      Variant (Variant const& ref)
        {
          ref.buffer().copyInto (&storage_);
        }
      
      Variant (Variant&& rref)
        {
          rref.buffer().moveInto (&storage_);
        }
      
      template<typename X>
      Variant&
      operator= (X x)
        {
          using RawType = typename std::remove_reference<X>::type;
          static_assert (meta::isInList<RawType, typename TYPES::List>(),
                         "Type error: the given variant could never hold the required type");
          static_assert (std::is_copy_assignable<RawType>::value, "target type does not support assignment");
          
          buff<RawType>() = forward<X>(x);
          return *this;
        }
      
      Variant&
      operator= (Variant& ovar)
        {
          ovar.buffer().copyInto (this->buffer());
          return *this;
        }
      
      Variant&
      operator= (Variant const& ovar)
        {
          ovar.buffer().copyInto (this->buffer());
          return *this;
        }
      
      Variant&
      operator= (Variant&& rvar)
        {
          rvar.buffer().moveInto (this->buffer());
          return *this;
        }
      
      //note: NOT defining a swap operation, because swapping inline storage is pointless!
      
      
      operator string()  const;
      
      
      /* === Access === */
      
      template<typename X>
      X&
      get()
        {
          static_assert (meta::isInList<X, typename TYPES::List>(),
                         "Type error: the given variant could never hold the required type");
          
          return buff<X>().access();
        }
      
      template<typename X>
      X const&
      get()  const
        {
          return unConst(this)->template get<X>();
        }
      
      void
      accept (Visitor& visitor)
        {
          buffer().dispatch (visitor);
        }
      
      bool
      accept (Predicate& visitor)  const
        {
          return buffer().dispatch (visitor);
        }
      
      string
      accept (Renderer& visitor)  const
        {
          return buffer().dispatch (visitor);
        }
    };
  
  
  
  /* == diagnostic helper == */

  
  template<typename TYPES>
  Variant<TYPES>::operator string()  const
  {
    return "Variant|" + string(buffer());
  }
  
  template<typename TYPES>
  template<typename TY>
  Variant<TYPES>::Buff<TY>::operator string()  const
  {
    return util::typedString (this->access());
  }
  
  template<typename TYPES>
  template<typename TY>
  inline string
  Variant<TYPES>::Buff<TY>::indicateTypeMismatch(Variant<TYPES>::Buffer& target)
  {
    try {
        return "Variant type mismatch: expected value of type «"
             + lib::meta::typeStr<TY>()+"», "
             + "however the given variant record is "
             + string{target};
      }
    catch(...) { return lib::meta::FAILURE_INDICATOR; }
  }
  
  
}// namespace lib
#endif /*LIB_VARIANT_H*/