dataset/tuple_generator.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser Public License as published by
// the Free Software Foundation, either version 3 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 Lesser Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __TUPLE_GENERATOR_HH
# define __TUPLE_GENERATOR_HH

# include <tuple>

namespace catsfoot {

  namespace details {

    template <typename U>
    struct tuple_generator_tool {};

    template <typename... U>
    struct tuple_generator_tool<std::tuple<U...>& >:
    public tuple_generator_tool<std::tuple<U...> > {
    };

    template <typename... U>
    struct tuple_generator_tool<const std::tuple<U...>& >:
    public tuple_generator_tool<std::tuple<U...> > {
    };

    template <typename... U>
    struct tuple_generator_tool<std::tuple<U...> > {

      template <typename... V, typename... Values,
                typename = void,
                typename = typename std::enable_if
                <(sizeof...(V) == sizeof...(Values))>::type>
      std::list<std::tuple<U...> >
      make_list(std::tuple<V...>&, Values... values...)
      const {
        return std::list<std::tuple<U...> >
          {std::tuple<U...>
            {std::forward<Values>(values)...}};
      }

      template <typename... V, typename... Values,
                typename = typename
                std::enable_if<(sizeof...(V) > sizeof...(Values))>::type>
      std::list<std::tuple<U...> >
      make_list(std::tuple<V...>& containers,
                Values... values) const
      {
        std::list<std::tuple<U...> > ret;
        typename std::tuple_element<sizeof...(Values),
                                    std::tuple<V...> >::type&
        local_container(std::get<sizeof...(Values)>(containers));

        for (auto i = local_container.begin();
             i != local_container.end();
             ++i) {
          auto r = make_list(containers, std::forward<Values>(values)...,
                             typename
                             std::tuple_element<sizeof...(Values),
                                                std::tuple<U...> >::type(*i));
          ret.splice(ret.end(), r);
        }
        return ret;
      }

      template <typename Generator>
      std::list<std::tuple<U...> >
      operator()(Generator& g) const {
        std::tuple<typename std::decay
                   <decltype(g.get(selector<U>()))>::type
                   ...>
          containers(g.get(selector<U>())...);
        return make_list(containers);
      }
    };

    template <typename Generator>
    struct tuple_generator {
    private:
      Generator g;

    public:
      tuple_generator(Generator&& g): g(std::move(g)) {}
      tuple_generator(const Generator& g): g(g) {}

      tuple_generator(const tuple_generator& other): g(other.g) {}
      tuple_generator(tuple_generator&& other): g(std::move(other.g)) {}

      template <typename U>
      decltype(tuple_generator_tool<U>()
               (std::declval<const Generator&>()))
      get(selector<U>) {
        return tuple_generator_tool<U>()(g);
      }
    };
  }

  template <typename Generator>
  details::tuple_generator<typename std::decay<Generator>::type>
  tuple_gen(Generator&& g) {
    return details::tuple_generator<typename std::decay<Generator>::type>
      (std::forward<Generator>(g));
  }
}

#endif