dl_string.h

浏览该文件的文档.

#pragma once
#include <array>
#include <string>
#include <system_error>
#include <charconv>
 
#include <fmt/format.h>
 
#include "memory/dl_code_cvt.h"
#include "dl_range.h"
#include "math/dl_algorithm.h"
#include "io/dl_log.h"
#include "base/dl_type_def.h"
#include "base/dl_vector2.h"
#include "base/dl_array2.h"
#include "memory/dl_buffer.h"
 
namespace dl
{
 
 
// unordered_map支持 string_view
struct string_hash
{
    using hash_type = std::hash<std::string_view>;
    using is_transparent = void;
 
    std::size_t operator()(const char* str) const { return hash_type{}(str); }
    std::size_t operator()(std::string_view str) const { return hash_type{}(str); }
    std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
};
 
//-----------------------------字符串连接-------------------
inline std::string& operator+=(std::string& a, std::string_view b)
{
    a.append(b);
    return a;
}
inline std::string operator+(const std::string& a, std::string_view b)
{
    std::string ret{ a };
    return ret += b;
}
inline std::string operator+(std::string_view a, std::string_view b)
{
    std::string ret{ a };
    return ret += b;
}

template<IsBase T>
std::string to_string(T v)
{
    if constexpr (std::is_floating_point_v<T>)
    {
        return fmt::format("{:.2f}", v);
    }
    else
        return std::to_string(v);
}
 
inline std::string to_string(const std::string& str)
{
    return str;
}

template<typename T, size_t N>
std::string to_string(const std::array<T, N>& arr, std::string_view delimiter = ", ")
{
    static_assert(N != 0);
    std::string ret;
    for (size_t i = 0; i < N - 1; ++i)
    {
        ret += dl::to_string(arr[i]);
        ret += delimiter;
    }
    ret += dl::to_string(arr[N - 1]);
    return ret;
}
template<typename T, size_t N>
std::string to_string(const Array<T, N>& arr, std::string_view delimiter = ", ")
{
    static_assert(N != 0);
    std::string ret;
    for (size_t i = 0; i < N - 1; ++i)
    {
        ret += dl::to_string(arr[i]);
        ret += delimiter;
    }
    ret += dl::to_string(arr[N - 1]);
    return ret;
}
template<typename T, size_t N>
std::string to_string(const ArrayS2<T, N>& arr, std::string_view delimiter = ", ")
{
    static_assert(N != 0);
    std::string ret;
    for (size_t i = 0; i < N - 1; ++i)
    {
        ret += dl::to_string(arr.x[i]);
        ret += delimiter;
        ret += dl::to_string(arr.y[i]);
        ret += delimiter;
    }
    ret += dl::to_string(arr.x[N - 1]);
    ret += delimiter;
    ret += dl::to_string(arr.y[N - 1]);
    return ret;
}

template<typename T>
std::string to_string(const std::vector<T>& vec, std::string_view delimiter = ", ")
{
    if (vec.empty())
        return {};
    std::string ret;
    for (size_t i = 0; i < vec.size() - 1; ++i)
    {
        ret += dl::to_string(vec[i]);
        ret += delimiter;
    }
    ret += dl::to_string(vec[vec.size() - 1]);
    return ret;
}

std::string to_string(std::error_code code);

std::string to_string(std::exception& e);

std::string to_string(BufferView buf);
 
inline std::string to_string(const Buffer& buf)
{
    return to_string(BufferView{ buf });
}

std::string to_string_check(BufferView buf, bool tips = true);

std::string to_string_hex(BufferView buf, bool upper = false, bool add_tag = false);

template<size_t N>
std::string to_string_hex(const std::array<std::byte, N>& buf, bool upper = false, bool add_tag = false)
{
    return to_string_hex(CreateBufferView(buf), add_tag);
}

std::string to_string_auto(BufferView buf, bool add_tag = false);
 
enum class StringType
{
    NORMAL,
    INTGER,
    FLOAT
};

namespace String
{ 
inline Float toFloat(std::string_view str, Float default_v = 0)
{
#if DL_PLATFORM != DL_PLATFORM_APPLE
    std::from_chars(str.data(), str.data() + str.size(), default_v);
    return default_v;
#else
    if (str.empty())
        return default_v;
 
    if constexpr (std::is_same_v<Float, float>)
    {
        try
        {
            return std::stof(str.data());
        }
        catch (...)
        {
            return default_v;
        }
    }
    else if constexpr (std::is_same_v<Float, double>)
    {
        try
        {
            return std::stod(str.data());
        }
        catch (...)
        {
            return default_v;
        }
    }
#endif
}

inline bool IsBlank(char ch)
{
    return ch == ' '
        || ch == '\n'
        || ch == '\t';
}

inline std::vector<std::string_view> ToView(const std::vector<std::string>& a)
{
    std::vector<std::string_view> ret;
    for (auto& iter : a)
    {
        ret.push_back(iter);
    }
    return ret;
}

inline bool IsBlank(std::string_view str)
{
    for (char ch : str)
    {
        if (!IsBlank(ch))
            return false;
    }
    return true;
}

inline std::string_view EraseBlankBoth(std::string_view str)
{
    auto iter = str.begin();
    while (iter != str.end() && IsBlank(*iter))
    {
        ++iter;
    }
    auto iter1 = str.rbegin();
    while (iter1 != str.rend() && IsBlank(*iter1))
    {
        ++iter1;
    }
 
    return { iter, iter1.base() };
}

inline int toInt(std::string_view str, int default_v = 0)
{
#if DL_PLATFORM != DL_PLATFORM_APPLE
    std::from_chars(str.data(), str.data() + str.size(), default_v);
    return default_v;
#else
    try
    {
        return std::stoi(str.data());
    }
    catch (...)
    {
        return default_v;
    }
#endif
}
inline unsigned toUint(std::string_view str, unsigned default_v = 0)
{
#if DL_PLATFORM != DL_PLATFORM_APPLE
    std::from_chars(str.data(), str.data() + str.size(), default_v);
    return default_v;
#else
    try
    {
        return std::stoul(str.data());
    }
    catch (...)
    {
        return default_v;
    }
#endif
}

inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
{
#if DL_PLATFORM != DL_PLATFORM_APPLE
    std::from_chars(str.data(), str.data() + str.size(), default_v);
    return default_v;
#else
    try
    {
        return std::stoll(str.data());
    }
    catch (...)
    {
        return default_v;
    }
#endif
}

inline bool getInt(std::string_view str, int& ret)
{
#if DL_PLATFORM != DL_PLATFORM_APPLE
    std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), ret);
    return r.ec == std::errc();
#else
    try
    {
        ret = std::stoi(str.data());
    }
    catch (...)
    {
        return false;
    }
    return true;
#endif
}

