libwz 0.1.0

package/src/Util/WzBinaryReader.cpp

@@ -0,0 +1,368 @@
+#include "wz/Util/WzBinaryReader.h"
+#include <algorithm>
+#include <cstring>
+#include <limits>
+#include <utility>
+#include "wz/Util/WzTool.h"
+#include "wz/WzAESConstant.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+
+// Simple UTF-16 to UTF-8 conversion (no deprecated codecvt)
+static std::string Utf16ToUtf8(const std::u16string& utf16) {
+  std::string result;
+  result.reserve(utf16.size() * 3);
+  for (char16_t ch : utf16) {
+    if (ch < 0x80) {
+      result.push_back(static_cast<char>(ch));
+    } else if (ch < 0x800) {
+      result.push_back(static_cast<char>(0xC0 | (ch >> 6)));
+      result.push_back(static_cast<char>(0x80 | (ch & 0x3F)));
+    } else {
+      result.push_back(static_cast<char>(0xE0 | (ch >> 12)));
+      result.push_back(static_cast<char>(0x80 | ((ch >> 6) & 0x3F)));
+      result.push_back(static_cast<char>(0x80 | (ch & 0x3F)));
+    }
+  }
+  return result;
+}
+
+WzBinaryReader::WzBinaryReader(std::shared_ptr<WzDataSource> source,
+                               const std::array<uint8_t, 4>& WzIv,
+                               int64_t startOffset)
+    : source_(std::move(source)),
+      position_(startOffset),
+      cache_(kCacheSize),
+      wzKey_(WzKeyGenerator::GenerateWzKey(WzIv)),
+      startOffset_(startOffset) {}
+
+WzBinaryReader::~WzBinaryReader() {
+  Close();
+}
+
+WzBinaryReader::WzBinaryReader(WzBinaryReader&& other) noexcept
+    : source_(std::move(other.source_)),
+      position_(other.position_),
+      cache_(std::move(other.cache_)),
+      cacheOffset_(other.cacheOffset_),
+      cacheSize_(other.cacheSize_),
+      wzKey_(std::move(other.wzKey_)),
+      hash_(other.hash_),
+      header_(other.header_),
+      startOffset_(other.startOffset_) {
+  other.header_ = nullptr;
+  other.position_ = 0;
+  other.cacheOffset_ = 0;
+  other.cacheSize_ = 0;
+}
+
+WzBinaryReader& WzBinaryReader::operator=(WzBinaryReader&& other) noexcept {
+  if (this != &other) {
+    Close();
+    source_ = std::move(other.source_);
+    position_ = other.position_;
+    cache_ = std::move(other.cache_);
+    cacheOffset_ = other.cacheOffset_;
+    cacheSize_ = other.cacheSize_;
+    wzKey_ = std::move(other.wzKey_);
+    hash_ = other.hash_;
+    header_ = other.header_;
+    startOffset_ = other.startOffset_;
+    other.header_ = nullptr;
+    other.position_ = 0;
+    other.cacheOffset_ = 0;
+    other.cacheSize_ = 0;
+  }
+  return *this;
+}
+
+uint8_t WzBinaryReader::ReadByte() {
+  uint8_t b = 0;
+  ReadExact(&b, sizeof(b));
+  return b;
+}
+
+int8_t WzBinaryReader::ReadSByte() {
+  int8_t b = 0;
+  ReadExact(&b, sizeof(b));
+  return b;
+}
+
+int16_t WzBinaryReader::ReadInt16() {
+  int16_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+int32_t WzBinaryReader::ReadInt32() {
+  int32_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+int64_t WzBinaryReader::ReadInt64() {
+  int64_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+uint16_t WzBinaryReader::ReadUInt16() {
+  uint16_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+uint32_t WzBinaryReader::ReadUInt32() {
+  uint32_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+uint64_t WzBinaryReader::ReadUInt64() {
+  uint64_t v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+float WzBinaryReader::ReadSingle() {
+  float v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+double WzBinaryReader::ReadDouble() {
+  double v = 0;
+  ReadExact(&v, sizeof(v));
+  return v;
+}
+
+std::vector<uint8_t> WzBinaryReader::ReadBytes(size_t count) {
+  std::vector<uint8_t> buf(count);
+  if (!ReadExact(buf.data(), count)) return {};
+  return buf;
+}
+
+int64_t WzBinaryReader::Position() {
+  return position_;
+}
+
+void WzBinaryReader::SetPosition(int64_t pos) {
+  position_ = pos;
+}
+
+std::string WzBinaryReader::DecodeAscii(int length) {
+  std::string result(length, '\0');
+  uint8_t mask = 0xAA;
+  for (int i = 0; i < length; i++) {
+    uint8_t encryptedChar = ReadByte();
+    encryptedChar ^= mask;
+    encryptedChar ^= wzKey_[i];
+    result[i] = static_cast<char>(encryptedChar);
+    mask++;
+  }
+  return result;
+}
+
+std::string WzBinaryReader::DecodeUnicode(int length) {
+  std::u16string utf16(length, u'\0');
+  uint16_t mask = 0xAAAA;
+  for (int i = 0; i < length; i++) {
+    uint16_t encryptedChar = ReadUInt16();
+    encryptedChar ^= mask;
+    encryptedChar ^=
+        static_cast<uint16_t>((wzKey_[i * 2 + 1] << 8) + wzKey_[i * 2]);
+    utf16[i] = static_cast<char16_t>(encryptedChar);
+    mask++;
+  }
+  return Utf16ToUtf8(utf16);
+}
+
+std::string WzBinaryReader::ReadString() {
+  int8_t smallLength = ReadSByte();
+  if (smallLength == 0) return {};
+
+  int length;
+  if (smallLength > 0)
+    length =
+        (smallLength == INT8_MAX) ? ReadInt32() : static_cast<int>(smallLength);
+  else
+    length = (smallLength == INT8_MIN) ? ReadInt32()
+                                       : static_cast<int>(-smallLength);
+
+  if (length <= 0) return {};
+
+  if (smallLength > 0)
+    return DecodeUnicode(length);
+  else
+    return DecodeAscii(length);
+}
+
+std::string WzBinaryReader::ReadString(size_t length) {
+  std::vector<char> buf(length);
+  ReadExact(buf.data(), length);
+  return std::string(buf.data(), length);
+}
+
+std::string WzBinaryReader::ReadNullTerminatedString() {
+  std::string result;
+  char c = '\0';
+  while (ReadExact(&c, 1) && c != '\0') {
+    result += c;
+  }
+  return result;
+}
+
+int32_t WzBinaryReader::ReadCompressedInt() {
+  int8_t sb = ReadSByte();
+  if (sb == INT8_MIN) {
+    return ReadInt32();
+  }
+  return sb;
+}
+
+int64_t WzBinaryReader::ReadLong() {
+  int8_t sb = ReadSByte();
+  if (sb == INT8_MIN) {
+    return ReadInt64();
+  }
+  return sb;
+}
+
+int64_t WzBinaryReader::Available() {
+  if (!source_ || position_ < 0) return 0;
+  const uint64_t pos = static_cast<uint64_t>(position_);
+  const uint64_t size = source_->Size();
+  if (pos >= size) return 0;
+  const uint64_t available = size - pos;
+  if (available > static_cast<uint64_t>(std::numeric_limits<int64_t>::max())) {
+    return std::numeric_limits<int64_t>::max();
+  }
+  return static_cast<int64_t>(available);
+}
+
+uint64_t WzBinaryReader::SourceSize() const {
+  return source_ ? source_->Size() : 0;
+}
+
+int64_t WzBinaryReader::ReadOffset() {
+  uint32_t offset = static_cast<uint32_t>(Position());
+  offset = (offset - header_->FStart()) ^ 0xFFFFFFFF;
+  offset *= hash_;
+  offset -= WzAESConstant::WZ_OffsetConstant;
+  offset = WzTool::RotateLeft(offset, static_cast<uint8_t>(offset & 0x1F));
+  uint32_t encryptedOffset = ReadUInt32();
+  offset ^= encryptedOffset;
+  offset += header_->FStart() * 2;
+  return static_cast<int64_t>(offset) + startOffset_;
+}
+
+std::string WzBinaryReader::ReadStringAtOffset(int64_t offset, bool readByte) {
+  int64_t currentOffset = Position();
+  SetPosition(offset - startOffset_);
+  if (readByte) {
+    ReadByte();
+  }
+  std::string returnString = ReadString();
+  SetPosition(currentOffset);
+  return returnString;
+}
+
+std::string WzBinaryReader::ReadStringBlock(int64_t offset) {
+  uint8_t flag = ReadByte();
+  switch (flag) {
+    case 0:
+    case WzImage::WzImageHeaderByte_WithoutOffset:
+      return ReadString();
+    case 1:
+    case WzImage::WzImageHeaderByte_WithOffset:
+      return ReadStringAtOffset(offset + ReadInt32());
+    default:
+      return {};
+  }
+}
+
+void WzBinaryReader::SetOffsetFromFStartToPosition(int offset) {
+  SetPosition(static_cast<int64_t>(header_->FStart() + offset) - startOffset_);
+}
+
+Result<void> WzBinaryReader::RollbackStreamPosition(int byOffset) {
+  int64_t pos = Position() - static_cast<int64_t>(byOffset);
+  if (pos < startOffset_)
+    return std::unexpected(
+        Error::IoError("Cant rollback stream position below 0"));
+  SetPosition(pos);
+  return {};
+}
+
+std::string WzBinaryReader::DecryptString(
+    const std::u16string& stringToDecrypt) {
+  size_t len = stringToDecrypt.length();
+  std::u16string output(len, u'\0');
+  for (size_t i = 0; i < len; i++) {
+    output[i] = static_cast<char16_t>(
+        static_cast<uint16_t>(stringToDecrypt[i]) ^
+        static_cast<uint16_t>((wzKey_[i * 2 + 1] << 8) + wzKey_[i * 2]));
+  }
+  return Utf16ToUtf8(output);
+}
+
+std::string WzBinaryReader::DecryptNonUnicodeString(
+    const std::u16string& stringToDecrypt) {
+  size_t len = stringToDecrypt.length();
+  std::u16string output(len, u'\0');
+  for (size_t i = 0; i < len; i++) {
+    output[i] =
+        static_cast<char16_t>(static_cast<uint16_t>(stringToDecrypt[i]) ^
+                              static_cast<uint16_t>(wzKey_[i]));
+  }
+  return Utf16ToUtf8(output);
+}
+
+void WzBinaryReader::PrintHexBytes(int numberOfBytes) {
+  // Debug only
+  (void)numberOfBytes;
+}
+
+void WzBinaryReader::Close() {
+  source_.reset();
+  cache_.clear();
+  cacheOffset_ = 0;
+  cacheSize_ = 0;
+}
+
+bool WzBinaryReader::ReadExact(void* destination, size_t count) {
+  if (count == 0) return true;
+  auto* output = static_cast<uint8_t*>(destination);
+  size_t total = 0;
+
+  while (total < count) {
+    if (position_ < 0) return false;
+    const uint64_t current = static_cast<uint64_t>(position_);
+    const uint64_t cacheEnd = cacheOffset_ + cacheSize_;
+    if (cacheSize_ == 0 || current < cacheOffset_ || current >= cacheEnd) {
+      if (!FillCache()) return false;
+      if (cacheSize_ == 0) return false;
+    }
+
+    const size_t cacheIndex = static_cast<size_t>(current - cacheOffset_);
+    const size_t available = cacheSize_ - cacheIndex;
+    const size_t toCopy = std::min(count - total, available);
+    std::memcpy(output + total, cache_.data() + cacheIndex, toCopy);
+    total += toCopy;
+    position_ += static_cast<int64_t>(toCopy);
+  }
+  return true;
+}
+
+bool WzBinaryReader::FillCache() {
+  if (!source_ || position_ < 0) return false;
+  cacheOffset_ = static_cast<uint64_t>(position_);
+  cacheSize_ = 0;
+  auto readResult = source_->ReadAt(cacheOffset_, cache_);
+  if (!readResult.has_value()) return false;
+  cacheSize_ = readResult.value();
+  return true;
+}
+
+}  // namespace wz

package/src/Util/WzBinaryWriter.cpp

@@ -0,0 +1,305 @@
+#include "wz/Util/WzBinaryWriter.h"
+#include <cstring>
+#include <utility>
+#include "wz/WzAESConstant.h"
+
+namespace wz {
+
+namespace {
+
+std::u16string Utf8ToUtf16(const std::string& value) {
+  std::u16string result;
+  result.reserve(value.size());
+
+  for (size_t i = 0; i < value.size();) {
+    uint8_t ch = static_cast<uint8_t>(value[i]);
+    uint32_t codePoint = 0;
+    size_t extraBytes = 0;
+
+    if ((ch & 0x80) == 0) {
+      codePoint = ch;
+    } else if ((ch & 0xE0) == 0xC0) {
+      codePoint = ch & 0x1F;
+      extraBytes = 1;
+    } else if ((ch & 0xF0) == 0xE0) {
+      codePoint = ch & 0x0F;
+      extraBytes = 2;
+    } else if ((ch & 0xF8) == 0xF0) {
+      codePoint = ch & 0x07;
+      extraBytes = 3;
+    } else {
+      result.push_back(static_cast<char16_t>(ch));
+      ++i;
+      continue;
+    }
+
+    if (i + extraBytes >= value.size()) {
+      result.push_back(static_cast<char16_t>(ch));
+      ++i;
+      continue;
+    }
+
+    bool valid = true;
+    for (size_t j = 1; j <= extraBytes; ++j) {
+      uint8_t next = static_cast<uint8_t>(value[i + j]);
+      if ((next & 0xC0) != 0x80) {
+        valid = false;
+        break;
+      }
+      codePoint = (codePoint << 6) | (next & 0x3F);
+    }
+
+    if (!valid) {
+      result.push_back(static_cast<char16_t>(ch));
+      ++i;
+      continue;
+    }
+
+    if (codePoint <= 0xFFFF) {
+      result.push_back(static_cast<char16_t>(codePoint));
+    } else {
+      codePoint -= 0x10000;
+      result.push_back(static_cast<char16_t>(0xD800 + (codePoint >> 10)));
+      result.push_back(static_cast<char16_t>(0xDC00 + (codePoint & 0x3FF)));
+    }
+    i += extraBytes + 1;
+  }
+
+  return result;
+}
+
+bool NeedsUnicode(const std::u16string& value) {
+  for (char16_t ch : value) {
+    if (ch > INT8_MAX) return true;
+  }
+  return false;
+}
+
+uint32_t RotateLeft32(uint32_t value, uint8_t count) {
+  count &= 0x1F;
+  if (count == 0) return value;
+  return static_cast<uint32_t>((value << count) | (value >> (32 - count)));
+}
+
+}  // namespace
+
+WzBinaryWriter::WzBinaryWriter(WzStream& output,
+                               const std::array<uint8_t, 4>& WzIv)
+    : output_(&output), wzKey_(WzKeyGenerator::GenerateWzKey(WzIv)) {}
+
+WzBinaryWriter::WzBinaryWriter(WzStream& output,
+                               const std::array<uint8_t, 4>& WzIv,
+                               uint32_t hash)
+    : output_(&output),
+      wzKey_(WzKeyGenerator::GenerateWzKey(WzIv)),
+      hash_(hash) {}
+
+WzBinaryWriter::WzBinaryWriter(WzBinaryWriter&& other) noexcept
+    : output_(other.output_),
+      wzKey_(std::move(other.wzKey_)),
+      hash_(other.hash_),
+      header_(other.header_),
+      stringCache_(std::move(other.stringCache_)) {
+  other.output_ = nullptr;
+}
+
+WzBinaryWriter& WzBinaryWriter::operator=(WzBinaryWriter&& other) noexcept {
+  if (this != &other) {
+    output_ = other.output_;
+    wzKey_ = std::move(other.wzKey_);
+    hash_ = other.hash_;
+    header_ = other.header_;
+    stringCache_ = std::move(other.stringCache_);
+    other.output_ = nullptr;
+  }
+  return *this;
+}
+
+int64_t WzBinaryWriter::Position() {
+  return output_ ? output_->Position() : -1;
+}
+
+void WzBinaryWriter::ClearStringCache() {
+  stringCache_.clear();
+}
+
+bool WzBinaryWriter::WriteRawByte(uint8_t value) {
+  return output_ && output_->WriteByte(value);
+}
+
+template <typename T>
+void WzBinaryWriter::WriteLittleEndian(T value) {
+  uint8_t bytes[sizeof(T)];
+  std::memcpy(bytes, &value, sizeof(T));
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+  for (size_t i = 0; i < sizeof(T) / 2; ++i) {
+    std::swap(bytes[i], bytes[sizeof(T) - 1 - i]);
+  }
+#endif
+  BaseStream().Write(bytes, sizeof(T));
+}
+
+void WzBinaryWriter::WriteByte(uint8_t value) {
+  WriteRawByte(value);
+}
+
+void WzBinaryWriter::WriteSByte(int8_t value) {
+  WriteByte(static_cast<uint8_t>(value));
+}
+
+void WzBinaryWriter::WriteInt16(int16_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteInt32(int32_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteInt64(int64_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteUInt16(uint16_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteUInt32(uint32_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteUInt64(uint64_t value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteSingle(float value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteDouble(double value) {
+  WriteLittleEndian(value);
+}
+
+void WzBinaryWriter::WriteString(const std::string& value) {
+  if (value.empty()) {
+    WriteByte(0);
+    return;
+  }
+
+  std::u16string utf16 = Utf8ToUtf16(value);
+  if (NeedsUnicode(utf16)) {
+    WriteUnicodeString(utf16);
+  } else {
+    WriteAsciiString(value);
+  }
+}
+
+void WzBinaryWriter::WriteAsciiString(const std::string& value) {
+  const int32_t length = static_cast<int32_t>(value.length());
+  if (length > INT8_MAX) {
+    WriteSByte(INT8_MIN);
+    WriteInt32(length);
+  } else {
+    WriteSByte(static_cast<int8_t>(-length));
+  }
+
+  uint8_t mask = 0xAA;
+  for (int32_t i = 0; i < length; ++i) {
+    uint8_t encryptedChar = static_cast<uint8_t>(value[i]);
+    encryptedChar ^= wzKey_[i];
+    encryptedChar ^= mask;
+    WriteByte(encryptedChar);
+    ++mask;
+  }
+}
+
+void WzBinaryWriter::WriteUnicodeString(const std::u16string& value) {
+  const int32_t length = static_cast<int32_t>(value.length());
+  if (length >= INT8_MAX) {
+    WriteSByte(INT8_MAX);
+    WriteInt32(length);
+  } else {
+    WriteSByte(static_cast<int8_t>(length));
+  }
+
+  uint16_t mask = 0xAAAA;
+  for (int32_t i = 0; i < length; ++i) {
+    uint16_t encryptedChar = static_cast<uint16_t>(value[i]);
+    encryptedChar ^=
+        static_cast<uint16_t>((wzKey_[i * 2 + 1] << 8) + wzKey_[i * 2]);
+    encryptedChar ^= mask;
+    WriteUInt16(encryptedChar);
+    ++mask;
+  }
+}
+
+void WzBinaryWriter::WriteNullTerminatedString(const std::string& value) {
+  BaseStream().Write(value.data(), value.size());
+  WriteByte(0);
+}
+
+void WzBinaryWriter::WriteStringValue(const std::string& value,
+                                      uint8_t withoutOffset,
+                                      uint8_t withOffset) {
+  auto found = stringCache_.find(value);
+  if (value.length() > 4 && found != stringCache_.end()) {
+    WriteByte(withOffset);
+    WriteInt32(found->second);
+    return;
+  }
+
+  WriteByte(withoutOffset);
+  int32_t stringOffset = static_cast<int32_t>(Position());
+  WriteString(value);
+  stringCache_.try_emplace(value, stringOffset);
+}
+
+bool WzBinaryWriter::WriteWzObjectValue(const std::string& value,
+                                        WzDirectoryType type) {
+  std::string storeName =
+      std::to_string(static_cast<uint8_t>(type)) + "_" + value;
+  auto found = stringCache_.find(storeName);
+  if (value.length() > 4 && found != stringCache_.end()) {
+    WriteByte(
+        static_cast<uint8_t>(WzDirectoryType::RetrieveStringFromOffset_2));
+    WriteInt32(found->second);
+    return true;
+  }
+
+  int32_t stringOffset =
+      static_cast<int32_t>(Position() - static_cast<int64_t>(header_.FStart()));
+  WriteByte(static_cast<uint8_t>(type));
+  WriteString(value);
+  stringCache_.try_emplace(storeName, stringOffset);
+  return false;
+}
+
+void WzBinaryWriter::WriteCompressedInt(int32_t value) {
+  if (value > INT8_MAX || value <= INT8_MIN) {
+    WriteSByte(INT8_MIN);
+    WriteInt32(value);
+  } else {
+    WriteSByte(static_cast<int8_t>(value));
+  }
+}
+
+void WzBinaryWriter::WriteCompressedLong(int64_t value) {
+  if (value > INT8_MAX || value <= INT8_MIN) {
+    WriteSByte(INT8_MIN);
+    WriteInt64(value);
+  } else {
+    WriteSByte(static_cast<int8_t>(value));
+  }
+}
+
+void WzBinaryWriter::WriteOffset(int64_t value) {
+  uint32_t encOffset = static_cast<uint32_t>(Position());
+  encOffset = (encOffset - header_.FStart()) ^ 0xFFFFFFFFu;
+  encOffset *= hash_;
+  encOffset -= WzAESConstant::WZ_OffsetConstant;
+  encOffset = RotateLeft32(encOffset, static_cast<uint8_t>(encOffset));
+  uint32_t writeOffset =
+      encOffset ^ (static_cast<uint32_t>(value) - (header_.FStart() * 2));
+  WriteUInt32(writeOffset);
+}
+
+}  // namespace wz

package/src/Util/WzBlobDataSource.cpp

@@ -0,0 +1,47 @@
+#include "wz/Util/WzBlobDataSource.h"
+
+#include <algorithm>
+#include <limits>
+#include <utility>
+
+namespace wz {
+
+WzBlobDataSource::WzBlobDataSource(uint64_t size, ReadCallback read_callback)
+    : size_(size), read_callback_(std::move(read_callback)) {}
+
+Result<size_t> WzBlobDataSource::ReadAt(uint64_t offset,
+                                        std::span<uint8_t> destination) {
+  if (offset > size_) {
+    return std::unexpected(Error::IoError("Read offset is beyond blob size"));
+  }
+
+  const uint64_t available = size_ - offset;
+  const size_t count = static_cast<size_t>(
+      std::min<uint64_t>(available, static_cast<uint64_t>(destination.size())));
+  if (count == 0) return 0;
+  if (count > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    return std::unexpected(Error::IoError("Blob read size exceeds limits"));
+  }
+  if (offset > 9007199254740991ULL) {
+    return std::unexpected(Error::IoError("Blob read offset exceeds limits"));
+  }
+
+  if (!read_callback_) {
+    return std::unexpected(Error::IoError("Blob read callback is not set"));
+  }
+
+  auto bytes_read = read_callback_(offset, destination.subspan(0, count));
+  if (!bytes_read.has_value()) {
+    return std::unexpected(bytes_read.error());
+  }
+  if (bytes_read.value() != count) {
+    return std::unexpected(Error::IoError("Failed to read blob range"));
+  }
+  return bytes_read.value();
+}
+
+uint64_t WzBlobDataSource::Size() const {
+  return size_;
+}
+
+}  // namespace wz