LayoutBuilder.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_LayoutBuilder_H_
#define AWKWARD_LayoutBuilder_H_

#include "awkward/common.h"
#include "awkward/util.h"
#include "awkward/forth/ForthMachine.h"
#include "awkward/layoutbuilder/FormBuilder.h"

#include <complex>

namespace awkward {
  class ArrayBuilderOptions;

  using ForthOutputBufferMap = std::map<std::string, std::shared_ptr<ForthOutputBuffer>>;

  const std::string
    index_form_to_name(const std::string& form_index);

  const std::string
    index_form_to_vm_format(const std::string& form_index);

  enum class state : std::int32_t {
    int64 = 0,
    float64 = 1,
    begin_list = 2,
    end_list = 3,
    boolean = 4,
    int8 = 5,
    int16 = 6,
    int32 = 7,
    uint8 = 8,
    uint16 = 9,
    uint32 = 10,
    uint64 = 11,
    float16 = 12,
    float32 = 13,
    float128 = 14,
    complex64 = 15,
    complex128 = 16,
    complex256 = 17,
    null = 18,
    index = 19,
    tag = 20,
    datetime64 = 21,
    timedelta64 = 22
  };
  using utype = std::underlying_type<state>::type;

  const std::string
    primitive_to_state(const std::string& name);

  const std::string
    primitive_to_vm_format(const std::string& name);

  template <typename T, typename I>
  class LIBAWKWARD_EXPORT_SYMBOL LayoutBuilder {
  public:
    LayoutBuilder(const std::string& json_form,
                  const ArrayBuilderOptions& options,
                  bool vm_init = true);

    void
      connect(const std::shared_ptr<ForthMachineOf<T, I>>& vm);

    void
      debug_step() const;

    const std::string
      vm_source() const;

    const std::shared_ptr<ForthMachineOf<T, I>>
      vm() const;

    int64_t
      length() const;

    void
      pre_snapshot() const;

    void
      null();

    void
      boolean(bool x);

    void
      int64(int64_t x);

    void
      float64(double x);

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

    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
      begin_list();

    void
      add_begin_list();

    void
      end_list();

    void
      add_end_list();

    void
      tag(int8_t tag);

    void
      index(int64_t x);

    template <typename D>
    bool
      find_index_of(D x, const std::string& vm_output_data) {
        auto const& outputs = vm_.get()->outputs();
        auto search = outputs.find(vm_output_data);
        if (search != outputs.end()) {
          auto data = std::static_pointer_cast<D>(search->second.get()->ptr());
          auto size = search->second.get()->len();
          for (int64_t i = 0; i < size; i++) {
            if (data.get()[i] == x) {
              index(i);
              return true;
            }
          }
        }
        return false;
      }

    void
      add_bool(bool x);

    void
      add_int64(int64_t x);

    void
      add_double(double x);

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

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

    static int64_t
      next_id();

    static int64_t
      next_error_id();

    void
      resume() const;

    // @brief Root node of the FormBuilder tree.
    const FormBuilderPtr<T, I> builder() const { return builder_; }

  protected:
    static int64_t
      next_node_id;

    static int64_t
      error_id;

  private:
    FormBuilderPtr<T, I>
      form_builder_from_json(const std::string& json_form);

    template <typename JSON>
    FormBuilderPtr<T, I>
      from_json(const JSON& json_doc);

    void
      initialise_builder(const std::string& json_form);

    void
      initialise();

    template <typename D>
    void
      set_data(D x);

    int64_t initial_;

    int64_t length_;

    FormBuilderPtr<T, I> builder_;

    std::shared_ptr<ForthMachineOf<T, I>> vm_;

    std::map<std::string, std::shared_ptr<ForthInputBuffer>> vm_inputs_map_;

    std::string vm_input_data_;

    std::string vm_source_;

    std::set<util::ForthError> ignore_;

    ForthOutputBufferMap vm_outputs_map_;

  };

  using LayoutBuilder32 = LayoutBuilder<int32_t, int32_t>;
  using LayoutBuilder64 = LayoutBuilder<int64_t, int32_t>;

}

#endif // AWKWARD_LayoutBuilder_H_