implementation.h

#ifndef SIMDJSON_IMPLEMENTATION_H
#define SIMDJSON_IMPLEMENTATION_H
 
#include "simdjson/common_defs.h"
#include "simdjson/internal/dom_parser_implementation.h"
#include "simdjson/internal/isadetection.h"
#include <string>
#include <atomic>
#include <vector>
 
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());
}
 
namespace dom {
  class document;
} // namespace dom
 
class implementation {
public:
 
  virtual const std::string &name() const { return _name; }
 
  virtual const std::string &description() const { return _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)
  {
  }
  virtual ~implementation()=default;
 
private:
  const std::string _name;
 
  const std::string _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;
};
 
template<typename T>
class atomic_ptr {
public:
  atomic_ptr(T *_ptr) : ptr{_ptr} {}
 
  operator const T*() const { return ptr.load(); }
  const T& operator*() const { return *ptr; }
  const T* operator->() const { return ptr.load(); }
 
  operator T*() { return ptr.load(); }
  T& operator*() { return *ptr; }
  T* operator->() { return ptr.load(); }
  atomic_ptr& operator=(T *_ptr) { ptr = _ptr; return *this; }
 
private:
  std::atomic<T*> ptr;
};
 
} // 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