ArrayBuilder.h

Go to the documentation of this file.

// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE

#ifndef AWKWARD_ARRAYBUILDER_H_
#define AWKWARD_ARRAYBUILDER_H_

#include <complex>
#include <string>
#include <vector>

#include "awkward/common.h"
#include "awkward/util.h"
#include "awkward/builder/Builder.h"

namespace awkward {
  class Content;
  using ContentPtr    = std::shared_ptr<Content>;
  class ArrayBuilderOptions;
  class Builder;
  using BuilderPtr = std::shared_ptr<Builder>;

  class LIBAWKWARD_EXPORT_SYMBOL ArrayBuilder {
  public:
    ArrayBuilder(const ArrayBuilderOptions& options);

    const std::string
      to_buffers(BuffersContainer& container, int64_t& form_key_id) const;

    int64_t
      length() const;

    void
      clear();

    void
      null();

    void
      boolean(bool x);

    void
      integer(int64_t x);

    void
      real(double x);

    void
      complex(std::complex<double> x);

    void
      datetime(int64_t x, const std::string& unit);

    void
      timedelta(int64_t x, const std::string& unit);

    void
      bytestring(const char* x);

    void
      bytestring(const char* x, int64_t length);

    void
      bytestring(const std::string& x);

    void
      string(const char* x);

    void
      string(const char* x, int64_t length);

    void
      string(const std::string& x);

    void
      beginlist();

    void
      endlist();

    void
      begintuple(int64_t numfields);

    void
      index(int64_t index);

    void
      endtuple();

    void
      beginrecord();

    void
      beginrecord_fast(const char* name);

    void
      beginrecord_check(const char* name);

    void
      beginrecord_check(const std::string& name);

    void
      field_fast(const char* key);

    void
      field_check(const char* key);

    void
      field_check(const std::string& key);

    void
      endrecord();

    // @brief Root node of the Builder tree.
    const BuilderPtr builder() const { return builder_; }

    void builder_update(BuilderPtr builder) { builder_ = builder; }

    void
      maybeupdate(const BuilderPtr builder);

private:
    static const char* no_encoding;
    static const char* utf8_encoding;
    BuilderPtr builder_;
  };
}

extern "C" {
  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_length(void* arraybuilder,
                                int64_t* result);
  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_clear(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_null(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_boolean(void* arraybuilder,
                                 bool x);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_integer(void* arraybuilder,
                                 int64_t x);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_real(void* arraybuilder,
                              double x);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_complex(void* arraybuilder,
                                 double real,
                                 double imag);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_datetime(void* arraybuilder,
                                  int64_t x,
                                  const char* unit);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_timedelta(void* arraybuilder,
                                   int64_t x,
                                   const char* unit);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_bytestring(void* arraybuilder,
                                    const char* x);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_bytestring_length(void* arraybuilder,
                                           const char* x,
                                           int64_t length);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_string(void* arraybuilder,
                                const char* x);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_string_length(void* arraybuilder,
                                       const char* x,
                                       int64_t length);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginlist(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endlist(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_begintuple(void* arraybuilder,
                                    int64_t numfields);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_index(void* arraybuilder,
                               int64_t index);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endtuple(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord(void* arraybuilder);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord_fast(void* arraybuilder,
                                          const char* name);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord_check(void* arraybuilder,
                                           const char* name);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_field_fast(void* arraybuilder,
                                    const char* key);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_field_check(void* arraybuilder,
                                     const char* key);

  LIBAWKWARD_EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endrecord(void* arraybuilder);
}

#endif // AWKWARD_ARRAYBUILDER_H_