inline bool toBool(std::string_view str, bool default_v = false)
{
    return toInt(str, default_v);
}

inline bool getByte(std::string_view str, std::byte& ret)
{
 
#if DL_PLATFORM != DL_PLATFORM_APPLE
    uint8_t v;
    std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), v, 16);
    if (r.ec != std::errc())
        return false;
    ret = (std::byte)v;
    return true;
#else
    try
    {
        ret = std::stoi(str.data(), nullptr, 16);
    }
    catch (...)
    {
        return false;
    }
    return true;
#endif
}

template<std::size_t N>
Array<int, N> toPoint(std::string_view str, char d = ',')
{
    std::vector<std::string_view> vec;
    split_no_empty(str, d, vec);
    if (vec.size() != N)
    {
        log_warn("分割后数量不匹配，将丢弃或填充0：{}/{}", vec.size(), N);
        vec.resize(N);
    }
 
    Array<int, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        std::string_view s = EraseBlankBoth(vec[i]);
        ret[i] = toInt(s);
    }
    return ret;
}

template<std::size_t N>
Array<Float, N> toPosition(std::string_view str, char d = ',')
{
    std::vector<std::string_view> vec;
    split_no_empty(str, d, vec);
    if (vec.size() != N)
    {
        log_warn("分割后数量不匹配，将丢弃或填充0：{}/{}", vec.size(), N);
        vec.resize(N);
    }
    
    Array<Float, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        std::string_view s = EraseBlankBoth(vec[i]);
        ret[i] = toFloat(s);
    }
    return ret;
}
 
