Function Step

cpp/src/arrow/testing/generator.h:321–356

/// Note: overflow is not prevented standard unsigned integer overflow applies
template <typename T = uint32_t>
std::shared_ptr<ArrayGenerator> Step(T start = 0, T step = 1) {
  class StepGenerator : public ArrayGenerator {
   public:
    // Use [[maybe_unused]] to avoid a compiler warning in Clang versions before 15 that
    // incorrectly reports 'unused type alias'.
    using ArrowType [[maybe_unused]] = typename CTypeTraits<T>::ArrowType;
    static_assert(is_number_type<ArrowType>::value,
                  "Step generator only supports numeric types");

    StepGenerator(T start, T step) : start_(start), step_(step) {}

    Result<std::shared_ptr<Array>> Generate(int64_t num_rows) override {
      TypedBufferBuilder<T> builder;
      ARROW_RETURN_NOT_OK(builder.Reserve(num_rows));
      T val = start_;
      for (int64_t i = 0; i < num_rows; i++) {
        builder.UnsafeAppend(val);
        val += step_;
      }
      start_ = val;
      ARROW_ASSIGN_OR_RAISE(auto buf, builder.Finish());
      return MakeArray(ArrayData::Make(TypeTraits<ArrowType>::type_singleton(), num_rows,
                                       {NULLPTR, std::move(buf)}, /*null_count=*/0));
    }

    std::shared_ptr<DataType> type() const override {
      return TypeTraits<ArrowType>::type_singleton();
    }

   private:
    T start_;
    T step_;
  };

  return std::make_shared<StepGenerator>(start, step);
}

/// make a generator that returns a random value
ARROW_TESTING_EXPORT std::shared_ptr<ArrayGenerator> Random(