dataset/dataset.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 __DATASET_HH
# define __DATASET_HH

# include "../concept/concept_tools.hh"
# include <list>
# include "position.hh"
# include "../type_traits/identity.hh"
# include <initializer_list>
# include "../wrappers/members.hh"
# include "../type_traits/is_callable.hh"
# include "../type_traits/always_false.hh"

namespace catsfoot {
  DEF_MEMBER_WRAPPER(begin);
  DEF_MEMBER_WRAPPER(end);
  DEF_MEMBER_WRAPPER(get);

  template <typename T>
  struct selector {
    typedef T type;
  };

  template <typename T, typename ValueType>
  struct container: public auto_concept {
    typedef concept_list<
      is_callable<member_begin(T)>,
      is_callable<member_end(T)>
      > requirements;
  };

  template <typename T, typename Type>
  struct generator_for: public auto_concept {
    typedef concept_list<
      is_callable<member_get(T, selector<Type>)>,
      container<typename is_callable<member_get(T, selector<Type>)>
                ::result_type,
                Type>
      > requirements;
  };

  struct default_generator {
    template <typename Return,
              typename NonRefReturn = typename std::decay<Return>::type>
    std::list<NonRefReturn> get(selector<Return>) const {
      return std::list<NonRefReturn>{NonRefReturn()};
    }
  };

  template <typename... T>
  struct list_data_generator {
  private:
    std::tuple<std::list<T>...> containers;

  public:
    list_data_generator(std::initializer_list<T>... lists):
      containers(lists...) {}

    list_data_generator(const list_data_generator&) = default;

    template <typename Return,
              typename NonRefReturn = typename std::decay<Return>::type,
              typename pos
              = typename details::position<NonRefReturn, T...>::type
              >
    std::list<NonRefReturn>& get(selector<Return>) {
      return std::get<pos::value>
        (containers);
    }

    template <typename Return,
              typename NonRefReturn = typename std::decay<Return>::type,
              typename pos
              = typename details::position<NonRefReturn, T...>::type>
    const std::list<NonRefReturn>& get(selector<Return>) const {
      return std::get<pos::value>
        (containers);
    }
  };
}

#endif