inline Point2 toPoint2(std::string_view str, char d = ',')
{
    return toPoint<2>(str, d);
}
inline Position toPosition2(std::string_view str, char d = ',')
{
    return toPosition<2>(str, d);
}

constexpr StringType GetType(std::string_view str)
{
    bool has_dot = false;
    for (size_t i = 0; i < str.size(); ++i)
    {
        const char& ch = str[i];
        if (std::isdigit(ch))
            continue;
        else if (i == 0 && (ch == '+' || ch == '-'))
            continue;
        else if (!has_dot && ch == '.')
        {
            has_dot = true;
            continue;
        }
        else
            return StringType::NORMAL;
    }
    return has_dot ? StringType::FLOAT : StringType::INTGER;
}

inline std::string AddQuotes(std::string_view str, char quotes = '\"')
{
    std::string ret;
    ret.reserve(str.size() + 2);
    ret += quotes;
    ret += str;
    ret += quotes;
    return ret;
}

size_t Wcwidth(wchar_t ch);
std::string FillEndl(std::string_view str, char ch = ' ');
constexpr std::string_view GetNotFileName()
{
    return R"(<>/\|:"*?)";
}

inline void EraseNotFileName(std::string& name)
{
    Erase::Match(name, std::string{ String::GetNotFileName() });
}

inline void ToLower(std::string& str)
{
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
}

inline std::string ToLower(const std::string& str)
{
    std::string ret = str;
    std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
    return ret;
}
inline void ToUpper(std::string& str)
{
    std::transform(str.begin(), str.end(), str.begin(), ::toupper);
}
inline std::string ToUpper(std::string_view str)
{
    std::string ret{ str };
    ToUpper(ret);
    return ret;
}
inline bool EqualToLower(std::string_view a, std::string_view b)
{
    if (a.size() != b.size())
        return false;
    if (a.empty())
        return true;
    for (size_t i = 0; i < a.size(); ++i)
    {
        if (std::tolower(a[i]) != std::tolower(b[i]))
            return false;
    }
    return true;
}
 

inline bool toBoolEx(std::string_view str, bool default_v = false)
{
    int v;
    if (getInt(str, v))
        return v;
    else if (String::EqualToLower(str, "true"))
        return true;
    else if (String::EqualToLower(str, "false"))
        return false;
    return default_v;
}

inline std::string Splicing(const std::vector<std::string>& vec, 
    std::string_view delimiter = ", ", std::string_view end = "")
{
    if (vec.empty())
        return {};
    if (vec.size() == 1)
        return vec[0] + end;
 
    std::string ret;
    for (size_t i = 0; i < vec.size() - 1; ++i)
    {
        ret += vec[i];
        ret += delimiter;
    }
    ret += vec[vec.size() - 1];
    ret += end;
    return ret;
}
inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
{
    std::string ret;
    for (auto& iter : str)
    {
        if (Every::NotEqual(vec_char, iter))
            ret.push_back(iter);
    }
    return ret;
}
inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
{
    std::string ret;
 
    for (auto& iter : str)
    {
        if (n && Any::Equal(vec_char, iter))
        {
            --n;
            continue;
        }
        else
            ret.push_back(iter);
    }
    return ret;
}
inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
{
    std::string ret;
 
    bool check = true;
    for (auto& iter : str)
    {
        if (check)
        {
            if (Any::Equal(vec_char, iter))
                ;// 需要删除，仍需判断
            else
            {
                check = false;
                ret.push_back(iter);
            }
        }   
        else
            ret.push_back(iter);
    }
    return ret;
}
inline std::string EraseBlank(std::string_view str)
{
    return EraseCharAll(str, " \t\n");
}
inline std::string EraseBlankN(std::string_view str, size_t n = 1)
{
    return EraseCharN(str, " \t\n", n);
}
inline std::string EraseBlankHead(std::string_view str)
{
    return EraseCharHead(str, " \t\n");
}
inline std::string EraseEndl(std::string_view str)
{
    if (str.empty())
        return {};
 
    size_t i = str.size() - 1;
    for (; i >= 0; --i)
    {
        if (str[i] != '\n' && str[i] != '\r')
            break;
    }
    return { str.data(), str.data() + i + 1 };
}

inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset = 0)
{
    // 某些平台wchar_t是4字节，必须使用u32string
    std::u32string s{ (char32_t)(wc + offset) };
 
    return CodeCvt::Utf32ToUtf8(s);
}
 

//string GetAscii()
//{
//  string str_ascii = format("ascii表:\n0 -> /0[t_8]");
//  for (char ch = 1; ch < 128; ++ch)
//  {
//      if (ch == '\n')
//          str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
//      else if (ch == '\t')
//          str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
//      else if (ch == '[')
//          str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
//      else if (ch == ']')
//          str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
//      else
//          str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
//
//      if ((ch - 1) % 6 == 0)
//          str_ascii += "\n";
//  }
//  return str_ascii;
//}

std::string Sprintf(const char* format, ...);

template<typename T>
std::string SplitIntegerToThousands(T integer)
{
    return r_insert_per_num(to_string(integer), ',', 3);
}

inline std::vector<std::string> Split(const std::string& str, char d)
{
    std::vector<std::string> ret;
    split(str, d, ret);
    return ret;
}
inline std::vector<std::string_view> SplitView(std::string_view str, char d)
{
    std::vector<std::string_view> ret;
    split(str, d, ret);
    return ret;
}

inline std::vector<std::string> Split(const std::string& str, const std::string& d)
{
    std::vector<std::string> ret;
    split_sub(str, d, ret);
    return ret;
}
inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view d)
{
    std::vector<std::string_view> ret;
    split_sub(str, d, ret);
    return ret;
}

inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
{
    std::vector<std::string> ret;
    split_no_empty(str, d, ret);
    return ret;
}

inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, char d)
{
    std::vector<std::string_view> ret;
    split_no_empty(str, d, ret);
    return ret;
}
 

inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
{
    std::vector<std::string_view> ret;
    size_t beg = 0;
    size_t cur = 0;
    for (; cur < str.size(); ++cur)
    {
        if (Any::Equal(vec_ch, str[cur]))
        {
            if (beg != cur)
                ret.push_back({ str.data() + beg, str.data() + cur });
            beg = cur + 1;
        }
    }
    if (beg != cur)
        ret.push_back({ str.data() + beg, str.data() + cur });
    return ret;
}
inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
    const std::vector<char>& vec_ch)
{
    return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
}
//* @brief 处理子字符串（通过特定字符分割）
//* @param[in] str 整个字符串
//* @param[in] vec_ch 匹配的字符
//* @note 连续匹配返回空串
//*/
//inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
//{
//  std::vector<std::string_view> ret;
//  size_t beg = 0;
//  size_t cur = 0;
//  for (; cur < str.size(); ++cur)
//  {
//      if (Any::Equal(vec_ch, str[cur]))
//      {
//          if (beg != cur)
//              ret.push_back({ str.data() + beg, str.data() + cur });
//          else
//              ret.push_back({});
//          beg = cur + 1;
//      }
//  }
//  if (beg != cur)
//      ret.push_back({ str.data() + beg, str.data() + cur });
//  else
//      ret.push_back({});
//  return ret;
//}
//inline std::vector<std::string_view> SplitView(std::string_view str,
//  const std::vector<char>& vec_ch)
//{
//  return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
//}
 
 

