utils/black_box_equal.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 BLACK_BOX_EQUAL_HH
# define BLACK_BOX_EQUAL_HH

# include <functional>
# include "../dataset/dataset.hh"
# include "../concept/concepts.hh"
# include "../wrappers/function_wrappers.hh"

namespace catsfoot {

  namespace details {
    template <typename T, typename Op>
    struct try_all_compare;

    template <typename T, typename Ret, typename... Args>
    struct try_all_compare<T, std::function<Ret(Args...)> > {
      template <typename Generator, typename... OtherArgs>
      static bool doit(Generator& g,
                       const selector<const T&>&,
                       const std::function<Ret(Args...)>& f,
                       const T& a, const T& b,
                       const std::tuple<OtherArgs, OtherArgs>&... args...) {
        return doit(g, f, a, b, args..., std::tuple<const T&, const T&>(a, b));
      }

      template <typename Generator, typename U, typename... OtherArgs>
      static bool doit(Generator& g,
                       const selector<U>&,
                       const std::function<Ret(Args...)>& f,
                       const T& a, const T& b,
                       const std::tuple<OtherArgs, OtherArgs>&... args...) {
        auto gen = g.get(selector<U>{});
        for (auto i = gen.begin();
             i != gen.end(); ++i) {
          if (!doit(g, f, a, b, args..., std::tuple<U, U>(*i, *i)))
            return false;
        }
        return true;
      }

      template <typename Generator, typename... OtherArgs>
      static bool doit(Generator& g,
                       const std::function<Ret(Args...)>& f,
                       const T& a, const T& b,
                       const std::tuple<OtherArgs, OtherArgs>&... args...) {
        typedef typename std::
          tuple_element<sizeof...(OtherArgs), std::tuple<Args...> >::type type;

        return doit(g, selector<type>(), f, a, b, args...);
      }

      template <typename Generator>
      static bool doit(Generator&,
                       const std::function<Ret(Args...)>& f,
                       const T&, const T&, const std::tuple<Args, Args>&...
                       args...) {
        return f(std::get<0>(args)...) ==
          f(std::get<1>(args)...);
      }

    };
  }

  namespace details {
    template <typename Generator, typename T, typename... Ops>
    struct compare;

    template <typename Generator, typename T>
    struct compare<Generator, T> {
      compare() = default;

      bool operator()(Generator&, const T&, const T&) const {
        return true;
      }
    };

    template <typename Generator, typename T, typename Op, typename... Ops>
    struct compare<Generator, T, Op, Ops...>:
      public compare<Generator, T, Ops...> {
    private:
      typedef compare<Generator, T, Ops...> super;
      Op op;
    public:
      compare(Op&& op,
              Ops&&... ops...):
        compare<Generator, T, Ops...>(std::move(ops)...),
        op(std::move(op))
      {}

      bool operator()(Generator &g, const T& a, const T& b) const {
        if (!this->super::operator()(g, a, b))
          return false;
        return details::try_all_compare<T, Op>::doit(g, op, a, b);
      }
    };

    template <typename Generator, typename T, typename... Ops>
    struct compare_top: public compare<Generator, T, Ops...> {
    private:
      Generator g;
    public:
      compare_top(const Generator& g,
                  Ops&&... ops...):
        compare<Generator, T, Ops...>(std::move(ops)...),
        g(g)
      {}

      compare_top(Generator&& g,
                  Ops&&... ops...):
        compare<Generator, T, Ops...>(std::move(ops)...),
        g(std::move(g))
      {}

      bool operator()(const T& a, const T& b) const {
        return this->compare<Generator, T, Ops...>::operator()
          (*const_cast<Generator*>(&g), a, b);
      }
    };

  }

  template <typename T>
  struct build_comparer {
    template <typename Generator, typename... Functions,
              typename G = typename std::decay<Generator>::type>
    details::compare_top<G, T, typename wrapped<Functions>::type...>
    operator()(Generator g, Functions&&... functions...) const {
      return details::compare_top<G, T, typename wrapped<Functions>::type...>
        (std::forward<Generator>(g),
         wrap(std::forward<Functions>(functions))...);
    }
  };
}

#endif