StringPath.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/StringSpan.h"
 
namespace SC
{
 
namespace detail
{
template <int N>
struct StringNativeFixed
{
    size_t        length = 0;
    native_char_t buffer[N];
 
    [[nodiscard]] StringSpan view() const { return StringSpan({buffer, length}, true, StringEncoding::Native); }
 
    [[nodiscard]] Span<native_char_t> writableSpan() { return {buffer, N}; }
 
    [[nodiscard]] bool assign(StringSpan str)
    {
        length = 0;
        return append(str);
    }
 
    [[nodiscard]] bool append(StringSpan str)
    {
        StringSpan::NativeWritable string = {{buffer, N}, length};
        if (not str.appendNullTerminatedTo(string))
            return false;
        length = string.length;
        return true;
    }
};
} // namespace detail
 
struct SC_COMPILER_EXPORT StringPath
{
#if SC_PLATFORM_WINDOWS
    static constexpr size_t MaxPath = 260; // Equal to 'MAX_PATH' on Windows
#elif SC_PLATFORM_APPLE
    static constexpr size_t MaxPath = 1024; // Equal to 'PATH_MAX' on macOS
#else
    static constexpr size_t MaxPath = 4096; // Equal to 'PATH_MAX' on Linux
#endif
    [[nodiscard]] StringSpan view() const { return path.view(); }
 
    [[nodiscard]] bool append(StringSpan str) { return path.append(str); }
    [[nodiscard]] bool assign(StringSpan str) { return path.assign(str); }
    [[nodiscard]] bool resize(size_t newSize)
    {
        if (newSize < MaxPath)
        {
            path.length = newSize;
        }
        return newSize < MaxPath;
    }
 
    [[nodiscard]] Span<native_char_t> writableSpan() { return path.writableSpan(); }
 
  private:
    detail::StringNativeFixed<MaxPath> path;
};
} // namespace SC