locstring.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
#include <welder/vocabulary.hpp>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/core/error.hpp>
 
namespace wowlib::db {
  constexpr std::optional<std::size_t> localeColumnSlot(Locale locale) {
    switch (locale) {
    case Locale::enUS:
    case Locale::enGB: return 0;
    case Locale::koKR: return 1;
    case Locale::frFR: return 2;
    case Locale::deDE: return 3;
    case Locale::zhCN: return 4;
    case Locale::zhTW: return 5;
    case Locale::esES: return 6;
    case Locale::esMX: return 7;
    case Locale::ruRU: return 8;
    case Locale::ptBR: return 10;
    case Locale::itIT: return 11;
    }
    return std::nullopt;
  }

  template <std::size_t Langs>
  struct [[
      =welder::weld,
      =welder::doc(R"(
        A localized string column of a pre-Cataclysm client database: one string
        per language slot in the client's fixed column order, plus the locale
        flags field. Use at()/set() to address slots by Locale.)")
    ]] LocString {
    [[=welder::mark::no_reassign,
      =welder::doc(
        "The language slot values in client column order (0 enUS, 1 koKR, "
        "2 frFR, 3 deDE, 4 zhCN, 5 zhTW, 6 esES, 7 esMX, then ruRU/ptBR/"
        "itIT for 16-slot eras); empty for languages the file does not "
        "carry.")]]
    std::array<std::string, Langs> values{};
 
    [[=welder::doc(
      "The trailing locale flags field; a bitmask the client never "
      "reads, preserved verbatim.")]]
    std::uint32_t flags = 0;


    [[nodiscard]]
    [[=welder::doc(
        "The string stored for a locale; empty when the locale has no "
        "slot in this client era."),
      =welder::returns("the slot value, empty when absent")]]
    std::string_view at(Locale locale [[=welder::doc("the locale to look up")]]) const {
      const auto slot = localeColumnSlot(locale);
      if (!slot || *slot >= Langs) return {};
      return values[*slot];
    }

    [[=welder::doc("Store a string in a locale's slot."),
      =welder::returns("nothing; raises when the locale has no slot in this "
        "client era")]]
    Result<void> set(Locale locale [[=welder::doc("the locale to write")]],
                     std::string_view value [[=welder::doc(
                       "the string to store")]]) {
      const auto slot = localeColumnSlot(locale);
      if (!slot || *slot >= Langs)
        return makeError(ErrorCode::NotSupported,
                          std::string{"locale "} + std::string{localeCode(locale)} +
                          " has no langstringref slot in this client era");
      values[*slot] = value;
      return {};
    }
 
    constexpr bool operator==(const LocString&) const = default;
  };

  using LocString8 = LocString<8>;

  using LocString16 = LocString<16>;
}