transformed_rdd.h

#ifndef CPARK_TRANSFORMED_RDD_H
#define CPARK_TRANSFORMED_RDD_H
 
#include <vector>
 
#include "base_rdd.h"
#include "utils.h"
 
namespace cpark {
 
template <concepts::Rdd R, typename Func,
          typename T = std::invoke_result_t<Func, utils::RddElementType<R>>>
requires std::invocable<Func, utils::RddElementType<R>>&& std::convertible_to<
    std::invoke_result_t<Func, utils::RddElementType<R>>, T> class TransformedRdd
    : public BaseRdd<TransformedRdd<R, Func, T>> {
public:
  using Base = BaseRdd<TransformedRdd<R, Func, T>>;
  friend Base;
 
  constexpr TransformedRdd(const R& prev, Func func) : Base{prev, false} {
    static_assert(concepts::Rdd<TransformedRdd<R, Func, T>>,
                  "Instance of TransformedRdd does not satisfy Rdd concept.");
    // Create the transformed splits.
    for (const concepts::Split auto& prev_split : prev) {
      splits_.emplace_back(prev_split | std::views::transform(func), prev_split);
      splits_.back().addDependency(prev_split);
    }
  }
 
  // Explicitly define default copy constrictor and assignment operator,
  // because some linters or compilers can not define implicit copy constructors for this class,
  // though they are supposed to do so.
  // TODO: find out why.
  constexpr TransformedRdd(const TransformedRdd&) = default;
  TransformedRdd& operator=(const TransformedRdd&) = default;
 
private:
  constexpr auto beginImpl() const { return std::ranges::begin(splits_); }
 
  constexpr auto endImpl() const { return std::ranges::end(splits_); }
 
private:
  using TransformedViewype =
      decltype(std::declval<R>().front() | std::views::transform(std::declval<Func>()));
  // A vector holding the splits for this rdd.
  std::vector<ViewSplit<TransformedViewype>> splits_{};
};
 
template <typename Func>
class Transform {
public:
  explicit Transform(Func func) : func_{std::move(func)} {}
 
  template <concepts::Rdd R, typename T = utils::RddElementType<R>,
            typename U = std::invoke_result_t<Func, T>>
  requires std::invocable<Func, T>&& std::convertible_to<std::invoke_result_t<Func, T>, U> auto
  operator()(const R& r) const {
    return TransformedRdd(r, func_);
  }
 
private:
  Func func_;
};
 
template <typename Func, concepts::Rdd R>
auto operator|(const R& r, const Transform<Func>& transform) {
  return transform(r);
}
 
 
}  // namespace cpark
 
#endif  //CPARK_TRANSFORMED_RDD_H