fields.hpp

Go to the documentation of this file.

//
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//

#ifndef BOOST_BEAST_HTTP_FIELDS_HPP
#define BOOST_BEAST_HTTP_FIELDS_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/core/string_param.hpp>
#include <boost/beast/core/string.hpp>
#include <boost/beast/core/detail/allocator.hpp>
#include <boost/beast/http/field.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/optional.hpp>
#include <algorithm>
#include <cctype>
#include <cstring>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>

namespace boost {
namespace beast {
namespace http {

template<class Allocator>
class basic_fields
{
    friend class fields_test; // for `header`

    static std::size_t constexpr max_static_buffer = 4096;

    using off_t = std::uint16_t;

public:
    using allocator_type = Allocator;

    class value_type
    {
        friend class basic_fields;

        boost::asio::const_buffer
        buffer() const;

        value_type(field name,
            string_view sname, string_view value);

        boost::intrusive::list_member_hook<
            boost::intrusive::link_mode<
                boost::intrusive::normal_link>>
                    list_hook_;
        boost::intrusive::set_member_hook<
            boost::intrusive::link_mode<
                boost::intrusive::normal_link>>
                    set_hook_;
        off_t off_;
        off_t len_;
        field f_;

    public:
        value_type(value_type const&) = delete;

        value_type& operator=(value_type const&) = delete;

        field
        name() const;

        string_view
        name_string() const;

        string_view
        value() const;
    };

    struct key_compare : beast::iless
    {
        template<class String>
        bool
        operator()(
            String const& lhs,
            value_type const& rhs) const noexcept
        {
            if(lhs.size() < rhs.name_string().size())
                return true;
            if(lhs.size() > rhs.name_string().size())
                return false;
            return iless::operator()(lhs, rhs.name_string());
        }

        template<class String>
        bool
        operator()(
            value_type const& lhs,
            String const& rhs) const noexcept
        {
            if(lhs.name_string().size() < rhs.size())
                return true;
            if(lhs.name_string().size() > rhs.size())
                return false;
            return iless::operator()(lhs.name_string(), rhs);
        }

        bool
        operator()(
            value_type const& lhs,
            value_type const& rhs) const noexcept
        {
            if(lhs.name_string().size() < rhs.name_string().size())
                return true;
            if(lhs.name_string().size() > rhs.name_string().size())
                return false;
            return iless::operator()(lhs.name_string(), rhs.name_string());
        }
    };

#if BOOST_BEAST_DOXYGEN
    using reader = implementation_defined;
#else
    class reader;
#endif

private:
    using list_t = typename boost::intrusive::make_list<
        value_type, boost::intrusive::member_hook<
            value_type, boost::intrusive::list_member_hook<
                boost::intrusive::link_mode<
                    boost::intrusive::normal_link>>,
                        &value_type::list_hook_>,
                            boost::intrusive::constant_time_size<
                                false>>::type;

    using set_t = typename boost::intrusive::make_multiset<
        value_type, boost::intrusive::member_hook<value_type,
            boost::intrusive::set_member_hook<
                boost::intrusive::link_mode<
                    boost::intrusive::normal_link>>,
                        &value_type::set_hook_>,
                            boost::intrusive::constant_time_size<true>,
                                boost::intrusive::compare<key_compare>>::type;


public:
    ~basic_fields();

    basic_fields() = default;

    explicit
    basic_fields(Allocator const& alloc);

    basic_fields(basic_fields&&);

    basic_fields(basic_fields&&, Allocator const& alloc);

    basic_fields(basic_fields const&);

    basic_fields(basic_fields const&, Allocator const& alloc);

    template<class OtherAlloc>
    basic_fields(basic_fields<OtherAlloc> const&);

    template<class OtherAlloc>
    basic_fields(basic_fields<OtherAlloc> const&,
        Allocator const& alloc);

    basic_fields& operator=(basic_fields&&);

    basic_fields& operator=(basic_fields const&);

    template<class OtherAlloc>
    basic_fields& operator=(basic_fields<OtherAlloc> const&);

public:
#if BOOST_BEAST_DOXYGEN
    using const_iterator = implementation_defined;
#else
    using const_iterator = typename list_t::const_iterator;
#endif

    using iterator = const_iterator;

    allocator_type
    get_allocator() const
    {
        return alloc_;
    }

