map_index.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 __MAP_INDEX_HH
# define __MAP_INDEX_HH

# include "../strategies.hh"

namespace aurelia {

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

    output operator()(strat, input, int);
#else
  private:
    static_assert(std::is_same<decltype(std::declval<strat>()
                                        (std::declval<input>(),
                                         0)),
                  output>::value,
                  "operator() does not return the right type");
#endif
  };

  template <typename S, typename I>
  struct default_index_strategy_model {
    typedef S strat;
    typedef I input;
    typedef decltype(std::declval<strat>()(std::declval<input>(), 0)) output;
  };

  template <typename S, typename I>
  struct index_strategy_model {
    typedef default_index_strategy_model<S, I> model;
  };

  template <typename S>
  struct map_index_strategy {
    S s;
    map_index_strategy(const S& s): s(s) {
    }

    template <typename Pool>
    untyped_term<Pool> operator()(const untyped_term<Pool>& t, int index = 0) const {
      typedef index_strategy_concept<typename
                                     index_strategy_model<S, untyped_term<Pool> >
                                     ::model>
      require;

      typedef untyped_term<Pool> T;
      typedef untyped_constructor<Pool> C;

      try {
        if (t.constructor() != C::AS_EMPTY_LIST)
          throw failure();
        return t;
      } catch (failure) {
        if (t.constructor() == C::AS_LIST) {
          T a = s(t[0], index);
          T b = (*this)(t[1], index+1);
          return T(C::AS_LIST, (a, b));
        } else
          throw failure();
      }
    }
  };

  template <typename S>
  map_index_strategy<S> map_index(const S& s) {
    return map_index_strategy<S>(s);
  }

}

#endif