ArrayBuilder.h

Go to the documentation of this file.

// BSD 3-Clause License; see https://github.com/scikit-hep/awkward/blob/main/LICENSE
 
#ifndef AWKWARD_ARRAYBUILDER_H_
#define AWKWARD_ARRAYBUILDER_H_
 
#include <complex>
#include <string>
#include <vector>
 
#include "awkward/common.h"
#include "awkward/builder/Builder.h"
#include "awkward/BuilderOptions.h"
 
namespace awkward {
  class Builder;
  using BuilderPtr = std::shared_ptr<Builder>;
 
  class EXPORT_SYMBOL ArrayBuilder {
  public:
    ArrayBuilder(const BuilderOptions& 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" {
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_length(void* arraybuilder,
                                int64_t* result);
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_clear(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_null(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_boolean(void* arraybuilder,
                                 bool x);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_integer(void* arraybuilder,
                                 int64_t x);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_real(void* arraybuilder,
                              double x);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_complex(void* arraybuilder,
                                 double real,
                                 double imag);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_datetime(void* arraybuilder,
                                  int64_t x,
                                  const char* unit);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_timedelta(void* arraybuilder,
                                   int64_t x,
                                   const char* unit);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_bytestring(void* arraybuilder,
                                    const char* x);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_bytestring_length(void* arraybuilder,
                                           const char* x,
                                           int64_t length);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_string(void* arraybuilder,
                                const char* x);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_string_length(void* arraybuilder,
                                       const char* x,
                                       int64_t length);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginlist(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endlist(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_begintuple(void* arraybuilder,
                                    int64_t numfields);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_index(void* arraybuilder,
                               int64_t index);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endtuple(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord(void* arraybuilder);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord_fast(void* arraybuilder,
                                          const char* name);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_beginrecord_check(void* arraybuilder,
                                           const char* name);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_field_fast(void* arraybuilder,
                                    const char* key);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_field_check(void* arraybuilder,
                                     const char* key);
 
  EXPORT_SYMBOL uint8_t
    awkward_ArrayBuilder_endrecord(void* arraybuilder);
}
 
#endif // AWKWARD_ARRAYBUILDER_H_