desc_str.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "core.hpp"
#include "libxr_type.hpp"
 
namespace LibXR::USB
{
class DescriptorStrings
{
 public:
  enum class Index : uint8_t
  {
    LANGUAGE_ID = 0x00,          
    MANUFACTURER_STRING = 0x01,  
    PRODUCT_STRING = 0x02,       
    SERIAL_NUMBER_STRING = 0x03  
  };
 
  enum class Language : uint16_t
  {
    EN_US = 0x0409,  
    ZH_CN = 0x0804   
  };
 
  typedef const char* StringData;
  static constexpr size_t STRING_LIST_SIZE = 3;
 
  struct LanguagePack
  {
    Language lang_id;                      
    StringData strings[STRING_LIST_SIZE];  
    size_t string_lens[STRING_LIST_SIZE];  
    size_t max_string_length;              
  };
 
  template <size_t N1, size_t N2, size_t N3>
  static const constexpr LanguagePack MakeLanguagePack(Language lang,
                                                       const char (&manu)[N1],
                                                       const char (&prod)[N2],
                                                       const char (&serial)[N3])
  {
    static_assert(N1 < 128 && N2 < 128 && N3 < 128,
                  "String length must be less than 128.");
 
    auto len_manu = CalcUTF16LELen(manu);
    auto len_prod = CalcUTF16LELen(prod);
    auto len_serial = CalcUTF16LELen(serial);
 
    size_t maxlen = len_manu;
    if (len_prod > maxlen)
    {
      maxlen = len_prod;
    }
    if (len_serial > maxlen)
    {
      maxlen = len_serial;
    }
 
    return LanguagePack{
        lang, {manu, prod, serial}, {len_manu, len_prod, len_serial}, maxlen};
  }
 
  DescriptorStrings(const std::initializer_list<const LanguagePack*>& lang_list,
                    const uint8_t* uid = nullptr, size_t uid_len = 0);
 
  DescriptorStrings(const DescriptorStrings&) = delete;
  DescriptorStrings& operator=(const DescriptorStrings&) = delete;
 
  ErrorCode GenerateString(Index index, uint16_t lang);
 
  RawData GetData();
 
  RawData GetLangIDData();
 
  [[nodiscard]] bool HasLanguage(uint16_t lang) const;
 
 private:
  template <size_t N>
  static constexpr size_t CalcUTF16LELen(const char (&input)[N])
  {
    size_t len = 0;
    for (size_t i = 0; i < N && input[i];)
    {
      unsigned char c = static_cast<unsigned char>(input[i]);
      if (c < 0x80)
      {
        len += 2;
        i += 1;
      }
      else if ((c & 0xE0) == 0xC0)
      {
        len += 2;
        i += 2;
      }
      else if ((c & 0xF0) == 0xE0)
      {
        len += 2;
        i += 3;
      }
      else
      {
        i += 4;
      }
    }
    return len;
  }
 
  static void ToUTF16LE(const char* str, uint8_t* buffer);
 
  const size_t LANG_NUM;              
  uint16_t* header_;                  
  uint16_t* land_id_;                 
  const LanguagePack** string_list_;  
  RawData buffer_;                    
 
  const uint8_t* serial_uid_;  
  size_t serial_uid_len_;      
};
 
}  // namespace LibXR::USB