uri_builder.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.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* Builder style class for creating URIs.
*
* For the latest on this and related APIs, please see http://casablanca.codeplex.com.
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/

#pragma once

#include <sstream>
#include <string>
#include <vector>

#include "cpprest/base_uri.h"
#include "cpprest/details/uri_parser.h"

namespace web
{
    class uri_builder
    {
    public:

        uri_builder() {}

        uri_builder(const uri &uri_str): m_uri(uri_str.m_components) {}

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

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

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

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

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

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

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

        uri_builder & set_scheme(const utility::string_t &scheme)
        {
            m_uri.m_scheme = scheme;
            return *this;
        }

        uri_builder & set_user_info(const utility::string_t &user_info, bool do_encoding = false)
        {
            m_uri.m_user_info = do_encoding ? uri::encode_uri(user_info, uri::components::user_info) : user_info;
            return *this;
        }

        uri_builder & set_host(const utility::string_t &host, bool do_encoding = false)
        {
            m_uri.m_host = do_encoding ? uri::encode_uri(host, uri::components::host) : host;
            return *this;
        }

        uri_builder & set_port(int port)
        {
            m_uri.m_port = port;
            return *this;
        }

        uri_builder & set_port(const utility::string_t &port)
        {
            utility::istringstream_t portStream(port);
            int port_tmp;
            portStream >> port_tmp;
            if(portStream.fail() || portStream.bad())
            {
                throw std::invalid_argument("invalid port argument, must be non empty string containing integer value");
            }
            m_uri.m_port = port_tmp;
            return *this;
        }

        uri_builder & set_path(const utility::string_t &path, bool do_encoding = false)
        {
            m_uri.m_path = do_encoding ? uri::encode_uri(path, uri::components::path) : path;
            return *this;
        }


        uri_builder & set_query(const utility::string_t &query, bool do_encoding = false)
        {
            m_uri.m_query = do_encoding ? uri::encode_uri(query, uri::components::query) : query;
            return *this;
        }

        uri_builder & set_fragment(const utility::string_t &fragment, bool do_encoding = false)
        {
            m_uri.m_fragment = do_encoding ? uri::encode_uri(fragment, uri::components::fragment) : fragment;
            return *this;
        }

        void clear()
        {
            m_uri = details::uri_components();
        }

        _ASYNCRTIMP uri_builder &append_path(const utility::string_t &path, bool do_encoding = false);

        _ASYNCRTIMP uri_builder &append_query(const utility::string_t &query, bool do_encoding = false);

        _ASYNCRTIMP uri_builder &append(const uri &relative_uri);

        template<typename T>
        uri_builder &append_query(const utility::string_t &name, const T &value, bool do_encoding = true)
        {
            auto encodedName = name;
            auto encodedValue = ::utility::conversions::print_string(value, std::locale::classic());

            if (do_encoding)
            {
                auto encodingCheck = [](int ch)
                {
                    switch (ch)
                    {
                        // Encode '&', ';', and '=' since they are used
                        // as delimiters in query component.
                    case '&':
                    case ';':
                    case '=':
                    case '%':
                    case '+':
                        return true;
                    default:
                        return !::web::details::uri_parser::is_query_character(ch);
                    }
                };
                encodedName = uri::encode_impl(encodedName, encodingCheck);
                encodedValue = uri::encode_impl(encodedValue, encodingCheck);
            }

            auto encodedQuery = encodedName;
            encodedQuery.append(_XPLATSTR("="));
            encodedQuery.append(encodedValue);
            // The query key value pair was already encoded by us or the user separately.
            return append_query(encodedQuery, false);
        }

        _ASYNCRTIMP utility::string_t to_string();

        _ASYNCRTIMP uri to_uri();

        _ASYNCRTIMP bool is_valid();

    private:
        details::uri_components m_uri;
    };
} // namespace web