UriComponents.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_RESOURCE__URI_COMPONENTS
#define COM_BORA_SOFTWARE__BALAU_RESOURCE__URI_COMPONENTS

#include <Balau/Dev/Assert.hpp>
#include <Balau/Type/ToString.hpp>

namespace Balau::Resource {

class Uri;

struct UriComponents {
    public: static std::string normalizePath(std::string_view path);

    public: const std::string & getUri() const {
        return uri;
    }

    public: explicit UriComponents(const Uri & uri_);

    public: explicit UriComponents(std::string uri_);

    public: UriComponents(const UriComponents & ) = default;

    public: UriComponents(UriComponents && ) = default;

    public: UriComponents & operator = (const UriComponents & ) = default;

    public: UriComponents & operator = (UriComponents && ) = default;

    public: bool hasAuthority() const {
        return hostOffset != -1;
    }

    public: bool hasUserInfo() const {
        return userinfoOffset != -1;
    }

    public: bool hasHost() const {
        return hostOffset != -1;
    }

    public: bool hasPort() const {
        return portOffset != -1;
    }

    public: bool hasQuery() const {
        return queryOffset != -1;
    }

    public: bool hasFragment() const {
        return fragmentOffset != -1;
    }

    public: std::string_view scheme() const {
        return std::string_view(uri.c_str(), (size_t) schemeEndOffset);
    }

    public: std::string_view userInfo() const {
        if (!hasUserInfo()) {
            return std::string_view();
        }

        const int endOffset = hostOffset - 1; // "@"
        Assert::assertion(endOffset > 0);
        return std::string_view(uri.c_str() + userinfoOffset, (size_t) (endOffset - userinfoOffset));
    }

    public: std::string_view host() const {
        if (!hasHost()) {
            return std::string_view();
        }

        const int endOffset = hasPort()
            ? portOffset - 1 // ":"
            : pathOffset;

        Assert::assertion(endOffset > 0);
        return std::string_view(uri.c_str() + hostOffset, (size_t) (endOffset - hostOffset));
    }

    public: unsigned short port() const {
        return parsedPort;
    }

    public: std::string_view path() const {
        const int endOffset = hasQuery()
            ? queryOffset - 1 // "?"
            : hasFragment()
            ? fragmentOffset - 1 // "#"
            : (int) uri.length();

        Assert::assertion(endOffset > 0);
        return std::string_view(uri.c_str() + pathOffset, (size_t) (endOffset - pathOffset));
    }

    public: std::string_view query() const {
        if (!hasQuery()) {
            return std::string_view();
        }

        const int endOffset = hasFragment()
            ? fragmentOffset - 1 // "#"
            : (int) uri.length();

        Assert::assertion(endOffset > 0);
        return std::string_view(uri.c_str() + queryOffset, (size_t) (endOffset - queryOffset));
    }

    public: std::string_view fragment() const {
        if (!hasFragment()) {
            return std::string_view();
        }

        return std::string_view(uri.c_str() + fragmentOffset, (size_t) (uri.length() - fragmentOffset));
    }

    public: std::string_view pathQueryFragment() const {
        return std::string_view(uri.c_str() + pathOffset, (size_t) (uri.length() - pathOffset));
    }


    friend struct UriComponentsTest;

    // For testing.
    private: UriComponents(std::string uri_,
                           short schemeEndOffset_,
                           short userinfoOffset_,
                           short hostOffset_,
                           short portOffset_,
                           short pathOffset_,
                           short queryOffset_,
                           short fragmentOffset_,
                           unsigned short parsedPort_)
        : uri(std::move(uri_))
        , schemeEndOffset(schemeEndOffset_)
        , userinfoOffset(userinfoOffset_)
        , hostOffset(hostOffset_)
        , portOffset(portOffset_)
        , pathOffset(pathOffset_)
        , queryOffset(queryOffset_)
        , fragmentOffset(fragmentOffset_)
        , parsedPort(parsedPort_) {}

    private: std::string uri;
    private: short schemeEndOffset;
    private: short userinfoOffset;
    private: short hostOffset;
    private: short portOffset;
    private: short pathOffset;
    private: short queryOffset;
    private: short fragmentOffset;
    private: unsigned short parsedPort;

    friend bool operator == (const UriComponents & lhs, const UriComponents & rhs);
};

inline bool operator == (const UriComponents & lhs, const UriComponents & rhs) {
    return lhs.uri == rhs.uri;
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const UriComponents & uriComponents) {
    return toString<AllocatorT>(uriComponents.getUri());
}

inline std::string toString(const UriComponents & uriComponents) {
    return uriComponents.getUri();
}

} // namespace Balau::Resource

#endif // COM_BORA_SOFTWARE__BALAU_RESOURCE__URI_COMPONENTS