    //--------------------------------------------------------------------------
    //
    // Element access
    //
    //--------------------------------------------------------------------------

    string_view
    at(field name) const;

    string_view
    at(string_view name) const;

    string_view
    operator[](field name) const;

    string_view
    operator[](string_view name) const;

    //--------------------------------------------------------------------------
    //
    // Iterators
    //
    //--------------------------------------------------------------------------

    const_iterator
    begin() const
    {
        return list_.cbegin();
    }

    const_iterator
    end() const
    {
        return list_.cend();
    }

    const_iterator
    cbegin() const
    {
        return list_.cbegin();
    }

    const_iterator
    cend() const
    {
        return list_.cend();
    }

    //--------------------------------------------------------------------------
    //
    // Capacity
    //
    //--------------------------------------------------------------------------

private:
    // VFALCO Since the header and message derive from Fields,
    //        what does the expression m.empty() mean? Its confusing.
    bool
    empty() const
    {
        return list_.empty();
    }
public:

    //--------------------------------------------------------------------------
    //
    // Modifiers
    //
    //--------------------------------------------------------------------------

private:
    // VFALCO But this leaves behind the method, target, and reason!
    void
    clear();
public:

    void
    insert(field name, string_param const& value);

    void
    insert(string_view name, string_param const& value);

    void
    insert(field name, string_view name_string,
        string_param const& value);

    void
    set(field name, string_param const& value);

    void
    set(string_view name, string_param const& value);

    const_iterator
    erase(const_iterator pos);

    std::size_t
    erase(field name);

    std::size_t
    erase(string_view name);

    void
    swap(basic_fields& other);

    template<class Alloc>
    friend
    void
    swap(basic_fields<Alloc>& lhs, basic_fields<Alloc>& rhs);

    //--------------------------------------------------------------------------
    //
    // Lookup
    //
    //--------------------------------------------------------------------------

    std::size_t
    count(field name) const;

    std::size_t
    count(string_view name) const;

    const_iterator
    find(field name) const;

    const_iterator
    find(string_view name) const;

    std::pair<const_iterator, const_iterator>
    equal_range(field name) const;

    std::pair<const_iterator, const_iterator>
    equal_range(string_view name) const;

    //--------------------------------------------------------------------------
    //
    // Observers
    //
    //--------------------------------------------------------------------------

    key_compare
    key_comp() const
    {
        return key_compare{};
    }

protected:
    string_view
    get_method_impl() const;

    string_view
    get_target_impl() const;

    string_view
    get_reason_impl() const;

    bool
    get_chunked_impl() const;

    bool
    get_keep_alive_impl(unsigned version) const;

    void
    set_method_impl(string_view s);

    void
    set_target_impl(string_view s);

    void
    set_reason_impl(string_view s);

    void
    set_chunked_impl(bool value);

    void
    set_content_length_impl(
        boost::optional<std::uint64_t> const& value);

    void
    set_keep_alive_impl(
        unsigned version, bool keep_alive);

private:
    template<class OtherAlloc>
    friend class basic_fields;

    using base_alloc_type = typename
        beast::detail::allocator_traits<Allocator>::
            template rebind_alloc<value_type>;

    using alloc_traits =
        beast::detail::allocator_traits<base_alloc_type>;

    using size_type = typename
        beast::detail::allocator_traits<Allocator>::size_type;

    value_type&
    new_element(field name,
        string_view sname, string_view value);

    void
    delete_element(value_type& e);

    void
    set_element(value_type& e);

    void
    realloc_string(string_view& dest, string_view s);

    void
    realloc_target(
        string_view& dest, string_view s);

    template<class OtherAlloc>
    void
    copy_all(basic_fields<OtherAlloc> const&);

    void
    clear_all();

    void
    delete_list();

    void
    move_assign(basic_fields&, std::true_type);

    void
    move_assign(basic_fields&, std::false_type);

    void
    copy_assign(basic_fields const&, std::true_type);

    void
    copy_assign(basic_fields const&, std::false_type);

    void
    swap(basic_fields& other, std::true_type);

    void
    swap(basic_fields& other, std::false_type);

    base_alloc_type alloc_;
    set_t set_;
    list_t list_;
    string_view method_;
    string_view target_or_reason_;
};

using fields = basic_fields<std::allocator<char>>;

} // http
} // beast
} // boost

#include <boost/beast/http/impl/fields.ipp>

#endif