URI.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
 
#include <aws/core/http/Scheme.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/StringUtils.h>
 
#include <stdint.h>
 
namespace Aws
{
    namespace Http
    {
        extern AWS_CORE_API const char* SEPARATOR;
        static const uint16_t HTTP_DEFAULT_PORT = 80;
        static const uint16_t HTTPS_DEFAULT_PORT = 443;
 
        extern bool s_compliantRfc3986Encoding;
        AWS_CORE_API void SetCompliantRfc3986Encoding(bool compliant);
 
        extern AWS_CORE_API bool s_preservePathSeparators;
        AWS_CORE_API void SetPreservePathSeparators(bool preservePathSeparators);
 
        //per https://tools.ietf.org/html/rfc3986#section-3.4 there is nothing preventing servers from allowing
        //multiple values for the same key. So use a multimap instead of a map.
        typedef Aws::MultiMap<Aws::String, Aws::String> QueryStringParameterCollection;
 
        class AWS_CORE_API URI
        {
        public:
            URI();
            URI(const Aws::String&);
            URI(const char*);
 
            URI& operator = (const Aws::String&);
            URI& operator = (const char*);
 
            bool operator == (const URI&) const;
            bool operator == (const Aws::String&) const;
            bool operator == (const char*) const;
            bool operator != (const URI&) const;
            bool operator != (const Aws::String&) const;
            bool operator != (const char*) const;
 
            inline Scheme GetScheme() const { return m_scheme; }
 
            void SetScheme(Scheme value);
 
            inline const Aws::String& GetAuthority() const { return m_authority; }
 
            inline void SetAuthority(const Aws::String& value) { m_authority = value; }
 
            inline uint16_t GetPort() const { return m_port; }
 
            inline void SetPort(uint16_t value) { m_port = value; }
 
            Aws::String GetPath() const;
 
            Aws::String GetURLEncodedPath() const;
 
            Aws::String GetURLEncodedPathRFC3986() const;
 
            void SetPath(const Aws::String& value);
 
            template<typename T>
            inline void AddPathSegment(T pathSegment)
            {
                Aws::StringStream ss;
                ss << pathSegment;
                Aws::String segment = ss.str();
                segment.erase(0, segment.find_first_not_of('/'));
                segment.erase(segment.find_last_not_of('/') + 1);
                m_pathSegments.push_back(segment);
                m_pathHasTrailingSlash = false;
            }
 
            template<typename T>
            inline void AddPathSegments(T pathSegments)
            {
                Aws::StringStream ss;
                ss << pathSegments;
                Aws::String segments = ss.str();
                const auto splitOption = s_preservePathSeparators
                                           ? Utils::StringUtils::SplitOptions::INCLUDE_EMPTY_SEGMENTS
                                           : Utils::StringUtils::SplitOptions::NOT_SET;
                // Preserve legacy behavior -- we need to remove a leading "/" if use `INCLUDE_EMPTY_SEGMENTS` is specified
                // because string split will no longer ignore leading delimiters -- which is correct.
                auto split = Aws::Utils::StringUtils::Split(segments, '/', splitOption);
                if (s_preservePathSeparators && m_pathSegments.empty() && !split.empty() && split.front().empty() && !m_pathHasTrailingSlash) {
                  split.erase(split.begin());
                }
                for (const auto& segment: split)
                {
                    m_pathSegments.push_back(segment);
                }
                m_pathHasTrailingSlash = (!segments.empty() && segments.back() == '/');
            }
 
            inline const Aws::String& GetQueryString() const { return m_queryString; }
 
            void SetQueryString(const Aws::String& str);
 
            Aws::String GetFormParameters() const;
 
            void CanonicalizeQueryString();
 
            QueryStringParameterCollection GetQueryStringParameters(bool decode = true) const;
 
            void AddQueryStringParameter(const char* key, const Aws::String& value);
 
            void AddQueryStringParameter(const Aws::Map<Aws::String, Aws::String>& queryStringPairs);
 
            Aws::String GetURIString(bool includeQueryString = true) const;
 
            inline bool IsRfc3986Encoded() const { return m_useRfcEncoding; }
 
            inline void SetRfc3986Encoded(const bool value) { m_useRfcEncoding = value; }
 
            static Aws::String URLEncodePath(const Aws::String& path);
 
            static Aws::String URLEncodePathRFC3986(const Aws::String& path, bool rfcCompliantEncoding = false);
 
            Aws::String GetHost() const;
 
        private:
            void ParseURIParts(const Aws::String& uri);
            void ExtractAndSetScheme(const Aws::String& uri);
            void ExtractAndSetAuthority(const Aws::String& uri);
            void ExtractAndSetPort(const Aws::String& uri);
            void ExtractAndSetPath(const Aws::String& uri);
            void ExtractAndSetQueryString(const Aws::String& uri);
            bool CompareURIParts(const URI& other) const;
 
            Scheme m_scheme = Scheme::HTTP;
            Aws::String m_authority;
            uint16_t m_port = HTTP_DEFAULT_PORT;
            Aws::Vector<Aws::String> m_pathSegments;
            bool m_pathHasTrailingSlash = false;
            bool m_useRfcEncoding = false;
            Aws::String m_queryString;
        };
 
    } // namespace Http
} // namespace Aws