buffer.hpp

// Copyright Takatoshi Kondo 2022
//
// 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)
 
#if !defined(ASYNC_MQTT_UTIL_BUFFER_HPP)
#define ASYNC_MQTT_UTIL_BUFFER_HPP
 
#include <string_view>
#include <memory>
 
 
#include <boost/asio/buffer.hpp>
#include <boost/container_hash/hash.hpp>
 
#include <async_mqtt/util/move.hpp>
#include <async_mqtt/util/detail/is_iterator.hpp>
 
namespace async_mqtt {
 
namespace as = boost::asio;
 
class buffer {
public:
    using life_type = std::shared_ptr<void>;
    using traits_type = std::string_view::traits_type;
    using value_type = std::string_view::value_type;
    using pointer = std::string_view::pointer;
    using const_pointer = std::string_view::const_pointer;
    using reference = std::string_view::reference;
    using const_reference = std::string_view::const_reference;
    using iterator = std::string_view::iterator;
    using const_iterator = std::string_view::const_iterator;
    using const_reverse_iterator = std::string_view::const_reverse_iterator;
    using reverse_iterator = std::string_view::reverse_iterator;
    using size_type = std::string_view::size_type;
    using difference_type = std::string_view::difference_type;
 
    static constexpr size_type npos = std::string_view::npos;
 
    constexpr buffer() noexcept = default;
 
    buffer(buffer const& other) = default;
 
    buffer(buffer&& other) = default;
 
    buffer& operator=(buffer const& other) = default;
 
    buffer& operator=(buffer&& other) = default;
 
    constexpr buffer(char const* s, std::size_t count)
        :view_{s, count}
    {}
 
    constexpr buffer(char const* s)
        :view_{s}
    {}
 
    template <
        typename It,
        typename End,
        typename std::enable_if_t<
            detail::is_input_iterator<It>::value &&
            detail::is_input_iterator<End>::value
        >* = nullptr
    >
    constexpr buffer(It first, End last)
        :view_{&*first, &*first + std::distance(first, last)}
    {}
 
    explicit constexpr buffer(std::string_view sv)
        : view_{force_move(sv)}
    {}
 
    explicit buffer(std::string s) {
        auto str = std::make_shared<std::string>(force_move(s));
        view_ = *str;
        life_ = force_move(str);
    }
 
    explicit buffer(std::string_view sv, std::shared_ptr<void> life)
        : view_{force_move(sv)},
          life_{force_move(life)}
    {}
 
    explicit buffer(char const* s, std::size_t count,std::shared_ptr<void> life)
        : view_{s, count},
          life_{force_move(life)}
    {}
 
    template <
        typename It,
        typename End,
        typename std::enable_if_t<
            detail::is_input_iterator<It>::value &&
            detail::is_input_iterator<End>::value
        >* = nullptr
    >
    explicit buffer(It first, End last, std::shared_ptr<void> life)
        : view_{&*first, static_cast<std::size_t>(std::distance(first, last))},
          life_{force_move(life)}
 
    {}
 
    constexpr const_iterator begin() const noexcept {
        return view_.begin();
    }
 
    constexpr const_iterator cbegin() const noexcept {
        return view_.cbegin();
    }
 
    constexpr const_iterator end() const noexcept {
        return view_.end();
    }
 
    constexpr const_iterator cend() const noexcept {
        return view_.cend();
    }
 
    constexpr const_reverse_iterator rbegin() const noexcept {
        return view_.rbegin();
    }
 
    constexpr const_reverse_iterator crbegin() const noexcept {
        return view_.crbegin();
    }
 
    constexpr const_reverse_iterator rend() const noexcept {
        return view_.rend();
    }
 
    constexpr const_reverse_iterator crend() const noexcept {
        return view_.crend();
    }
 
    constexpr const_reference operator[](size_type pos) const {
        return view_[pos];
    }
 
    constexpr const_reference at(size_type pos) const {
        return view_.at(pos);
    }
 
    constexpr const_reference front() const {
        return view_.front();
    }
 
    constexpr const_reference back() const {
        return view_.back();
    }
 
    constexpr const_pointer data() const noexcept {
        return view_.data();
    }
 
    constexpr size_type size() const noexcept {
        return view_.size();
    }
 
    constexpr size_type length() const noexcept {
        return view_.length();
    }
 
