Path.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Strings/StringView.h"
 
namespace SC
{
struct String;
 
 
struct SC_COMPILER_EXPORT Path
{
    enum Type
    {
        AsPosix,
        AsWindows,
#if SC_PLATFORM_WINDOWS
        AsNative = AsWindows
#else
        AsNative = AsPosix
#endif
    };
    struct ParsedView
    {
        bool endsWithSeparator = false;
 
        // TODO: ParsedView::directory and base are not defined consistently
 
        Type       type = AsPosix; 
        StringView root;           
        StringView directory;      
        StringView base;           
        StringView name;           
        StringView ext;            
 
        [[nodiscard]] bool parseWindows(StringView input);
 
        [[nodiscard]] bool parsePosix(StringView input);
    };
 
    template <typename T>
    [[nodiscard]] static bool join(T& output, Span<const StringView> inputs,
                                   StringView separator = SeparatorStringView(), bool skipEmpty = false)
    {
        return join(GrowableBuffer<T>{output}, output.getEncoding(), inputs, separator, skipEmpty);
    }
 
    [[nodiscard]] static bool join(IGrowableBuffer&& output, StringEncoding encoding, Span<const StringView> inputs,
                                   StringView separator = SeparatorStringView(), bool skipEmpty = false);
    [[nodiscard]] static bool parseNameExtension(const StringView input, StringView& name, StringView& extension);
 
    [[nodiscard]] static bool parse(StringView input, Path::ParsedView& pathView, Type type);
 
    [[nodiscard]] static StringView dirname(StringView input, Type type, int repeat = 0);
 
    [[nodiscard]] static StringView basename(StringView input, Type type);
 
    [[nodiscard]] static StringView basename(StringView input, StringView suffix);
 
    [[nodiscard]] static bool isAbsolute(StringView input, Type type);
 
    struct Windows
    {
        static const char Separator = '\\';
 
        [[nodiscard]] static constexpr StringView SeparatorStringView() { return "\\"_a8; };
    };
 
    struct Posix
    {
        static const char Separator = '/';
 
        [[nodiscard]] static constexpr StringView SeparatorStringView() { return "/"_a8; }
    };
 
#if SC_PLATFORM_WINDOWS
    static constexpr char Separator = '\\';
#else
    static constexpr char Separator = '/';
#endif
 
#if SC_PLATFORM_WINDOWS
    [[nodiscard]] static constexpr StringView SeparatorStringView() { return "\\"_a8; };
#else
    [[nodiscard]] static constexpr StringView SeparatorStringView() { return "/"_a8; }
#endif
 
    template <typename T, int numComponents = 64>
    [[nodiscard]] static bool normalize(T& output, StringView view, Type type)
    {
        StringView components[numComponents];
        return normalize(GrowableBuffer<T>{output}, output.getEncoding(), view, type, components);
    }
 
    [[nodiscard]] static bool normalize(IGrowableBuffer&& output, StringEncoding encoding, StringView view, Type type,
                                        Span<StringView> components);
 
    template <typename T>
    [[nodiscard]] static bool relativeFromTo(T& output, StringView source, StringView destination, Type type,
                                             Type outputType = AsNative)
    {
        return relativeFromTo(GrowableBuffer<T>{output}, output.getEncoding(), source, destination, type, outputType);
    }
 
    [[nodiscard]] static bool relativeFromTo(IGrowableBuffer&& output, StringEncoding encoding, StringView source,
                                             StringView destination, Type type, Type outputType = AsNative);
 
    template <typename T>
    [[nodiscard]] static bool append(T& output, Span<const StringView> paths, Type inputType)
    {
        return append(GrowableBuffer<T>{output}, output.getEncoding(), paths, inputType);
    }
 
    [[nodiscard]] static bool append(IGrowableBuffer&& output, StringEncoding encoding, Span<const StringView> paths,
                                     Type inputType);
 
    [[nodiscard]] static bool endsWithSeparator(StringView path);
 
    [[nodiscard]] static StringView removeStartingSeparator(StringView path);
 
    template <typename T>
    [[nodiscard]] static bool normalizeUNCAndTrimQuotes(T& outputPath, StringView fileLocation, Type type,
                                                        Span<StringView> components)
    {
        return normalizeUNCAndTrimQuotes(GrowableBuffer<T>{outputPath}, outputPath.getEncoding(), fileLocation, type,
                                         components);
    }
    [[nodiscard]] static bool normalizeUNCAndTrimQuotes(IGrowableBuffer&& outputPath, StringEncoding encoding,
                                                        StringView fileLocation, Type type,
                                                        Span<StringView> components);
 
  private:
    [[nodiscard]] static StringView removeTrailingSeparator(StringView path);
    struct Internal;
};
 
} // namespace SC