padded_string.h

#ifndef SIMDJSON_PADDED_STRING_H
#define SIMDJSON_PADDED_STRING_H
 
#include "simdjson/base.h"
#include "simdjson/error.h"
 
#include "simdjson/error-inl.h"
 
#include <cstring>
#include <memory>
#include <string>
#include <ostream>
 
namespace simdjson {
 
class padded_string_view;
 
struct padded_string final {
 
  explicit inline padded_string() noexcept;
  explicit inline padded_string(size_t length) noexcept;
  explicit inline padded_string(const char *data, size_t length) noexcept;
#ifdef __cpp_char8_t
  explicit inline padded_string(const char8_t *data, size_t length) noexcept;
#endif
  inline padded_string(const std::string & str_ ) noexcept;
  inline padded_string(std::string_view sv_) noexcept;
  inline padded_string(padded_string &&o) noexcept;
  inline padded_string &operator=(padded_string &&o) noexcept;
  inline void swap(padded_string &o) noexcept;
  ~padded_string() noexcept;
 
  size_t size() const noexcept;
 
  size_t length() const noexcept;
 
  const char *data() const noexcept;
  const uint8_t *u8data() const noexcept { return static_cast<const uint8_t*>(static_cast<const void*>(data_ptr));}
 
  char *data() noexcept;
 
  inline bool append(const char *data, size_t length) noexcept;
 
  operator std::string_view() const;
 
  operator padded_string_view() const noexcept;
 
  inline static simdjson_result<padded_string> load(std::string_view path) noexcept;
 
    #if defined(_WIN32) && SIMDJSON_CPLUSPLUS17
    inline static simdjson_result<padded_string> load(std::wstring_view path) noexcept;
  #endif
 
private:
  friend class padded_string_builder;
  padded_string &operator=(const padded_string &o) = delete;
  padded_string(const padded_string &o) = delete;
 
  size_t viable_size{0};
  char *data_ptr{nullptr};
 
}; // padded_string
 
class padded_string_builder {
public:
  inline padded_string_builder() noexcept;
 
  inline padded_string_builder(size_t capacity) noexcept;
 
  inline padded_string_builder(padded_string_builder &&o) noexcept;
 
  inline padded_string_builder &operator=(padded_string_builder &&o) noexcept;
 
  padded_string_builder(const padded_string_builder &) = delete;
 
  padded_string_builder &operator=(const padded_string_builder &) = delete;
 
  inline ~padded_string_builder() noexcept;
 
  inline bool append(const char *newdata, size_t length) noexcept;
 
  inline bool append(std::string_view sv) noexcept;
 
  inline size_t length() const noexcept;
 
  inline padded_string build() const noexcept;
 
  inline padded_string convert() noexcept;
private:
  size_t size{0};
  size_t capacity{0};
  char *data{nullptr};
 
  inline bool reserve(size_t additional) noexcept;
};
 
inline std::ostream& operator<<(std::ostream& out, const padded_string& s) { return out << s.data(); }
 
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string> &s) noexcept(false) { return out << s.value(); }
#endif
 
#if SIMDJSON_HAS_PADDED_MEMORY_MAP
class padded_memory_map {
public:
  simdjson_inline padded_memory_map(const char *filename) noexcept;
  simdjson_inline ~padded_memory_map() noexcept;
 
  // lifetime of the view is tied to the memory map, so we can return a view
  // directly
  simdjson_inline simdjson::padded_string_view view() const noexcept simdjson_lifetime_bound;
  simdjson_inline bool is_valid() const noexcept;
 
private:
  padded_memory_map() = delete;
  padded_memory_map(const padded_memory_map &) = delete;
  padded_memory_map &operator=(const padded_memory_map &) = delete;
  const char *data{nullptr};
  size_t size{0};
#ifdef _WIN32
  // When the file ends near an allocation-granularity boundary, we use the
  // placeholder API to append zero-filled padding pages. This pointer tracks
  // that region so the destructor can release it with VirtualFree.
  void *padding_view_{nullptr};
#endif
};
#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP
 
 
 
} // namespace simdjson
 
// This is deliberately outside of simdjson so that people get it without having to use the namespace
inline simdjson::padded_string operator ""_padded(const char *str, size_t len);
#ifdef __cpp_char8_t
inline simdjson::padded_string operator ""_padded(const char8_t *str, size_t len);
#endif
 
namespace simdjson {
namespace internal {
 
// The allocate_padded_buffer function is a low-level function to allocate memory
// with padding so we can read past the "length" bytes safely. It is used by
// the padded_string class automatically. It returns nullptr in case
// of error: the caller should check for a null pointer.
// The length parameter is the maximum size in bytes of the string.
// The caller is responsible to free the memory (e.g., delete[] (...)).
inline char *allocate_padded_buffer(size_t length) noexcept;
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_PADDED_STRING_H