branch-case.hpp

Go to the documentation of this file.

/*
  BRANCH-CASE.hpp  -  variant-like data type to capture different result types
 
   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_BRANCH_CASE_H
#define LIB_BRANCH_CASE_H
 
 
#include "lib/meta/util.hpp"
 
#include <utility>
#include <cstddef>
#include <tuple>
 
namespace lib {
  
  using std::move;
  using std::forward;
  using std::decay_t;
  using std::tuple;
  
  
  namespace {// Metaprogramming helper
    
    template<typename...TYPES>
    struct _MaxBuf;
    
    template<>
    struct _MaxBuf<>
      {
        static constexpr size_t siz = 0;
        static constexpr size_t align = 0;
      };
    
    template<typename T, typename...TYPES>
    struct _MaxBuf<T,TYPES...>
      {
        static constexpr size_t siz   = std::max (sizeof(T),_MaxBuf<TYPES...>::siz);
        static constexpr size_t align = std::max (alignof(T),_MaxBuf<TYPES...>::align);
      };
  }//(End)Meta-helper
  
  
  
  /*********************************************************************/
  template<typename...TYPES>
  class BranchCase
    {
    public:
      static constexpr auto TOP = sizeof...(TYPES) -1;
      static constexpr auto SIZ = _MaxBuf<TYPES...>::siz;
      
      template<size_t idx>
      using SlotType = std::tuple_element_t<idx, tuple<TYPES...>>;
 
    protected:
      BranchCase() = default; 
      
      size_t branch_{0};
      
      alignas(_MaxBuf<TYPES...>::align)
        std::byte buffer_[SIZ];
      
      
      template<typename TX, typename...INITS>
      TX&
      emplace (INITS&&...inits)
        {
          return * new(&buffer_) TX(forward<INITS> (inits)...);
        }
      
      template<typename TX>
      TX&
      access ()
        {
          return * std::launder (reinterpret_cast<TX*> (&buffer_[0]));
        }
      
      template<size_t idx, class FUN>
      auto
      selectBranch (FUN&& fun)
        {
          if constexpr (0 < idx)
            if (branch_ < idx)
              return selectBranch<idx-1> (forward<FUN>(fun));
          return fun (get<idx>());
        }
      
      
    public:
      template<class FUN>
      auto
      accept (FUN&& visitor)
        {
          return selectBranch<TOP> (forward<FUN> (visitor));
        }
      
     ~BranchCase()
        {
          accept ([this](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          access<Elm>().~Elm();
                        });
        }
      
      template<typename...INITS>
      BranchCase (size_t idx, INITS&& ...inits)
        : branch_{idx}
        {
          accept ([&,this](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          if constexpr (std::is_constructible_v<Elm,INITS...>)
                              this->emplace<Elm> (forward<INITS> (inits)...);
                        });
        }
      
      BranchCase (BranchCase const& o)
        {
          branch_ = o.branch_;
          BranchCase& unConst = const_cast<BranchCase&> (o);
          unConst.accept ([this](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          this->emplace<Elm> (it);
                        });
        }
      
      BranchCase (BranchCase && ro)
        {
          branch_ = ro.branch_;
          ro.accept ([this](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          this->emplace<Elm> (move (it));
                        });
        }
      
      friend void
      swap (BranchCase& o1, BranchCase& o2)
        {
          using std::swap;
          BranchCase tmp;
          tmp.branch_ = o1.branch_;
          o1.accept ([&](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          tmp.emplace<Elm> (move (o1.access<Elm>()));
                        });
          swap (o1.branch_,o2.branch_);
          o1.accept ([&](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          o1.emplace<Elm> (move (o2.access<Elm>()));
                        });
          o2.accept ([&](auto& it)
                        { using Elm = decay_t<decltype(it)>;
                          o2.emplace<Elm> (move (tmp.access<Elm>()));
                        });
        }
      
      BranchCase&
      operator= (BranchCase ref)
        {
          swap (*this, ref);
          return *this;
        }
      
      
      size_t
      selected()  const
        {
          return branch_;
        }
      
      template<size_t idx>
      SlotType<idx>&
      get()
        {
          return access<SlotType<idx>>();
        }
      
      auto
      getAny()
        {
          return accept([](auto val){ return val; });
        }
    };
  
}// namespace lib
#endif/*LIB_BRANCH_CASE_H*/