struct_pack_doc.hpp

/*
 * Copyright (c) 2023, Alibaba Group Holding Limited;
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
#include "ylt/struct_pack/struct_pack_impl.hpp"
 
namespace struct_pack {
 
template <typename T>
struct trivial_view {
 private:
  const T *ref;
 
 public:
  trivial_view(const T *t);
  trivial_view(const T &t);
  trivial_view(const trivial_view &) = default;
  trivial_view() : ref(nullptr){};
  trivial_view &operator=(const trivial_view &) = default;
  using value_type = T;
 
  void set(const T &obj);
  const T &get() const;
  const T *operator->() const;
};
 
template <typename T, uint64_t version>
struct compatible : public std::optional<T> {
  constexpr compatible() = default;
  constexpr compatible(const compatible &other) = default;
  constexpr compatible(compatible &&other) = default;
  constexpr compatible(std::optional<T> &&other)
      : std::optional<T>(std::move(other)){};
  constexpr compatible(const std::optional<T> &other)
      : std::optional<T>(other){};
  constexpr compatible &operator=(const compatible &other) = default;
  constexpr compatible &operator=(compatible &&other) = default;
  using std::optional<T>::optional;
  friend bool operator==(const compatible<T, version> &self,
                         const compatible<T, version> &other);
  static constexpr uint64_t version_number = version;
};
 
template <typename CharType, std::size_t Size>
struct string_literal {
  constexpr string_literal() = default;
  constexpr string_literal(std::basic_string_view<CharType> str);
  constexpr string_literal(const CharType (&value)[Size + 1]);
  constexpr std::size_t size() const;
  constexpr bool empty() const;
  constexpr CharType &operator[](std::size_t sz);
  constexpr const char &operator[](std::size_t sz) const;
 
  constexpr const CharType *data() const;
 
  template <std::size_t Size2>
  constexpr bool operator!=(const string_literal<CharType, Size2> &other) const;
 
  template <std::size_t Size2>
  constexpr bool operator==(const string_literal<CharType, Size2> &other) const;
 
  template <size_t Size2>
  string_literal<CharType, Size + Size2> constexpr operator+(
      string_literal<CharType, Size2> other) const;
 
 private:
  CharType ar[Size + 1];
};
 
struct err_code {
 public:
  struct_pack::errc ec;
  err_code() noexcept;
  err_code(struct_pack::errc ec) noexcept;
  err_code &operator=(errc ec);
  err_code(const err_code &err_code) noexcept;
  err_code &operator=(const err_code &o) noexcept;
  bool operator==(const err_code &o) const noexcept { return ec == o.ec; }
  bool operator!=(const err_code &o);
  operator bool() const noexcept { return ec != errc::ok; }
  int val() const noexcept;
  std::string_view message() const noexcept;
};
 
enum class errc {
  ok = 0,
  no_buffer_space,
  invalid_buffer,
  hash_conflict,
  invalid_width_of_container_length,
};
 
enum sp_config : uint64_t {
  DEFAULT = 0,
 
  DISABLE_TYPE_INFO = 0b1,
  ENABLE_TYPE_INFO = 0b10,
  DISABLE_ALL_META_INFO = 0b11,
 
  ENCODING_WITH_VARINT = 0b100,
  USE_FAST_VARINT = 0b1000
};
 
template <typename T>
constexpr std::size_t members_count;
 
inline std::error_code make_error_code(struct_pack::errc err);
 
inline std::string error_message(struct_pack::errc err);
 
template <typename... Args>
constexpr std::uint32_t get_type_code();
 
template <typename... Args>
constexpr decltype(auto) get_type_literal();
 
template <typename... Args>
[[nodiscard]] constexpr struct_pack::serialize_buffer_size get_needed_size(
    const Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename Writer, typename... Args>
void serialize_to(Writer &writer, const Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename... Args>
void serialize_to(char *buffer, serialize_buffer_size len, const Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, detail::struct_pack_buffer Buffer,
          typename... Args>
void serialize_to_with_offset(Buffer &buffer, std::size_t offset,
                              const Args &...args);
 
template <detail::struct_pack_buffer Buffer = std::vector<char>,
          typename... Args>
[[nodiscard]] Buffer serialize(const Args &...args);
 
template <
    detail::struct_pack_buffer Buffer = std::vector<char> typename... Args>
[[nodiscard]] Buffer serialize_with_offset(std::size_t offset,
                                           const Args &...args);
 
template <uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>,
          typename... Args>
[[nodiscard]] Buffer serialize(const Args &...args);
 
template <uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>,
          typename... Args>
[[nodiscard]] Buffer serialize_with_offset(std::size_t offset,
                                           const Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename T, typename... Args,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] struct_pack::err_code deserialize_to(T &t, const View &v,
                                                   Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename T, typename... Args>
[[nodiscard]] struct_pack::err_code deserialize_to(T &t, const char *data,
                                                   size_t size, Args &...args);
template <uint64_t conf = sp_config::DEFAULT, typename T, typename... Args,
          struct_pack::reader_t Reader>
[[nodiscard]] struct_pack::err_code deserialize_to(T &t, Reader &reader,
                                                   Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename T, typename... Args,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] struct_pack::err_code deserialize_to_with_offset(T &t,
                                                               const View &v,
                                                               size_t &offset,
                                                               Args &...args);
 
template <uint64_t conf = sp_config::DEFAULT, typename T, typename... Args>
[[nodiscard]] struct_pack::err_code deserialize_to_with_offset(
    T &t, const char *data, size_t size, size_t &offset, Args &...args);
 
template <typename... Args, struct_pack::detail::deserialize_view View>
[[nodiscard]] auto deserialize(const View &v);
 
template <typename... Args>
[[nodiscard]] auto deserialize(const char *data, size_t size);
 
template <typename... Args, struct_pack::reader_t Reader>
[[nodiscard]] auto deserialize(Reader &v);
 
template <typename... Args, struct_pack::detail::deserialize_view View>
[[nodiscard]] auto deserialize(const View &v, size_t &consume_len);
 
template <typename... Args>
[[nodiscard]] auto deserialize(const char *data, size_t size,
                               size_t &consume_len);
 
template <uint64_t conf, typename... Args,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] auto deserialize(const View &v);
 
template <uint64_t conf, typename... Args>
[[nodiscard]] auto deserialize(const char *data, size_t size);
 
template <uint64_t conf, typename... Args, struct_pack::reader_t Reader>
[[nodiscard]] auto deserialize(Reader &v);
 
template <uint64_t conf, typename... Args,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] auto deserialize(const View &v, size_t &consume_len);
 
template <uint64_t conf, typename... Args>
[[nodiscard]] auto deserialize(const char *data, size_t size,
                               size_t &consume_len);
 
template <typename... Args, struct_pack::detail::deserialize_view View>
[[nodiscard]] auto deserialize_with_offset(const View &v, size_t &offset);
 
template <typename... Args>
[[nodiscard]] auto deserialize_with_offset(const char *data, size_t size,
                                           size_t &offset);
 
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT,
          typename Field, struct_pack::detail::deserialize_view View>
[[nodiscard]] struct_pack::err_code get_field_to(Field &dst, const View &v);
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT,
          typename Field>
[[nodiscard]] struct_pack::err_code get_field_to(Field &dst, const char *data,
                                                 size_t size);
 
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT,
          typename Field, struct_pack::reader_t Reader>
[[nodiscard]] struct_pack::err_code get_field_to(Field &dst, Reader &reader);
 
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] auto get_field(const View &v);
 
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT>
[[nodiscard]] auto get_field(const char *data, size_t size);
 
template <typename T, size_t I, uint64_t conf = sp_config::DEFAULT,
          struct_pack::reader_t Reader>
[[nodiscard]] auto get_field(Reader &reader);
 
template <typename BaseClass, typename... DerivedClasses,
          struct_pack::detail::deserialize_view View>
[[nodiscard]] struct_pack::expected<std::unique_ptr<BaseClass>,
                                    struct_pack::err_code>
deserialize_derived_class(const View &v);
 
template <typename BaseClass, typename... DerivedClasses>
[[nodiscard]] struct_pack::expected<std::unique_ptr<BaseClass>,
                                    struct_pack::err_code>
deserialize_derived_class(const char *data, size_t size);
 
template <typename BaseClass, typename... DerivedClasses,
          struct_pack::reader_t Reader>
[[nodiscard]] struct_pack::expected<std::unique_ptr<BaseClass>,
                                    struct_pack::err_code>
deserialize_derived_class(Reader &reader);
 
}  // namespace struct_pack