list_concept.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program 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 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __LIST_CONCEPT_HH
# define __LIST_CONCEPT_HH

# include "list.hh"

namespace aurelia {
  template <typename T>
  struct list_model;

  template <typename Model>
  struct list_concept: public Model {
    typedef typename Model::cons_t cons_t;
    typedef typename Model::head_t head_t;
    typedef typename Model::tail_t tail_t;
    enum: unsigned { size = (unsigned)Model::size };
#ifdef DOC_GEN
    head head(cons);
    tail tail(cons);
    cons cons(head, tail);
#else
    static_assert(((unsigned)list_model<tail_t>::model::size+1 == size)
                  || ((size == 0) &&
                      ((unsigned)list_model<tail_t>::model::size == 0)),
                  "Wrong size");
    static_assert(std::is_same<decltype(head(std::declval<cons_t>())),
                  head_t>::value,
                  "head(cons) does not return the right type");
    static_assert(std::is_same<decltype(tail(std::declval<cons_t>())),
                  tail_t>::value,
                  "tail(cons) does not return the right type");
    static_assert(std::is_same<decltype(cons(std::declval<head_t>(),
                                             std::declval<tail_t>())),
                  cons_t>::value,
                  "cons(head,tail) does not return the right type");

    typedef void check;
#endif
  };

  template <typename T>
  struct list_model {
    typedef void no_model;
  };

  template <typename H, typename T>
  struct list_model<list_cons<H, T> > {
    struct model {
      typedef list_cons<H, T> cons_t;
      typedef H head_t;
      typedef T tail_t;
      enum : unsigned { size = list_cons<H, T>::size };
    };
  };

  template <>
  struct list_model<list_nil> {
    struct model {
      typedef list_nil cons;
      typedef void head;
      typedef list_nil tail;
      enum : unsigned { size = list_nil::size };
    };
  };

  template <template <typename> class Predicate,
            typename T,
            typename M = typename aurelia::list_model<T>::model,
            bool = std::is_same<void, typename M::head_t>::value,
            bool = Predicate<typename M::head_t>::value>
  struct all_elements: public std::false_type {
  };

  template <template <typename> class Predicate,
            typename T, typename M, bool whatever>
  struct all_elements<Predicate, T, M, true, whatever>
    : public all_elements<Predicate, typename M::tail_t> {
  };

  template <template <typename> class Predicate,
            typename T, typename M>
  struct all_elements<Predicate, T, M, false, true>: public std::true_type {
  };

}

#endif