base_uri.h

/***
* ==++==
*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* Protocol independent support for URIs.
*
* For the latest on this and related APIs, please see http://casablanca.codeplex.com.
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/

#pragma once

#include <map>
#include <memory>
#include <string>
#include <vector>
#include <functional>

#include "cpprest/asyncrt_utils.h"
#include "cpprest/details/basic_types.h"

namespace web {
    namespace details
    {
        struct uri_components
        {
            uri_components() : m_path(_XPLATSTR("/")), m_port(-1)
            {}

            uri_components(const uri_components &other) :
                m_scheme(other.m_scheme),
                m_host(other.m_host),
                m_user_info(other.m_user_info),
                m_path(other.m_path),
                m_query(other.m_query),
                m_fragment(other.m_fragment),
                m_port(other.m_port)
            {}

            uri_components & operator=(const uri_components &other)
            {
                if (this != &other)
                {
                    m_scheme = other.m_scheme;
                    m_host = other.m_host;
                    m_user_info = other.m_user_info;
                    m_path = other.m_path;
                    m_query = other.m_query;
                    m_fragment = other.m_fragment;
                    m_port = other.m_port;
                }
                return *this;
            }

            uri_components(uri_components &&other) CPPREST_NOEXCEPT :
                m_scheme(std::move(other.m_scheme)),
                m_host(std::move(other.m_host)),
                m_user_info(std::move(other.m_user_info)),
                m_path(std::move(other.m_path)),
                m_query(std::move(other.m_query)),
                m_fragment(std::move(other.m_fragment)),
                m_port(other.m_port)
            {}

            uri_components & operator=(uri_components &&other) CPPREST_NOEXCEPT
            {
                if (this != &other)
                {
                    m_scheme = std::move(other.m_scheme);
                    m_host = std::move(other.m_host);
                    m_user_info = std::move(other.m_user_info);
                    m_path = std::move(other.m_path);
                    m_query = std::move(other.m_query);
                    m_fragment = std::move(other.m_fragment);
                    m_port = other.m_port;
                }
                return *this;
            }

            _ASYNCRTIMP utility::string_t join();

            utility::string_t m_scheme;
            utility::string_t m_host;
            utility::string_t m_user_info;
            utility::string_t m_path;
            utility::string_t m_query;
            utility::string_t m_fragment;
            int m_port;
        };
    }

    class uri_exception : public std::exception
    {
    public:

        uri_exception(std::string msg) : m_msg(std::move(msg)) {}

        ~uri_exception() CPPREST_NOEXCEPT {}

        const char* what() const CPPREST_NOEXCEPT
        {
            return m_msg.c_str();
        }

    private:
        std::string m_msg;
    };

    class uri
    {
    public:

        class components
        {
        public:
            enum component
            {
                user_info,
                host,
                path,
                query,
                fragment,
                full_uri
            };
        };

        _ASYNCRTIMP static utility::string_t __cdecl encode_uri(const utility::string_t &raw, uri::components::component = components::full_uri);

        _ASYNCRTIMP static utility::string_t __cdecl encode_data_string(const utility::string_t &utf8data);

        _ASYNCRTIMP static utility::string_t __cdecl decode(const utility::string_t &encoded);

        _ASYNCRTIMP static std::vector<utility::string_t> __cdecl split_path(const utility::string_t &path);

        _ASYNCRTIMP static std::map<utility::string_t, utility::string_t> __cdecl split_query(const utility::string_t &query);

        _ASYNCRTIMP static bool __cdecl validate(const utility::string_t &uri_string);

        uri() { m_uri = _XPLATSTR("/");};

        _ASYNCRTIMP uri(const utility::char_t *uri_string);

        _ASYNCRTIMP uri(const utility::string_t &uri_string);

        uri(const uri &other) :
            m_uri(other.m_uri),
            m_components(other.m_components)
        {}

        uri & operator=(const uri &other)
        {
            if (this != &other)
            {
                m_uri = other.m_uri;
                m_components = other.m_components;
            }
            return *this;
        }

        uri(uri &&other) CPPREST_NOEXCEPT :
            m_uri(std::move(other.m_uri)),
            m_components(std::move(other.m_components))
        {}

        uri & operator=(uri &&other) CPPREST_NOEXCEPT
        {
            if (this != &other)
            {
                m_uri = std::move(other.m_uri);
                m_components = std::move(other.m_components);
            }
            return *this;
        }

        const utility::string_t &scheme() const { return m_components.m_scheme; }

        const utility::string_t &user_info() const { return m_components.m_user_info; }

        const utility::string_t &host() const { return m_components.m_host; }

        int port() const { return m_components.m_port; }

        const utility::string_t &path() const { return m_components.m_path; }

        const utility::string_t &query() const { return m_components.m_query; }

        const utility::string_t &fragment() const { return m_components.m_fragment; }

        _ASYNCRTIMP uri authority() const;

        _ASYNCRTIMP uri resource() const;

        bool is_empty() const
        {
            return this->m_uri.empty() || this->m_uri == _XPLATSTR("/");
        }

        bool is_host_loopback() const
        {
            return !is_empty() && ((host() == _XPLATSTR("localhost")) || (host().size() > 4 && host().substr(0,4) == _XPLATSTR("127.")));
        }

        bool is_host_wildcard() const
        {
            return !is_empty() && (this->host() == _XPLATSTR("*") || this->host() == _XPLATSTR("+"));
        }

        bool is_host_portable() const
        {
            return !(is_empty() || is_host_loopback() || is_host_wildcard());
        }

        // <summary>
        bool is_port_default() const
        {
            return !is_empty() && this->port() == 0;
        }

        bool is_authority() const
        {
            return !is_empty() && is_path_empty() && query().empty() && fragment().empty();
        }

        bool has_same_authority(const uri &other) const
        {
            return !is_empty() && this->authority() == other.authority();
        }

        bool is_path_empty() const
        {
            return path().empty() || path() == _XPLATSTR("/");
        }

        utility::string_t to_string() const
        {
            return m_uri;
        }

        _ASYNCRTIMP bool operator == (const uri &other) const;

        bool operator < (const uri &other) const
        {
            return m_uri < other.m_uri;
        }

        bool operator != (const uri &other) const
        {
            return !(this->operator == (other));
        }

    private:
        friend class uri_builder;

        // Encodes all characters not in given set determined by given function.
        _ASYNCRTIMP static utility::string_t __cdecl encode_impl(const utility::string_t &raw, const std::function<bool __cdecl(int)>& should_encode);

        utility::string_t m_uri;
        details::uri_components m_components;
    };

} // namespace web