inline void EraseExtension(std::string& path_name)
{
    if (Erase::TailFromLast(path_name, '.'))
        path_name.pop_back();
}
[[nodiscard]]
inline std::string EraseExtension(std::string_view path_name)
{
    std::string ret = std::string{ path_name };
    EraseExtension(ret);
    return ret;
}

inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
{
    if (Erase::TailFromLast(path_name, '.'))
    {
        path_name += fmt;
        return;
    }
    path_name += ".";
    path_name += std::string{ fmt };
}
[[nodiscard]]
inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
{
    std::string ret = std::string{ path_name };
    ReplaceExtension(ret, fmt);
    return ret;
}

inline void EraseFilename(std::string& path_name)
{
    if (!Erase::TailFromLast(path_name, '/'))
        log_err0("不是一个有效路径！");
}
[[nodiscard]]
inline std::string EraseFilename(std::string_view path_name)
{
    std::string ret = std::string{ path_name };
    EraseFilename(ret);
    return ret;
}

inline std::string GetFileStem(std::string_view path_name)
{
    std::string name{ path_name };
    Erase::HeadFromLast(name, '/');
    if (Erase::TailFromLast(name, '.'))
        name.pop_back();
    return name;
}
inline std::string ErasePath(std::string_view path_name, std::string_view path)
{
    std::string ret{ path_name };
    Erase::HeadSub(ret, std::string{ path });
    return ret;
}

 
inline bool IsRelativePath(std::string_view path_name)
{
    if (path_name.empty())
        return true;
 
    if (path_name[0] == '/')
        return false;
 
    size_t len = (std::min)(path_name.size(), (size_t)12);
    for (size_t i = 0; i < len; ++i)
    {
        if (path_name[i] == ':')
            return false;
    }
    return true;
}
 

bool GetPathAndRes(
    std::string_view path_root, std::string_view path_name,
    std::string& path_real, std::string& res_name,
    std::string_view name = "");
 

std::string GetResName(
    std::string_view path_root,
    std::string_view path_name);
 

std::string CvtRelativePath(std::string path_cur, std::string_view path);

inline void CvtPathSeparator(std::string& path)
{
    Every::Replace(path, '\\', '/');
}
[[nodiscard]]
inline std::string CvtPathSeparator(std::string_view path)
{
    std::string ret{ path };
    CvtPathSeparator(ret);
    return ret;
}
inline void CvtPathSeparatorBack(std::string& path)
{
    Every::Replace(path, '/', '\\');
}
[[nodiscard]]
inline std::string CvtPathSeparatorBack(std::string_view path)
{
    std::string ret{ path };
    CvtPathSeparatorBack(ret);
    return ret;
}
inline std::string CvtLineBreak(std::string_view str)
{
    std::string ret;
    for (auto& iter : str)
    {
        if(iter == '\r')
            continue;
        ret.push_back(iter);
    }
    return ret;
}
 

inline bool HasNumber(std::string_view str)
{
    return Any::Yes(str, isdigit);
}

inline bool HasLetter(std::string_view str)
{
    return Any::Yes(str, isalpha);
}

std::vector<std::string> ParseCommand(std::string_view cmd);

template<size_t W, size_t H>
Array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
{
    //每一列得到一个最大宽度
    Array<size_t, W> mul_col{};
    for (size_t j = 0; j < H; ++j)
    {
        for (size_t i = 0; i < W; ++i)
        {
            if (arr[j][i].size() > mul_col[i])
                mul_col[i] = arr[j][i].size();
        }
    }
    //合并每行
    Array<std::string, H> ret;
    for (size_t i = 0; i < W; ++i)
    {
        std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
        for (size_t j = 0; j < H; ++j)
        {
            ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
        }
    }
    return ret;
}

std::vector<std::string> FormatString2(const Vector2<std::string>& arr);

inline std::string_view GetBeginUntilNumber(std::string_view str)
{
    size_t i = 0;
    while (i < str.size() && !std::isdigit((unsigned char)str[i]))
    {
        ++i;
    }
    return str.substr(0, i);
}
 
