concept/product.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 PRODUCT_HH
# define PRODUCT_HH

# include "concept_tools.hh"
# include "../axioms/axioms.hh"
# include "../utils/call_tuple.hh"
# include "../utils/call_with.hh"
# include "../wrappers/function_wrappers.hh"
# include "../type_traits/is_callable.hh"
# include "congruence.hh"

namespace catsfoot {

  template <typename Type,
            typename Constructor,
            typename... Projections>
  struct product: public concept {
    typedef concept_list<
      is_callable<Projections(const Type&)>...,
      is_callable
      <Constructor(typename is_callable<Projections(const Type&)>
                   ::result_type...)>,
      std::is_convertible
      <typename is_callable
       <Constructor(typename is_callable
                    <Projections(const Type&)>::result_type...)>::result_type,
       Type>,
      equivalence_eq<Type>,
      equivalence_eq
      <typename is_callable<Projections(const Type&)>::result_type>...
      > requirements;

    static void projections(const std::tuple
                            <typename is_callable<Projections(const Type&)>
                             ::result_type...>& comps,
                            const std::tuple<Projections...>& p,
                            const Constructor& constr) {
      axiom_assert(call_tuple(p, call_with(constr, comps)) == comps);
    }

    static void universality(const Type& t,
                             const std::tuple<Projections...>& p,
                             const Constructor& constr) {
      axiom_assert(call_with(constr, call_tuple(p, t)) == t);
    }

    AXIOMS(projections, universality);
  };

  template <typename Type,
            typename... Projections>
  struct simple_product: public concept {
    typedef concept_list<
      is_constructible
      <Type(typename is_callable<Projections(const Type&)>::result_type...)>,
      product<Type, constructor_wrap<Type>,
              Projections...>
      > requirements;
  };

  template <typename Type, typename... Projections>
  struct verified<product
                  <Type,
                   constructor_wrap
                   <Type>, Projections...> >:
    public verified<simple_product<Type, Projections...> > {};

}

#endif