StringPath.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Foundation/StringSpan.h"
 
namespace SC
{
 
namespace detail
{
template <int N>
struct StringNativeFixed
{
    size_t        length = 0;
    native_char_t buffer[N];
 
    [[nodiscard]] auto view() const { return StringSpan({buffer, length}, true, StringEncoding::Native); }
    [[nodiscard]] bool isEmpty() const { return length == 0; }
    [[nodiscard]] auto writableSpan() { return Span<native_char_t>{buffer, N}; }
    [[nodiscard]] bool operator==(StringSpan other) const { return view() == other; }
    [[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]] StringEncoding getEncoding() const { return StringEncoding::Native; }
 
    [[nodiscard]] bool isEmpty() const { return path.view().isEmpty(); }
    [[nodiscard]] bool append(StringSpan str) { return path.append(str); }
    [[nodiscard]] bool assign(StringSpan str) { return path.assign(str); }
    [[nodiscard]] bool resize(size_t newSize);
 
    [[nodiscard]] Span<native_char_t> writableSpan() { return path.writableSpan(); }
 
  private:
    detail::StringNativeFixed<MaxPath> path;
};
 
template <>
struct SC_COMPILER_EXPORT GrowableBuffer<StringPath> : public IGrowableBuffer
{
    StringPath& sp;
    GrowableBuffer(StringPath& string) noexcept;
    ~GrowableBuffer() noexcept;
    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept;
    static auto getEncodingFor(const StringPath& sp) noexcept { return sp.getEncoding(); }
    void        finalize() noexcept;
};
} // namespace SC