//----------------------------其余范围操作封装----------------------------
inline bool IsSub(std::string_view str, std::string_view str_sub)
{
    return Sub::IsSub(str, str_sub);
}
 
inline bool IsBegin(std::string_view str, std::string_view str_sub)
{
    return Sub::IsBegin(str, str_sub);
}
inline std::string_view Range(std::string_view str, char a, char b)
{
    return Sub::Range(str, a, b);
}
 
}
 
}
 
 
namespace dl
{
 
 
inline std::string to_string(const Vector2<std::string>& vec2)
{
    return String::Splicing(String::FormatString2(vec2), "\n");
}
 
 
//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
//* @brief array的format特化
//* @note 
//*/
//template<typename T, size_t N, typename CharT>
//struct std::formatter<Array<T, N>, CharT> : std::formatter<std::string, CharT>
//{
//  template <typename FormatParseContext>
//  auto parse(FormatParseContext& pc)
//  {
//      return pc.end();
//  }
//
//  template<typename FormatContext>
//  auto format(array<T, N> t, FormatContext& fc)
//  {
//      if constexpr (N == 2)
//          return std::formatter<std::string, CharT>::format(
//              std::format("{}, {}", t[0], t[1]), fc);
//      if constexpr (N == 3)
//          return std::formatter<std::string, CharT>::format(
//              std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
//      if constexpr (N == 4)
//          return std::formatter<std::string, CharT>::format(
//              std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
//  }
//};
//#endif
}
 
 
 
 
 
namespace fmt
{
    //
    template <typename T>
    struct formatter<dl::Array<T, 2>>
    {
        // 解析格式化参数（这里简化，不处理自定义格式）
        constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
        {
            // 检查是否有多余的格式符
            auto it = ctx.begin();
            if (it != ctx.end() && *it != '}')
                throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
            return it;
        }
 
        // 格式化逻辑
        template <typename FormatContext>
        auto format(const dl::Array<T, 2>& arr, FormatContext& ctx) const -> decltype(ctx.out())
        {
            return fmt::format_to(ctx.out(), "{}, {}", arr.x, arr.y);
        }
    };
 
    //
    template <typename T>
    struct formatter<dl::Array<T, 3>>
    {
        constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
        {
            auto it = ctx.begin();
            if (it != ctx.end() && *it != '}')
                throw fmt::format_error("invalid format specifier for dl::Array<T, 3>");
            return it;
        }
 
        template <typename FormatContext>
        auto format(const dl::Array<T, 3>& arr, FormatContext& ctx) const -> decltype(ctx.out())
        {
            return fmt::format_to(ctx.out(), "{}, {}, {}", arr.x, arr.y, arr.z);
        }
    };
 
    //
    template <typename T>
    struct formatter<dl::Array<T, 4>>
    {
        constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
        {
            auto it = ctx.begin();
            if (it != ctx.end() && *it != '}')
                throw fmt::format_error("invalid format specifier for dl::Array<T, 4>");
            return it;
        }
 
        template <typename FormatContext>
        auto format(const dl::Array<T, 4>& arr, FormatContext& ctx) const -> decltype(ctx.out())
        {
            return fmt::format_to(ctx.out(), "{}, {}, {}, {}", arr.x, arr.y, arr.z, arr.w);
        }
    };
    //
    template <size_t N>
    struct formatter<dl::StringN<N>>
    {
        // 解析格式化参数（这里简化，不处理自定义格式）
        constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
        {
            // 检查是否有多余的格式符
            auto it = ctx.begin();
            if (it != ctx.end() && *it != '}')
                throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
            return it;
        }
 
        // 格式化逻辑
        template <typename FormatContext>
        auto format(const dl::StringN<N>& str, FormatContext& ctx) const -> decltype(ctx.out())
        {
            return fmt::format_to(ctx.out(), "{}", str.c_str());
        }
    };
}