Functor.h

Go to the documentation of this file.

#ifndef INCLUDE_TEMPLE_FUNCTOR_H
#define INCLUDE_TEMPLE_FUNCTOR_H

#include <algorithm>
#include <stdexcept>
#include "Molassembler/Temple/Binding.h"

namespace Scine {
namespace Molassembler {
namespace Temple {

namespace Functor {

struct Identity {
  template<typename U>
  constexpr auto operator()(U&& v) const noexcept {
    return std::forward<U>(v);
  }
};

template<class Container>
struct At : public Binding<Container> {
  using ContainerBinding = Binding<Container>;
  // Bring constructor into scope
  using ContainerBinding::ContainerBinding;

  template<typename T>
  auto operator() (const T& index) const {
    return ContainerBinding::value.at(index);
  }
};

template<class Container>
auto at(Container&& container) {
  return At<Container&&> {std::forward<Container>(container)};
}

template<class Container>
struct IndexIn : public Binding<Container> {
  using ContainerBinding = Binding<Container>;
  // Bring constructor into scope
  using ContainerBinding::ContainerBinding;

  template<typename T>
  auto operator() (const T& item) const {
    auto findIter = std::find(
      std::begin(ContainerBinding::value),
      std::end(ContainerBinding::value),
      item
    );

    if(findIter == std::end(ContainerBinding::value)) {
      throw std::out_of_range("Item not found in container");
    }

    return findIter - std::begin(ContainerBinding::value);
  }
};

template<class Container>
auto indexIn(Container&& container) {
  return IndexIn<Container&&> {std::forward<Container>(container)};
}

template<unsigned i>
struct Get {
  template<typename T>
  constexpr auto operator() (const T& t) const {
    return std::get<i>(t);
  }
};

template<unsigned i>
constexpr auto get() { return Get<i> {}; }

constexpr Get<0> first;
constexpr Get<1> second;

// TODO this doesn't curry, it chains
template<typename UnaryF, typename UnaryG>
struct Currier {
  Currier(UnaryF&& outer, UnaryG&& inner) : f(outer), g(inner) {}

  template<typename T>
  auto operator() (T&& t) -> decltype(auto) {
    return f(g(t));
  }

  UnaryF f;
  UnaryG g;
};

template<typename UnaryF, typename UnaryG>
auto curry(UnaryF&& outer, UnaryG&& inner) {
  return Currier<UnaryF, UnaryG>(std::forward<UnaryF>(outer), std::forward<UnaryG>(inner));
}

} // namespace Functor
} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif