Find untagged template options/parameters/args by position

Question

In short: I want to extract various options from variadic template parameters, but not only by tag but by index for those parameters, that have no known tag. I like the approach in boost (e.g. heap or lockfree policies), but want to make it compatible with STL containers - the allocator parameter.

Preface

I am currently writing template for queue/buffer of variable-size records/objects with this signature:

// current:
template <typename R = byte, class Alloc = std::allocator<byte>,
  class... Opts> class rqueue;
// what I want:
template <class... Opts> class rqueue;

I have few other possible options which I described like this:

namespace tag {
    struct allocator {};        ///< specify allocator for data storage
    struct virtual_offset {};   ///< manage offset in virtual memory
    struct fill_empty {};       ///< fill empty space (security or reconstruction)
    struct reconstructible {};  ///< fill empty and leave one slot between wp&rp
} namespace opt {
/// allocator for data storage
    template <class Alloc> struct allocator: tag::allocator {
        typedef Alloc type; };
/// type for offset in virtual memory
    template <class Off> struct virtual_offset: tag::virtual_offset {
        typedef Off type; };
/// type and value to fill empty space
    template <class T, T V> struct fill_empty: tag::fill_empty {
        typedef T type; static constexpr T value = V; };
/// make state pointers reconstructible by leaving one slot between wp&rp
    template <class T, T V> struct reconstructible
      : tag::reconstructible, fill_empty<T, V> {};
}

Usage

// basic queue for custom record class
rqueue<record>;
// advanced record storage that can be written to a file and reconstructed back
rqueue<opt::virtual_offset<unsigned>, opt::reconstructible<byte,0xFF>>;
// specialization for strings with custom allocator
rqueue<string, myalloc>;
// alternative to above
rqueue<const char*, opt::allocator<myalloc>>;

Option Pack Helper

namespace opt {
template<class... Opts> struct bind {
    template<class Tag> static constexpr bool has() {
        return false; }
    template<class Tag, class Default = void>
      using get = Default; };
template<class First, class... More> struct bind<First, More...> {
private:
    template<class Tag> static constexpr bool first() {
        return std::is_same<Tag, First>::value
          || std::is_base_of<Tag, First>::value; }
    template<class Tag, class Default, bool> struct get_ {
        typedef typename bind<More...>::template get<Tag, Default> type; };
    template<class Tag, class Default> struct get_<Tag, Default, true> {
        typedef First type; };
public:
    template<class Tag> static constexpr bool has() {
        return first<Tag>() || bind<More...>::template has<Tag>(); }
    template<class Tag, class Default = void>
      using get = typename get_<Tag, Default, first<Tag>()>::type; };
}

It is not that advanced as The Boost Parameter Library, but gets the job done... so far, with list of untagged required params and tagged optional params.

Test Code

cout << boolalpha;

typedef opt::bind<
  opt::virtual_offset<unsigned>,
  opt::reconstructible<char,0>
  > opts;
cout << opts::has<tag::virtual_offset>() << endl;
cout << opts::has<tag::fill_empty>() << endl;
cout << opts::has<tag::reconstructible>() << endl;
cout << typeid(opts::get<tag::virtual_offset>::type).name() << endl;
cout << typeid(opts::get<tag::fill_empty>::type).name() << endl;
cout << (int)opts::get<tag::fill_empty>::value << endl;

typedef opt::bind<> no;
cout << no::has<tag::virtual_offset>() << endl;
cout << no::has<tag::fill_empty>() << endl;
cout << no::has<tag::reconstructible>() << endl;
cout << typeid(no::get<tag::virtual_offset>).name() << endl;

typedef opt::bind<opt::fill_empty<char,0>> one;
cout << one::has<tag::virtual_offset>() << endl;
cout << one::has<tag::fill_empty>() << endl;
cout << one::has<tag::reconstructible>() << endl;
cout << typeid(one::get<tag::virtual_offset>).name() << endl;

Questions

I was searching the complex boost parameter / metaprogramming library and ended in metafunctions which can do the same work as my small helper (and of course much more), but didn't find a solution for extracting untagged options by index.

1. Did I miss it? Is it there somewhere?
2. Can you offer me some different solution?

Maybe I should just forget about it and stick with those tags, or write some complex helper to filter out all tagged options and acces those left by index... But before I surrender or go the long way, here is nice place to ask :)

Note: If you refer to some library, leave a description how to use it, please. Thank you.

Answer 1

I have managed to get it working

(specialization of already presented option pack helper, merge with original code)

template<class... Tags> struct tags {
    template<class Option> static constexpr bool match() {
        return false; }};
template<class First, class... More> struct tags<First, More...> {
    template<class Option> static constexpr bool match() {
        return std::is_same<First, Option>::value
          || std::is_base_of<First, Option>::value
          || tags<More...>::template match<Option>(); }};
//-----------------------------------------------------------------------
template<class... Tags, class... Opts>
  struct bind<tags<Tags...>, Opts...> {
    static constexpr size_t size = sizeof...(Opts);
    typedef opt::tags<Tags...> tags;
    template<class Tag> static constexpr bool has() {
        return false; }
    template<class Tag, class Default = void>
      using get = Default;
    template<size_t idx, class Default = void>
      using at = Default;
    static constexpr size_t count = 0; };
template<class... Tags, class First, class... More>
  struct bind<tags<Tags...>, First, More...> {
public:
    typedef opt::tags<Tags...> tags;
    static constexpr size_t size = 1 + sizeof...(More);
private:
    template<size_t idx, class Default, bool> struct at_ {
        typedef typename bind<tags, More...>::template at<idx,Default> type; };
    template<size_t idx, class Default> struct at_<idx, Default, false> {
        typedef typename bind<tags, More...>::template at<idx-1,Default> type; };
    template<class Default> struct at_<0, Default, false> {
        typedef First type; };
public:
    template<class Tag> static constexpr bool has() {
        return bind<First, More...>::template has<Tag>(); }
    template<class Tag, class Default = void>
      using get = typename bind<First, More...>::template get<Tag,Default>;
    template<size_t idx, class Default = void>
      using at = typename at_<idx, Default, tags::template match<First>()>::type;
    static constexpr size_t count = bind<tags, More...>::count
      + (tags::template match<First>() ? 0 : 1); };

Usage

template <class... Opts> class rqueue {
//  bind tags and options
    typedef opt::bind<opt::tags<tag::allocator,
      tag::virtual_offset, tag::fill_empty,
      tag::reconstructible, tag::fixed_size>,
      Opts...> opts;
public:
//  get first untagged option or byte if none
    typedef typename opts::template at<0,byte>
      value_type, record_type, *pointer, &reference;
//  get second untagged option, or allocator option or std::allocator<byte>
    typedef typename std::conditional<
      (opts::count > 1),
      typename opts::template at<1>,
      typename opts::template get<tag::allocator,
      std::allocator<byte>>>::type allocator_type;
//...shorter version of the above
    typedef typename opts::template at<1,
      typename opts::template get<tag::allocator,
      std::allocator<byte>>> allocator_type_v2;
//  get type specified as virtual_offset or void
    typedef typename opts::template get<tag::virtual_offset,
      std::enable_if<true>>::type offset_type;