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(
    invoke(function, *std::begin(container))
  );

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

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

  return returnContainer;
}

template<
  template<typename, std::size_t> class ArrayType,
  typename T,
  std::size_t size,
  class UnaryFunction
> auto map_stl(
  const ArrayType<T, size>& container,
  UnaryFunction&& function
) {
  using U = decltype(
    invoke(function, *std::begin(container))
  );

  ArrayType<U, size> returnContainer;

  for(unsigned i = 0; i < size; ++i) {
    returnContainer[i] = invoke(function, container[i]);
  }

  return returnContainer;
}

template<
  template<typename, typename> class PairType,
  typename T,
  class UnaryFunction
> auto map_stl(
  const PairType<T, T>& pair,
  UnaryFunction&& function
) {
  using U = decltype(
    invoke(function, pair.first)
  );

  return PairType<U, U> {
    function(pair.first),
    function(pair.second)
  };
}

template<class Container, class UnaryFunction>
auto map(Container&& container, UnaryFunction&& function) {
  using U = decltype(
    invoke(function, *std::begin(container))
  );

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

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

  return returnContainer;
}

template<class Pairlike, typename Unary>
auto mapHomogeneousPairlike(Pairlike p, Unary&& f) {
  return std::make_pair(f(p.first), f(p.second));
}

template<class Container, class Callable>
void forEach(
  const Container& container,
  Callable&& callable
) {
  for(const auto& value : container) {
    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 = 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(!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(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)
  );
}

// C++17 nodiscard
template<class Container, class Predicate>
Container copy_if(const Container& container, Predicate&& predicate) {
  Container returnContainer;

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

  return returnContainer;
}

// C++17 nodiscard
template<class Container>
Container sorted(Container container) {
  sort(container);
  return container;
}

// C++17 nodiscard
template<class Container, typename Comparator>
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<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