variadic-helper.hpp

Go to the documentation of this file.

/*
  VARIADIC-HELPER.hpp  -  metaprogramming utilities for parameter- and type sequences

  Copyright (C)         Lumiera.org
    2016,               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_META_VARIADIC_HELPER_H
#define LIB_META_VARIADIC_HELPER_H

#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-util.hpp"
#include "lib/meta/typeseq-util.hpp"
#include "lib/meta/util.hpp"

namespace lib {
namespace meta {
  

  template<typename...TYPES>
  struct TySeq
    {
      using Seq = TySeq;
      using List = typename Types<TYPES...>::List;
    };
  
  
  template<typename T, typename...TYPES>
  struct Prepend<T, TySeq<TYPES...>>
  {
    using Seq  = TySeq<T, TYPES...>;
    using List = typename Types<T, TYPES...>::List;
  };
  
  
  template<typename SEQ>
  struct StripNullType;
  
  template<typename T, typename...TYPES>
  struct StripNullType<Types<T,TYPES...>>
    {
      using TailSeq = typename StripNullType<Types<TYPES...>>::Seq;
      
      using Seq = typename Prepend<T, TailSeq>::Seq;
    };
  
  template<typename...TYPES>
  struct StripNullType<Types<NullType, TYPES...>>
    {
      using Seq = TySeq<>;  // NOTE: this causes the result to be a TySeq
    };
  
  
  
  
  
  
  template<typename X>
  constexpr inline X const&
  max (X const& a, X const& b)
    {
      return a < b? b : a;
    }
  
  template<typename X>
  constexpr inline X const&
  min (X const& a, X const& b)
    {
      return b < a? b : a;
    }
  
  
  
  
  
  
  
  /* ==== Build Variadic Sequences ==== **/
  
  
  template<size_t...idx>
  struct IndexSeq
    {
      template<size_t i>
      using AppendElm = IndexSeq<idx..., i>;
      
      template<size_t i>
      using PrependElm = IndexSeq<i, idx...>;
    };
  
  template<size_t n>
  struct BuildIndexSeq
    {
      using Ascending  = typename BuildIndexSeq<n-1>::Ascending::template AppendElm<n-1>;
      using Descending = typename BuildIndexSeq<n-1>::Descending::template PrependElm<n-1>;
      
      template<size_t d>
      using OffsetBy   = typename BuildIndexSeq<n-1>::template OffsetBy<d>::template AppendElm<n-1+d>;
      
      template<size_t x>
      using FilledWith = typename BuildIndexSeq<n-1>::template FilledWith<x>::template AppendElm<x>;
      
      template<size_t c>
      using First = typename BuildIndexSeq<min(c,n)>::Ascending;
      
      template<size_t c>
      using After = typename BuildIndexSeq< (n>c)? n-c : 0>::template OffsetBy<c>;
    };
  
  template<>
  struct BuildIndexSeq<0>
    {
      using Empty = IndexSeq<>;
      
      using Ascending  = Empty;
      using Descending = Empty;
      
      template<size_t>
      using OffsetBy   = Empty;
      
      template<size_t>
      using FilledWith = Empty;
      
      template<size_t>
      using First = Empty;
      
      template<size_t>
      using After = Empty;
    };
  
  
  
  template<typename...TYPES>
  struct BuildIdxIter
    {
      enum {SIZ = sizeof...(TYPES) };
      using Builder = BuildIndexSeq<SIZ>;
      
      using Ascending  = typename Builder::Ascending;
      using Descending = typename Builder::Descending;
      
      template<size_t d>
      using OffsetBy   = typename Builder::template OffsetBy<d>;
      
      template<size_t x>
      using FilledWith = typename Builder::template FilledWith<x>;
      
      template<size_t c>
      using First = typename Builder::template First<c>;
      
      template<size_t c>
      using After = typename Builder::template After<c>;
    };

  template<typename...TYPES>
  struct BuildIdxIter<Types<TYPES...>>
    {
      enum {SIZ = lib::meta::count<typename Types<TYPES...>::List>::value };
      using Builder = BuildIndexSeq<SIZ>;
      
      using Ascending  = typename Builder::Ascending;
      using Descending = typename Builder::Descending;
      
      template<size_t d>
      using OffsetBy   = typename Builder::template OffsetBy<d>;
      
      template<size_t x>
      using FilledWith = typename Builder::template FilledWith<x>;
      
      template<size_t c>
      using First = typename Builder::template First<c>;
      
      template<size_t c>
      using After = typename Builder::template After<c>;
    };
  
  
  
  
  
  /* ==== Rebinding Variadic Arguments ==== **/
  
  template<template<typename...> class X, typename...ARGS>
  struct RebindVariadic
    {
      using Type = X<ARGS...>;
    };
  
  template<template<typename...> class X
          ,template<typename...> class U
          ,typename...ARGS>
  struct RebindVariadic<X, U<ARGS...>>
    {
      using Type = X<ARGS...>;
    };
  
  
  
  
  
  
  
  /* ==== Manipulation of variadic arguments ==== **/
  
  namespace { // Implementation delegate template...
    template<size_t i>
    struct SelectVararg
      {
        template<typename ARG, typename...ARGS>
        static auto
        get (ARG, ARGS&& ...args)
          {
            return SelectVararg<i-1>::get (std::forward<ARGS> (args)...);
          }
      };
    
    template<>
    struct SelectVararg<0>
      {
        template<typename ARG, typename...ARGS>
        static auto
        get (ARG&& a, ARGS...)
          {
            return std::forward<ARG>(a);
          }
      };
    
    template<bool, typename, size_t idx>
    struct SelectOrInit
      : SelectVararg<idx>
      { };
    
    template<typename DEFAULT, size_t idx>
    struct SelectOrInit<false, DEFAULT, idx>
      {
        template<typename...ARGS>
        static DEFAULT
        get (ARGS&&...)
          {
            return DEFAULT{};
          }
      };
  }//(End)Implementation
  
  
  template<size_t idx, typename...ARGS>
  constexpr inline auto
  pickArg (ARGS&&... args)
    {
      static_assert (idx < sizeof...(args), "insufficient number of arguments");
      
      return SelectVararg<idx>::get (std::forward<ARGS> (args)...);
    }
  
  template<size_t idx, typename DEFAULT, typename...ARGS>
  constexpr inline auto
  pickInit (ARGS&&... args)
    {
      return SelectOrInit<(idx < sizeof...(args)), DEFAULT, idx>::get (std::forward<ARGS> (args)...);
    }
  
  
  
}} // namespace lib::meta
#endif /*LIB_META_VARIADIC_HELPER_H*/