variadic-helper.hpp

Go to the documentation of this file.

/*
  VARIADIC-HELPER.hpp  -  metaprogramming utilities for parameter- and type sequences
 
   Copyright (C)
     2016,            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_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/variadic-rebind.hpp"
#include "lib/meta/util.hpp"
 
namespace lib {
namespace meta {
 
  
  
  /* ==== 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  = BuildIndexSeq<n-1>::Ascending::template AppendElm<n-1>;
      using Descending = BuildIndexSeq<n-1>::Descending::template PrependElm<n-1>;
      
      template<size_t d>
      using OffsetBy   = BuildIndexSeq<n-1>::template OffsetBy<d>::template AppendElm<n-1+d>;
      
      template<size_t x>
      using FilledWith = BuildIndexSeq<n-1>::template FilledWith<x>::template AppendElm<x>;
      
      template<size_t c>
      using First      = BuildIndexSeq<std::min(c,n)>::Ascending;
      
      template<size_t c>
      using After      = BuildIndexSeq< (n>c)? n-c : 0>::template OffsetBy<c>;
    };
  
  template<>
  struct BuildIndexSeq<0>
    {
      using EmptySeq = IndexSeq<>;
      
      using Ascending  = EmptySeq;
      using Descending = EmptySeq;
      
      template<size_t>
      using OffsetBy   = EmptySeq;
      
      template<size_t>
      using FilledWith = EmptySeq;
      
      template<size_t>
      using First = EmptySeq;
      
      template<size_t>
      using After = EmptySeq;
    };
  
  
  
  template<typename...TYPES>
  struct BuildIdxIter
    {
      enum {SIZ = sizeof...(TYPES) };
      using Builder = BuildIndexSeq<SIZ>;
      
      using Ascending  = Builder::Ascending;
      using Descending = Builder::Descending;
      
      template<size_t d>
      using OffsetBy   = Builder::template OffsetBy<d>;
      
      template<size_t x>
      using FilledWith = Builder::template FilledWith<x>;
      
      template<size_t c>
      using First      = Builder::template First<c>;
      
      template<size_t c>
      using After      = Builder::template After<c>;
    };
 
  template<typename...TYPES>
  struct BuildIdxIter<Types<TYPES...>>
    : BuildIdxIter<TYPES...>
    { };
  
  
  
  
  
  
  
  
  /* ==== Build and Rebuild variadic type sequences ==== **/
  
  template<class X,  typename =void>
  struct ElmTypes
    {
      static constexpr size_t SIZ = 1;
      using Idx = std::index_sequence<SIZ>;
      using Seq = Types<X>;
      using Tup = std::tuple<X>;
      
      template<template<class> class META>
      using Apply = Types<META<X>>;
      template<template<typename...> class O>
      using Rebind = O<X>;
      template<template<class> class PRED>
      using AndAll = std::__and_<PRED<X>>;
      template<template<class> class PRED>
      using OrAll  = std::__or_<PRED<X>>;
    };
  
  template<typename...TYPES>
  struct ElmTypes<Types<TYPES...>>
    {
      static constexpr size_t SIZ = sizeof...(TYPES);
      using Idx = std::make_index_sequence<SIZ>;
      using Seq = Types<TYPES...>;
      using Tup = std::tuple<TYPES...>;
      
      template<template<class> class META>
      using Apply = Types<META<TYPES>...>;
      
      template<template<typename...> class O>
      using Rebind = lib::meta::RebindVariadic<O, Seq>::Type;
      
      template<template<class> class PRED>
      using AndAll = ElmTypes<Apply<PRED>>::template Rebind<std::__and_>;
      
      template<template<class> class PRED>
      using OrAll  = ElmTypes<Apply<PRED>>::template Rebind<std::__or_>;
    };
  
  // Note: a further specialisation for any »tuple-like« is defined in tuple-helper.hpp
  
  
  
  
  
  
  /* ==== Invoke with index from variadic ==== **/
  
  template<size_t N>
  class WithIdxSeq
    {
      template<class FUN, size_t...idx>
      static constexpr void
      invoke_forEach (FUN&& fun, std::index_sequence<idx...>)
        {
          (fun (std::integral_constant<size_t,idx>{}), ...);
        }
      
      template<class FUN, size_t...idx>
      static constexpr bool
      and_forEach (FUN&& fun, std::index_sequence<idx...>)
        {
          return (fun (std::integral_constant<size_t,idx>{}) and ...);
        }
      
      template<class FUN, size_t...idx>
      static constexpr bool
      or_forEach (FUN&& fun, std::index_sequence<idx...>)
        {
          return (fun (std::integral_constant<size_t,idx>{}) or ...);
        }
      
      using IdxSeq = std::make_index_sequence<N>;
      
    public:
      template<class FUN>
      static constexpr void
      invoke (FUN&& fun)
        {
          invoke_forEach (std::forward<FUN>(fun), IdxSeq{});
        }
      
      template<class FUN>
      static constexpr bool
      andAll (FUN&& fun)
        {
          return and_forEach (std::forward<FUN>(fun), IdxSeq{});
        }
      
      template<class FUN>
      static constexpr bool
      orAny (FUN&& fun)
        {
          return or_forEach (std::forward<FUN>(fun), IdxSeq{});
        }
    };
  
  template<class TTX, class FUN>
  inline void
  forEachIDX (FUN&& fun)
  {
    WithIdxSeq<ElmTypes<TTX>::SIZ>::invoke (std::forward<FUN> (fun));
  }
  
  template<class TTX, class FUN>
  inline bool
  andAllIDX (FUN&& fun)
  {
    return WithIdxSeq<ElmTypes<TTX>::SIZ>::andAll (std::forward<FUN> (fun));
  }
  
  template<class TTX, class FUN>
  inline bool
  orAnyIDX (FUN&& fun)
  {
    return WithIdxSeq<ElmTypes<TTX>::SIZ>::orAny (std::forward<FUN> (fun));
  }
  
  
  
 
  
  
  
  
  /* ==== 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*/