Functional.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_FUNCTIONAL_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_FUNCTIONAL_H

#include "Molassembler/Temple/Invoke.h"
#include "Molassembler/Temple/AddToContainer.h"

#include <numeric>

namespace Scine {
namespace Molassembler {
namespace Temple {

template<
  class Container,
  std::enable_if_t<Traits::hasSize<Container>::value, int> = 0
> auto size(const Container& container) {
  return container.size();
}

template<
  class Container,
  std::enable_if_t<!Traits::hasSize<Container>::value, int> = 0
> auto size(const Container& container) {
  return std::distance(
    std::begin(container),
    std::end(container)
  );
}

template<
  class UnaryFunction,
  typename T,
  template<typename, typename...> class Container,
  template<typename> class ... Dependents
> auto map_stl(
  const Container<T, Dependents<T>...>& container,
  UnaryFunction&& function
) {
  using U = decltype(
    Temple::invoke(function, *std::begin(container))
  );

  Container<U, Dependents<U>...> returnContainer;
  reserveIfPossible(returnContainer, container);

  for(const auto& element : container) {
    addToContainer(
      returnContainer,
      Temple::invoke(function, element)
    );
  }

  return returnContainer;
}

namespace Detail {

template<
  template<typename ...> class Tuplelike,
  typename Tuple,
  typename Unary,
  std::size_t ... Inds
>
constexpr auto mapTupleHelper(Tuple&& tup, Unary&& f, std::index_sequence<Inds ...> /* inds */) {
  using ReturnType = Tuplelike<
    decltype(
      Temple::invoke(f, std::declval<std::tuple_element_t<Inds, Tuple>>())
    )
  ...>;
  return ReturnType(Temple::invoke(f, std::get<Inds>(tup))...);
}

} // namespace Detail

template<
  template<typename ...> class Tuplelike,
  typename Unary,
  typename ... Ts,
  std::enable_if_t<!Traits::isPairlike<Tuplelike<Ts...>>::value && Traits::isTuplelike<Tuplelike<Ts...>>::value>* = nullptr
> constexpr auto map(Tuplelike<Ts...>&& tup, Unary&& f) {
  return Detail::mapTupleHelper<Tuplelike>(
    std::forward<Tuplelike<Ts...>>(tup),
    std::forward<Unary>(f),
    std::make_index_sequence<std::tuple_size<Tuplelike<Ts...>>::value> {}
  );
}

// Catch pair-like classes that can't provide an overload for tuple_size
template<
  typename Pairlike,
  typename Unary,
  std::enable_if_t<Traits::isPairlike<Pairlike>::value && !Traits::isTuplelike<Pairlike>::value>* = nullptr
> constexpr auto map(Pairlike&& pair, Unary&& f) {
  return std::make_pair(
    Temple::invoke(f, pair.first),
    Temple::invoke(f, pair.second)
  );
}

template<class Container, class UnaryFunction, std::enable_if_t<!Traits::isPairlike<Container>::value && !Traits::isTuplelike<Container>::value>* = nullptr>
auto map(Container&& container, UnaryFunction&& function) {
  using U = decltype(Temple::invoke(function, *std::begin(container)));

  std::vector<U> returnContainer;
  reserveIfPossible(returnContainer, container);

  for(auto&& value : container) {
    returnContainer.push_back(Temple::invoke(function, std::move(value)));
  }

  return returnContainer;
}

template<class Container, class Callable>
void forEach(const Container& container, Callable&& callable) {
  for(const auto& value : container) {
    Temple::invoke(callable, value);
  }
}

template<
  class Container,
  typename ComparisonFunction,
  typename MappingFunction
>
typename Container::const_iterator select(
  const Container& container,
  ComparisonFunction&& comparator,
  MappingFunction&& mapFunction
) {
  auto selection = std::begin(container);
  auto selectionValue = mapFunction(*selection);

  auto iter = std::begin(container);

  while(iter != std::end(container)) {
    auto currentValue = mapFunction(*iter);

    // Replace if 'better' according to the comparator
    if(comparator(currentValue, selectionValue)) {
      selection = iter;
      selectionValue = currentValue;
    }

    ++iter;
  }

  return selection;
}

template<
  class Container,
  typename T,
  class BinaryFunction
> T accumulate(
  const Container& container,
  T init,
  BinaryFunction&& reductionFunction
) {
  for(const auto& value: container) {
    // Call variadic invoke (no tuple unpacking!)
    init = Temple::invoke(reductionFunction, std::move(init), value);
  }

  return init;
}

template<class Container, class UnaryPredicate = Functor::Identity>
bool all_of(const Container& container, UnaryPredicate&& predicate = UnaryPredicate {}) {
  for(const auto& element : container) {
    if(!Temple::invoke(predicate, element)) {
      return false;
    }
  }

  return true;
}

template<class Container, class UnaryPredicate = Functor::Identity>
bool any_of(const Container& container, UnaryPredicate&& predicate = UnaryPredicate {}) {
  for(const auto& element : container) {
    if(Temple::invoke(predicate, element)) {
      return true;
    }
  }

  return false;
}

template<class Container>
void sort(Container& container) {
  std::sort(
    std::begin(container),
    std::end(container)
  );
}

template<class Container, typename Comparator>
void sort(Container& container, Comparator&& comparator) {
  std::sort(
    std::begin(container),
    std::end(container),
    std::forward<Comparator>(comparator)
  );
}

template<class Container>
void reverse(Container& container) {
  std::reverse(
    std::begin(container),
    std::end(container)
  );
}

template<class Container, typename T>
void remove(
  Container& container,
  const T& value
) {
  container.erase(
    std::remove(
      std::begin(container),
      std::end(container),
      value
    ),
    std::end(container)
  );
}

template<class Container, class UnaryFunction>
void remove_if(
  Container& container,
  UnaryFunction&& predicate
) {
  container.erase(
    std::remove_if(
      std::begin(container),
      std::end(container),
      std::forward<UnaryFunction>(predicate)
    ),
    std::end(container)
  );
}

template<class Container, class Predicate>
[[nodiscard]] Container copy_if(const Container& container, Predicate&& predicate) {
  Container returnContainer;

  for(const auto& value : container) {
    if(Temple::invoke(predicate, value)) {
      addToContainer(returnContainer, value);
    }
  }

  return returnContainer;
}

template<class Container>
[[nodiscard]] Container sorted(Container container) {
  sort(container);
  return container;
}

template<class Container, typename Comparator>
[[nodiscard]] Container sorted(Container container, Comparator&& comparator) {
  sort(container, std::forward<Comparator>(comparator));
  return container;
}

template<class Container, typename T>
auto find(const Container& container, const T& needle) {
  return std::find(
    std::begin(container),
    std::end(container),
    needle
  );
}

template<class Container, typename UnaryPredicate>
auto find_if(const Container& container, UnaryPredicate&& predicate) {
  return std::find_if(
    std::begin(container),
    std::end(container),
    std::forward<UnaryPredicate>(predicate)
  );
}

template<class Container, typename T>
std::size_t index(const Container& container, const T& needle) {
  const auto iter = find(container, needle);
  if(iter == std::end(container)) {
    throw std::out_of_range("Needle not in the haystack");
  }
  return iter - std::begin(container);
}

template<class Container, typename UnaryPredicate>
std::size_t index_if(const Container& container, UnaryPredicate&& predicate) {
  const auto iter = find_if(container, predicate);
  if(iter == std::end(container)) {
    throw std::out_of_range("Needle not in the haystack");
  }
  return iter - std::begin(container);
}

template<typename T>
std::vector<T> iota(unsigned upperBound) {
  std::vector<T> values(upperBound);

  std::iota(
    std::begin(values),
    std::end(values),
    T(0)
  );

  return values;
}

template<class Container>
auto makeContainsPredicate(const Container& container) {
  using T = Traits::getValueType<Container>;

  return [&container](const T& element) -> bool {
    return std::find(
      std::begin(container),
      std::end(container),
      element
    ) != std::end(container);
  };
}

namespace Functor {

template<typename Transformation>
struct Map {
  Map(Transformation&& f) : t(f) {}

  template<typename Container>
  auto operator() (const Container& c) {
    return Temple::map(c, t);
  }

  Transformation t;
};

template<typename Transformation>
auto map(Transformation&& t) {
  return Map<Transformation>(std::forward<Transformation>(t));
}

} // namespace Functor

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

#endif