choice.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 __CHOICE_HH
# define __CHOICE_HH

# include "../strategies.hh"
# include <type_traits>

namespace aurelia {

  template <typename T>
  T common_convertible(T, T);

  template <typename T,
            typename U,
            typename =
            typename std::enable_if<std::is_convertible<U, T>::value>::type>
  T common_convertible(T, U);

  template <typename T,
            typename U,
            typename =
            typename std::enable_if<std::is_convertible<T, U>::value>::type>
  U common_convertible(T, U);

  template <typename Strat1, typename Strat2>
  struct choice_strategy;

  template <typename Strat1, typename Strat2, typename T>
  struct strategy_model<choice_strategy<Strat1, Strat2>, T, false> {
    struct model {
      typedef typename strategy_model<Strat1, T>::model model1;
      typedef typename strategy_model<Strat2, T>::model model2;

      typedef typename strategy_concept<model1>::check require1;
      typedef typename strategy_concept<model2>::check require2;

      typedef choice_strategy<Strat1, Strat2> strat;
      typedef T input;
      typedef
      decltype(common_convertible(std::declval<typename model1::output>(),
                                  std::declval<typename model2::output>()))
      output;
    };
  };

  template <typename Strat1, typename Strat2>
  struct choice_strategy {
  private:
    Strat1 s1;
    Strat2 s2;
  public:
    choice_strategy(const Strat1& s1, const Strat2& s2): s1(s1), s2(s2) {
    }

    template <typename T>
    typename strategy_model<choice_strategy, T>::model::output
    operator()(const T& term) const {
      try {
        return s1(term);
      }
      catch (failure) {
        return s2(term);
      }
    }
  };

  template <typename Strat1, typename Strat2>
  choice_strategy<Strat1, Strat2> operator+(const Strat1& s1, const Strat2& s2) {
    return choice_strategy<Strat1, Strat2>(s1, s2);
  }
}

#endif