strategies.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 __STRATEGIES_HH
# define __STRATEGIES_HH

# include <type_traits/is_callable_with.hh>
# include <functional>

namespace aurelia {

  template <typename Model>
  struct strategy_concept: public Model {
  public:
    typedef typename Model::strat strat;
    typedef typename Model::input input;
    typedef typename Model::output output;
#ifdef DOC_GEN

    output operator()(strat, input);
#else
    typedef void check;
  private:
    static_assert(std::is_same<decltype(std::declval<strat>()
                                        (std::declval<input>())),
                  output>::value,
                  "operator() does not return the right type");
#endif
  };
  template <typename S, typename I>
  struct default_strategy_model {
    typedef S strat;
    typedef I input;
    typedef decltype(std::declval<const strat>()(std::declval<input>())) output;
  };

  template <typename S, typename I,
            bool = type_traits::is_callable_with<const S, I>::value>
  struct strategy_model;

  template <typename S, typename I>
  struct strategy_model<S, I, false> {
    typedef void no_model;
  };

  template <typename S, typename I>
  struct strategy_model<S, I, true> {
    typedef default_strategy_model<S, I> model;
  };

  template <typename R, typename ArgType>
  struct strategy_model<std::function<R(ArgType)>, ArgType, false> {
    struct model {
      typedef typename
      strategy_concept<strategy_model<std::function<R(ArgType)>,
                                      ArgType> >::model require;
      typedef std::function<R(ArgType)> strat;
      typedef ArgType input;
      typedef R output;
    };
  };
}

# include "generic/id.hh"
# include "generic/fail.hh"
# include "traversals/all.hh"
# include "generic/choice.hh"
# include "generic/seq.hh"
# include "patterns/match.hh"
# include "patterns/build.hh"
# include "generic/not.hh"
# include "generic/where.hh"

#endif