dom_parser_implementation.h

#ifndef SIMDJSON_INTERNAL_DOM_PARSER_IMPLEMENTATION_H
#define SIMDJSON_INTERNAL_DOM_PARSER_IMPLEMENTATION_H
 
#include "simdjson/base.h"
#include "simdjson/error.h"
#include <memory>
 
namespace simdjson {
 
namespace dom {
class document;
} // namespace dom
 
enum class stage1_mode {
  regular,
  streaming_partial, streaming_final,
  json_sequence_partial, json_sequence_final,
  comma_delimited_partial, comma_delimited_final
};
 
inline bool is_streaming(stage1_mode mode) {
  // performance note: it is probably faster to check that mode is different
  // from regular than checking that it is either streaming_partial or streaming_final.
  return (mode != stage1_mode::regular);
  // return (mode == stage1_mode::streaming_partial || mode == stage1_mode::streaming_final);
}
 
namespace internal {
 
 
class dom_parser_implementation {
public:
 
  simdjson_warn_unused virtual error_code parse(const uint8_t *buf, size_t len, dom::document &doc) noexcept = 0;
 
  simdjson_warn_unused virtual error_code stage1(const uint8_t *buf, size_t len, stage1_mode streaming) noexcept = 0;
 
  simdjson_warn_unused virtual error_code stage2(dom::document &doc) noexcept = 0;
 
  simdjson_warn_unused virtual error_code stage2_next(dom::document &doc) noexcept = 0;
 
  simdjson_warn_unused virtual uint8_t *parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept = 0;
 
  simdjson_warn_unused virtual uint8_t *parse_wobbly_string(const uint8_t *src, uint8_t *dst) const noexcept = 0;
 
  virtual error_code set_capacity(size_t capacity) noexcept = 0;
 
  virtual error_code set_max_depth(size_t max_depth) noexcept = 0;
 
  virtual ~dom_parser_implementation() = default;
 
  uint32_t n_structural_indexes{0};
  std::unique_ptr<uint32_t[]> structural_indexes{};
  uint32_t next_structural_index{0};
 
  simdjson_pure simdjson_inline size_t capacity() const noexcept;
 
  simdjson_pure simdjson_inline size_t max_depth() const noexcept;
 
  simdjson_warn_unused inline error_code allocate(size_t capacity, size_t max_depth) noexcept;
 
 
protected:
  size_t _capacity{0};
 
  size_t _max_depth{0};
 
public:
  bool _number_as_string{false};
 
  bool _unpadded{false};
 
protected:
 
  // Declaring these so that subclasses can use them to implement their constructors.
  simdjson_inline dom_parser_implementation() noexcept;
  simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;
  simdjson_inline dom_parser_implementation &operator=(dom_parser_implementation &&other) noexcept;
 
  simdjson_inline dom_parser_implementation(const dom_parser_implementation &) noexcept = delete;
  simdjson_inline dom_parser_implementation &operator=(const dom_parser_implementation &other) noexcept = delete;
}; // class dom_parser_implementation
 
simdjson_inline dom_parser_implementation::dom_parser_implementation() noexcept = default;
simdjson_inline dom_parser_implementation::dom_parser_implementation(dom_parser_implementation &&other) noexcept = default;
simdjson_inline dom_parser_implementation &dom_parser_implementation::operator=(dom_parser_implementation &&other) noexcept = default;
 
simdjson_pure simdjson_inline size_t dom_parser_implementation::capacity() const noexcept {
  return _capacity;
}
 
simdjson_pure simdjson_inline size_t dom_parser_implementation::max_depth() const noexcept {
  return _max_depth;
}
 
simdjson_warn_unused
inline error_code dom_parser_implementation::allocate(size_t capacity, size_t max_depth) noexcept {
  if (this->max_depth() != max_depth) {
    error_code err = set_max_depth(max_depth);
    if (err) { return err; }
  }
  if (_capacity != capacity) {
    error_code err = set_capacity(capacity);
    if (err) { return err; }
  }
  return SUCCESS;
}
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_INTERNAL_DOM_PARSER_IMPLEMENTATION_H