    constexpr size_type max_size() const noexcept {
        return view_.max_size();
    }
 
    constexpr bool empty() const noexcept {
        return view_.empty();
    }
 
    constexpr void remove_prefix(size_type n) {
        view_.remove_prefix(n);
    }
 
    constexpr void remove_suffix(size_type n) {
        view_.remove_suffix(n);
    }
 
    void swap(buffer& buf) noexcept {
        view_.swap(buf.view_);
        life_.swap(buf.life_);
    }
 
    size_type copy(char* dest, size_type count, size_type pos = 0 ) const {
        return view_.copy(dest, count, pos);
    }
 
    buffer substr(size_type pos = 0, size_type count = npos) const& {
        // range is checked in std::string_view::substr.
        return buffer(view_.substr(pos, count), life_);
    }
 
    buffer substr(size_type pos = 0, size_type count = npos) && {
        // range is checked in std::string_view::substr.
        return buffer(view_.substr(pos, count), force_move(life_));
    }
 
    constexpr int compare(buffer const& buf) const noexcept {
        return view_.compare(buf.view_);
    }
 
    constexpr int compare(std::string_view const& v) const noexcept {
        return view_.compare(v);
    }
 
    constexpr int compare(size_type pos1, size_type count1, buffer const& buf) const noexcept {
        return view_.compare(pos1, count1, buf.view_);
    }
 
    constexpr int compare(size_type pos1, size_type count1, std::string_view const& v) const noexcept {
        return view_.compare(pos1, count1, v);
    }
 
    constexpr int compare(
        size_type pos1,
        size_type count1,
        buffer const& buf,
        size_type pos2,
        size_type count2
    ) const noexcept {
        return view_.compare(pos1, count1, buf.view_, pos2, count2);
    }
 
    constexpr int compare(
        size_type pos1,
        size_type count1,
        std::string_view const& v,
        size_type pos2,
        size_type count2
    ) const noexcept {
        return view_.compare(pos1, count1, v, pos2, count2);
    }
 
    constexpr int compare(char const* s) const noexcept {
        return view_.compare(s);
    }
 
    constexpr int compare(size_type pos1, size_type count1, char const* s) const noexcept {
        return view_.compare(pos1, count1, s);
    }
 
    constexpr int compare(
        size_type pos1,
        size_type count1,
        char const* s,
        size_type pos2,
        size_type count2
    ) const noexcept {
        return view_.compare(pos1, count1, s, pos2, count2);
    }
 
    constexpr size_type find(buffer const& buf, size_type pos = 0) const noexcept {
        return view_.find(buf.view_, pos);
    }
 
    constexpr size_type find(std::string_view v, size_type pos = 0) const noexcept {
        return view_.find(v, pos);
    }
 
    constexpr size_type find(char ch, size_type pos = 0) const noexcept {
        return view_.find(ch, pos);
    }
 
    constexpr size_type find(char const* s, size_type pos, size_type count) const {
        return view_.find(s, pos, count);
    }
 
    constexpr size_type find(char const* s, size_type pos = 0) const {
        return view_.find(s, pos);
    }
 
    constexpr size_type rfind(buffer const& buf, size_type pos = npos) const noexcept {
        return view_.rfind(buf.view_, pos);
    }
 
    constexpr size_type rfind( std::string_view v, size_type pos = npos) const noexcept {
        return view_.rfind(v, pos);
    }
 
    constexpr size_type rfind(char ch, size_type pos = npos) const noexcept {
        return view_.rfind(ch, pos);
    }
 
    constexpr size_type rfind(char const* s, size_type pos, size_type count) const {
        return view_.rfind(s, pos, count);
    }
 
    constexpr size_type rfind(char const* s, size_type pos = npos) const {
        return view_.rfind(s, pos);
    }
 
    constexpr size_type find_first_of(buffer const& buf, size_type pos = 0) const noexcept {
        return view_.find_first_of(buf.view_, pos);
    }
 
    constexpr size_type find_first_of( std::string_view v, size_type pos = 0) const noexcept {
        return view_.find_first_of(v, pos);
    }
 
    constexpr size_type find_first_of(char ch, size_type pos = 0) const noexcept {
        return view_.find_first_of(ch, pos);
    }
 
