URI.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/String.hpp"
 
#include "CeresEngine/Math/Range.hpp"
 
namespace CeresEngine {
 
    class FilePath;
 
    class URI {
    private:
        using Part = TRange<std::size_t>;
 
        Part mScheme;
 
        Part mUserInfo;
 
        Part mHost;
 
        Part mPort;
 
        Part mPath;
 
        Part mQuery;
 
        Part mFragment;
 
        String mData;
 
    public:
        URI() = default;
 
        explicit URI(String raw);
 
        explicit URI(const StringView raw) : URI(String(raw)) {}
 
        CE_EXPLICIT(false) URI(const char* raw) : URI(String(raw)) {}
 
        explicit URI(const FilePath& path);
 
        explicit URI(const std::string_view raw) : URI(StringView(raw)) {}
 
        template<typename CharTraits, typename Allocator>
        explicit URI(const std::basic_string<char, CharTraits, Allocator>& raw) : URI(StringView(raw)) {}
 
        explicit URI(const StringView scheme, const StringView path, const StringView host = StringView(), const StringView port = StringView(), const StringView query = StringView(),
            const StringView fragment = StringView(), const StringView userInfo = StringView()) {
            mData.reserve(scheme.size() + host.size() + path.size() + port.size() + query.size() + fragment.size() + userInfo.size());
            setScheme(scheme);
            setUserInfo(userInfo);
            setHost(host);
            setPort(port);
            setPath(path);
            setQuery(query);
            setFragment(fragment);
        }
 
        explicit URI(const URI& absolute, const URI& relative) : URI(absolute.resolve(relative)) {}
 
        URI(const URI&) = default;
 
        URI& operator=(const URI&) = default;
 
        URI(URI&&) = default;
 
        URI& operator=(URI&&) = default;
 
    public: // URI parts
        [[nodiscard]] StringView getScheme() const noexcept { return get(mScheme); }
 
        void setScheme(const StringView scheme) { set(mScheme, scheme); }
 
        [[nodiscard]] bool hasScheme() const noexcept { return !mScheme.empty(); }
 
        void clearScheme() { setScheme(StringView()); }
 
        [[nodiscard]] StringView getUserInfo() const noexcept { return get(mUserInfo); }
 
        [[nodiscard]] bool isUserInfoNested() const noexcept { return isPartNested(mUserInfo); }
 
        void setUserInfo(const StringView userInfo) { set(mUserInfo, userInfo); }
 
        [[nodiscard]] bool hasUserInfo() const noexcept { return !mUserInfo.empty(); }
 
        void clearUserInfo() { setUserInfo(StringView()); }
 
        [[nodiscard]] StringView getHost() const noexcept { return get(mHost); }
 
        [[nodiscard]] bool isHostNested() const noexcept { return isPartNested(mHost); }
 
        void setHost(const StringView host) { set(mHost, host); }
 
        [[nodiscard]] bool hasHost() const noexcept { return !mHost.empty(); }
 
        void clearHost() { setHost(StringView()); }
 
        [[nodiscard]] StringView getPort() const noexcept { return get(mPort); }
 
        [[nodiscard]] bool isPortNested() const noexcept { return isPartNested(mPort); }
 
        void setPort(const StringView port) { set(mPort, port); }
 
        [[nodiscard]] bool hasPort() const noexcept { return !mPort.empty(); }
 
        void clearPort() { setPort(StringView()); }
 
        [[nodiscard]] StringView getPath() const noexcept { return get(mPath); }
 
        [[nodiscard]] bool isPathNested() const noexcept { return isPartNested(mPath); }
 
        void setPath(const StringView path) { set(mPath, path); }
 
        [[nodiscard]] bool hasPath() const noexcept { return !mPath.empty(); }
 
        void clearPath() { setPath(StringView()); }
 
        [[nodiscard]] StringView getQuery() const noexcept { return get(mQuery); }
 
        [[nodiscard]] bool isQueryNested() const noexcept { return isPartNested(mQuery); }
 
        void setQuery(const StringView query) { set(mQuery, query); }
 
        [[nodiscard]] bool hasQuery() const noexcept { return !mQuery.empty(); }
 
        void clearQuery() { setQuery(StringView()); }
 
        [[nodiscard]] StringView getFragment() const noexcept { return get(mFragment); }
 
        [[nodiscard]] bool isFragmentNested() const noexcept { return isPartNested(mFragment); }
 
        void setFragment(const StringView fragment) { set(mFragment, fragment); }
 
        [[nodiscard]] bool hasFragment() const noexcept { return !mFragment.empty(); }
 
        void clearFragment() { setFragment(StringView()); }
 
    public:
        [[nodiscard]] String toString() const;
 
        [[nodiscard]] bool isRelative() const noexcept { return mScheme.empty(); }
 
        [[nodiscard]] bool isAbsolute() const noexcept { return !mScheme.empty(); }
 
        [[nodiscard]] bool isNested() const noexcept;
 
        void clear() noexcept;
 
        [[nodiscard]] bool isEmpty() const noexcept;
 
        [[nodiscard]] URI resolve(const URI& relative) const;
 
        [[nodiscard]] URI canonicalize() const;
 
    public: // STL compatibility
        [[nodiscard]] bool empty() const noexcept { return isEmpty(); }
 
    private:
        [[nodiscard]] bool tryParse(String string);
 
        [[nodiscard]] StringView get(const Part& part) const noexcept {
            const StringView view = StringView(mData);
            return view.substr(part.offset, part.length);
        }
 
        void set(const Part& part, StringView newContent);
 
        [[nodiscard]] bool isPartNested(const Part& part) const noexcept {
            const StringView string = get(part);
            return string.starts_with('[') && string.ends_with(']');
        }
    };
 
    inline bool operator==(const URI& lhs, const URI& rhs) noexcept {
        return toCaseInsensitive(lhs.getScheme()) == toCaseInsensitive(rhs.getScheme()) //
            && lhs.getUserInfo() == rhs.getUserInfo() //
            && lhs.getHost() == rhs.getHost() //
            && lhs.getPort() == rhs.getPort() //
            && lhs.getPath() == rhs.getPath() //
            && lhs.getQuery() == rhs.getQuery() //
            && lhs.getFragment() == rhs.getFragment();
    }
 
    inline bool operator!=(const URI& lhs, const URI& rhs) noexcept {
        return toCaseInsensitive(lhs.getScheme()) != toCaseInsensitive(rhs.getScheme()) //
            || lhs.getUserInfo() != rhs.getUserInfo() //
            || lhs.getHost() != rhs.getHost() //
            || lhs.getPort() != rhs.getPort() //
            || lhs.getPath() != rhs.getPath() //
            || lhs.getQuery() != rhs.getQuery() //
            || lhs.getFragment() != rhs.getFragment();
    }
 
} // namespace CeresEngine