mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
d8dea963fa
6d5547a Set version to 1.0.0-b34 6fab138 Fix and tidy up CMake build scripts: ccefa54 Set version to 1.0.0-b33 32afe41 Set internal state correctly when writing frames: fe3e20b Add write_frames unit test 578dcd0 Add decorator unit test aaa3733 Use fwrite return value in file_body df66165 Require Visual Studio 2015 Update 3 or later b8e5a21 Set version to 1.0.0-b32 ffb1758 Update CMake scripts for finding packages: b893749 Remove http Writer suspend and resume feature (API Change): 27864fb Add io_service completion invariants tests eba05a7 Set version to 1.0.0-b31 484bcef Fix badge markdown in README.md 5663bea Add missing dynabuf_readstream member 0d7a551 Tidy up build settings 0fd4030 Move the handler, don't copy it git-subtree-dir: src/beast git-subtree-split: 6d5547a32c50ec95832c4779311502555ab0ee1f
142 lines
3.3 KiB
C++
142 lines
3.3 KiB
C++
//
|
|
// Copyright (c) 2013-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)
|
|
//
|
|
|
|
#ifndef BEAST_HANDLER_ALLOC_HPP
|
|
#define BEAST_HANDLER_ALLOC_HPP
|
|
|
|
#include <beast/config.hpp>
|
|
#include <beast/core/handler_helpers.hpp>
|
|
#include <cstdlib>
|
|
#include <memory>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
namespace beast {
|
|
|
|
// Guidance from
|
|
// http://howardhinnant.github.io/allocator_boilerplate.html
|
|
|
|
/** An allocator that uses handler customizations.
|
|
|
|
This allocator uses the handler customizations `asio_handler_allocate`
|
|
and `asio_handler_deallocate` to manage memory. It meets the requirements
|
|
of @b Allocator and can be used anywhere a `std::allocator` is
|
|
accepted.
|
|
|
|
@tparam T The type of objects allocated by the allocator.
|
|
|
|
@tparam Handler The type of handler.
|
|
|
|
@note Memory allocated by this allocator must be freed before
|
|
the handler is invoked or undefined behavior results. This behavior
|
|
is described as the "deallocate before invocation" Asio guarantee.
|
|
*/
|
|
#if GENERATING_DOCS
|
|
template<class T, class Handler>
|
|
class handler_alloc;
|
|
#else
|
|
template<class T, class Handler>
|
|
class handler_alloc
|
|
{
|
|
private:
|
|
// We want a partial template specialization as a friend
|
|
// but that isn't allowed so we friend all versions. This
|
|
// should produce a compile error if Handler is not
|
|
// constructible from H.
|
|
//
|
|
template<class U, class H>
|
|
friend class handler_alloc;
|
|
|
|
Handler& h_;
|
|
|
|
public:
|
|
using value_type = T;
|
|
using is_always_equal = std::true_type;
|
|
|
|
template<class U>
|
|
struct rebind
|
|
{
|
|
using other = handler_alloc<U, Handler>;
|
|
};
|
|
|
|
handler_alloc() = delete;
|
|
handler_alloc(handler_alloc&&) = default;
|
|
handler_alloc(handler_alloc const&) = default;
|
|
handler_alloc& operator=(handler_alloc&&) = default;
|
|
handler_alloc& operator=(handler_alloc const&) = default;
|
|
|
|
/** Construct the allocator.
|
|
|
|
A reference of the handler is stored. The handler must
|
|
remain valid for at least the lifetime of the allocator.
|
|
*/
|
|
explicit
|
|
handler_alloc(Handler& h)
|
|
: h_(h)
|
|
{
|
|
}
|
|
|
|
/// Copy constructor
|
|
template<class U>
|
|
handler_alloc(
|
|
handler_alloc<U, Handler> const& other)
|
|
: h_(other.h_)
|
|
{
|
|
}
|
|
|
|
value_type*
|
|
allocate(std::ptrdiff_t n)
|
|
{
|
|
auto const size = n * sizeof(T);
|
|
return static_cast<value_type*>(
|
|
beast_asio_helpers::allocate(
|
|
size, h_));
|
|
}
|
|
|
|
void
|
|
deallocate(value_type* p, std::ptrdiff_t n)
|
|
{
|
|
auto const size = n * sizeof(T);
|
|
beast_asio_helpers::deallocate(
|
|
p, size, h_);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
// Work-around for MSVC not using allocator_traits
|
|
// in the implementation of shared_ptr
|
|
//
|
|
void
|
|
destroy(T* t)
|
|
{
|
|
t->~T();
|
|
}
|
|
#endif
|
|
|
|
template<class U>
|
|
friend
|
|
bool
|
|
operator==(handler_alloc const& lhs,
|
|
handler_alloc<U, Handler> const& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
template<class U>
|
|
friend
|
|
bool
|
|
operator!=(handler_alloc const& lhs,
|
|
handler_alloc<U, Handler> const& rhs)
|
|
{
|
|
return ! (lhs == rhs);
|
|
}
|
|
};
|
|
#endif
|
|
|
|
} // beast
|
|
|
|
#endif
|