implementation.h

#ifndef SIMDJSON_IMPLEMENTATION_H
#define SIMDJSON_IMPLEMENTATION_H
 
#include "simdjson/internal/atomic_ptr.h"
#include "simdjson/internal/dom_parser_implementation.h"
 
#include <memory>
 
namespace simdjson {
 
simdjson_warn_unused bool validate_utf8(const char * buf, size_t len) noexcept;
simdjson_inline simdjson_warn_unused bool validate_utf8(const std::string_view sv) noexcept {
  return validate_utf8(sv.data(), sv.size());
}
 
simdjson_inline simdjson_warn_unused bool validate_utf8(const std::string& s) noexcept {
  return validate_utf8(s.data(), s.size());
}
 
class implementation {
public:
 
  virtual std::string name() const { return std::string(_name); }
 
  virtual std::string description() const { return std::string(_description); }
 
  bool supported_by_runtime_system() const;
 
  virtual uint32_t required_instruction_sets() const { return _required_instruction_sets; }
 
  virtual error_code create_dom_parser_implementation(
    size_t capacity,
    size_t max_depth,
    std::unique_ptr<internal::dom_parser_implementation> &dst
  ) const noexcept = 0;
 
  simdjson_warn_unused virtual error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept = 0;
 
 
  simdjson_warn_unused virtual bool validate_utf8(const char *buf, size_t len) const noexcept = 0;
 
protected:
  simdjson_inline implementation(
    std::string_view name,
    std::string_view description,
    uint32_t required_instruction_sets
  ) :
    _name(name),
    _description(description),
    _required_instruction_sets(required_instruction_sets)
  {
  }
protected:
  ~implementation() = default;
 
private:
  std::string_view _name;
 
  std::string_view _description;
 
  const uint32_t _required_instruction_sets;
};
 
namespace internal {
 
class available_implementation_list {
public:
  simdjson_inline available_implementation_list() {}
  size_t size() const noexcept;
  const implementation * const *begin() const noexcept;
  const implementation * const *end() const noexcept;
 
  const implementation * operator[](const std::string_view &name) const noexcept {
    for (const implementation * impl : *this) {
      if (impl->name() == name) { return impl; }
    }
    return nullptr;
  }
 
  const implementation *detect_best_supported() const noexcept;
};
 
} // namespace internal
 
extern SIMDJSON_DLLIMPORTEXPORT const internal::available_implementation_list& get_available_implementations();
 
extern SIMDJSON_DLLIMPORTEXPORT internal::atomic_ptr<const implementation>& get_active_implementation();
 
} // namespace simdjson
 
#endif // SIMDJSON_IMPLEMENTATION_H