    constexpr size_type find_first_of(char const* s, size_type pos, size_type count) const {
        return view_.find_first_of(s, pos, count);
    }
 
    constexpr size_type find_first_of(char const* s, size_type pos = 0) const {
        return view_.find_first_of(s, pos);
    }
 
    constexpr size_type find_last_of(buffer const& buf, size_type pos = npos) const noexcept {
        return view_.find_last_of(buf.view_, pos);
    }
 
    constexpr size_type find_last_of( std::string_view v, size_type pos = npos) const noexcept {
        return view_.find_last_of(v, pos);
    }
 
    constexpr size_type find_last_of(char ch, size_type pos = npos) const noexcept {
        return view_.find_last_of(ch, pos);
    }
 
    constexpr size_type find_last_of(char const* s, size_type pos, size_type count) const {
        return view_.find_last_of(s, pos, count);
    }
    constexpr size_type find_last_of(char const* s, size_type pos = npos) const {
        return view_.find_last_of(s, pos);
    }
 
    constexpr size_type find_first_not_of(buffer const& buf, size_type pos = 0) const noexcept {
        return view_.find_first_not_of(buf.view_, pos);
    }
 
    constexpr size_type find_first_not_of( std::string_view v, size_type pos = 0) const noexcept {
        return view_.find_first_not_of(v, pos);
    }
 
    constexpr size_type find_first_not_of(char ch, size_type pos = 0) const noexcept {
        return view_.find_first_not_of(ch, pos);
    }
 
    constexpr size_type find_first_not_of(char const* s, size_type pos, size_type count) const {
        return view_.find_first_not_of(s, pos, count);
    }
 
    constexpr size_type find_first_not_of(char const* s, size_type pos = 0) const {
        return view_.find_first_not_of(s, pos);
    }
 
    constexpr size_type find_last_not_of(buffer const& buf, size_type pos = npos) const noexcept {
        return view_.find_last_not_of(buf.view_, pos);
    }
 
    constexpr size_type find_last_not_of( std::string_view v, size_type pos = npos) const noexcept {
        return view_.find_last_not_of(v, pos);
    }
 
    constexpr size_type find_last_not_of(char ch, size_type pos = npos) const noexcept {
        return view_.find_last_not_of(ch, pos);
    }
 
    constexpr size_type find_last_not_of(char const* s, size_type pos, size_type count) const {
        return view_.find_last_not_of(s, pos, count);
    }
 
    constexpr size_type find_last_not_of(char const* s, size_type pos = npos) const {
        return view_.find_last_not_of(s, pos);
    }
 
    operator as::const_buffer() const {
        return as::buffer(view_.data(), view_.size());
    }
 
    operator std::string_view() const {
        return view_;
    }
 
    friend
    constexpr bool operator==(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ == rhs.view_;
    }
 
    friend
    constexpr bool operator!=(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ != rhs.view_;
    }
 
    friend
    constexpr bool operator<(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ < rhs.view_;
    }
 
    friend
    constexpr bool operator<=(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ <= rhs.view_;
    }
 
    friend
    constexpr bool operator>(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ > rhs.view_;
    }
 
    friend
    constexpr bool operator>=(buffer const& lhs, buffer const& rhs) noexcept {
        return lhs.view_ >= rhs.view_;
    }
 
    friend
    std::ostream& operator<<(std::ostream& o, buffer const& v) {
        o << v.view_;
        return o;
    }
 
    bool has_life() const noexcept {
        return bool(life_);
    }
 
private:
    std::string_view view_;
    life_type life_;
};
 
inline std::size_t hash_value(buffer const& v) noexcept {
    std::size_t result = 0;
    boost::hash_combine(result, static_cast<std::string_view const&>(v));
    return result;
}
 
} // namespace async_mqtt
 
namespace boost {
namespace asio {
 
inline const_buffer buffer(async_mqtt::buffer const& data) {
    return buffer(data.data(), data.size());
}
 
} // namespace asio
} // namespace boost
 
namespace std {
 
template <>
class hash<async_mqtt::buffer> {
public:
    std::uint64_t operator()(async_mqtt::buffer const& v) const noexcept {
        return std::hash<std::string_view>()(static_cast<std::string_view const&>(v));
    }
};
 
} // namespace std
 
#endif // ASYNC_MQTT_UTIL_BUFFER_HPP