File Manager

X7ROOT File Manager

Current Path: /opt/cpanel/ea-ruby27/src/passenger-release-6.0.23/src/cxx_supportlib/vendor-modified/boost/asio

opt / cpanel / ea-ruby27 / src / passenger-release-6.0.23 / src / cxx_supportlib / vendor-modified / boost / asio /

📁 ..
📄 any_completion_executor.hpp(11.5 KB)
📄 any_completion_handler.hpp(23.19 KB)
📄 any_io_executor.hpp(11.85 KB)
📄 append.hpp(1.82 KB)
📄 as_tuple.hpp(3.85 KB)
📄 associated_allocator.hpp(6.12 KB)
📄 associated_cancellation_slot.hpp(6.79 KB)
📄 associated_executor.hpp(6.86 KB)
📄 associated_immediate_executor.hpp(8.17 KB)
📄 associator.hpp(891 B)
📄 async_result.hpp(26.57 KB)
📄 awaitable.hpp(3.41 KB)
📄 basic_datagram_socket.hpp(52.37 KB)
📄 basic_deadline_timer.hpp(24.08 KB)
📄 basic_file.hpp(27.17 KB)
📄 basic_io_object.hpp(7.71 KB)
📄 basic_random_access_file.hpp(24.96 KB)
📄 basic_raw_socket.hpp(51.82 KB)
📄 basic_readable_pipe.hpp(21.04 KB)
📄 basic_seq_packet_socket.hpp(30.9 KB)
📄 basic_serial_port.hpp(33.84 KB)
📄 basic_signal_set.hpp(22.43 KB)
📄 basic_socket.hpp(65.57 KB)
📄 basic_socket_acceptor.hpp(94.54 KB)
📄 basic_socket_iostream.hpp(10.32 KB)
📄 basic_socket_streambuf.hpp(19.62 KB)
📄 basic_stream_file.hpp(26.08 KB)
📄 basic_stream_socket.hpp(44.98 KB)
📄 basic_streambuf.hpp(13.14 KB)
📄 basic_streambuf_fwd.hpp(918 B)
📄 basic_waitable_timer.hpp(28.24 KB)
📄 basic_writable_pipe.hpp(20.94 KB)
📄 bind_allocator.hpp(14.68 KB)
📄 bind_cancellation_slot.hpp(15.76 KB)
📄 bind_executor.hpp(16.3 KB)
📄 bind_immediate_executor.hpp(15.54 KB)
📄 buffer.hpp(88.29 KB)
📄 buffer_registration.hpp(9.71 KB)
📄 buffered_read_stream.hpp(8.9 KB)
📄 buffered_read_stream_fwd.hpp(699 B)
📄 buffered_stream.hpp(9.17 KB)
📄 buffered_stream_fwd.hpp(669 B)
📄 buffered_write_stream.hpp(8.53 KB)
📄 buffered_write_stream_fwd.hpp(705 B)
📄 buffers_iterator.hpp(13.68 KB)
📄 cancellation_signal.hpp(6.25 KB)
📄 cancellation_state.hpp(7.09 KB)
📄 cancellation_type.hpp(3.78 KB)
📄 co_spawn.hpp(16.39 KB)
📄 completion_condition.hpp(5.37 KB)
📄 compose.hpp(9.62 KB)
📄 connect.hpp(46.78 KB)
📄 connect_pipe.hpp(2.35 KB)
📄 consign.hpp(2.18 KB)
📄 coroutine.hpp(9.71 KB)
📄 deadline_timer.hpp(1.11 KB)
📄 defer.hpp(8.09 KB)
📄 deferred.hpp(21 KB)
📄 detached.hpp(3.09 KB)
📁 detail
📄 dispatch.hpp(7.25 KB)
📄 error.hpp(10.97 KB)
📁 execution
📄 execution.hpp(1.14 KB)
📄 execution_context.hpp(13.21 KB)
📄 executor.hpp(10.02 KB)
📄 executor_work_guard.hpp(9.41 KB)
📁 experimental
📄 file_base.hpp(4.04 KB)
📁 generic
📄 handler_continuation_hook.hpp(1.44 KB)
📄 high_resolution_timer.hpp(1.21 KB)
📁 impl
📄 io_context.hpp(51.9 KB)
📄 io_context_strand.hpp(13.56 KB)
📄 io_service.hpp(861 B)
📄 io_service_strand.hpp(575 B)
📁 ip
📄 is_applicable_property.hpp(1.53 KB)
📄 is_contiguous_iterator.hpp(1.33 KB)
📄 is_executor.hpp(1.28 KB)
📄 is_read_buffered.hpp(1.61 KB)
📄 is_write_buffered.hpp(1.63 KB)
📁 local
📄 multiple_exceptions.hpp(1.38 KB)
📄 packaged_task.hpp(1.79 KB)
📄 placeholders.hpp(2.56 KB)
📁 posix
📄 post.hpp(7.78 KB)
📄 prefer.hpp(16.36 KB)
📄 prepend.hpp(1.84 KB)
📄 query.hpp(8.68 KB)
📄 random_access_file.hpp(985 B)
📄 read.hpp(57.39 KB)
📄 read_at.hpp(30.53 KB)
📄 read_until.hpp(126.37 KB)
📄 readable_pipe.hpp(940 B)
📄 recycling_allocator.hpp(3.36 KB)
📄 redirect_error.hpp(1.82 KB)
📄 registered_buffer.hpp(7.93 KB)
📄 require.hpp(12.2 KB)
📄 require_concept.hpp(9.78 KB)
📄 serial_port.hpp(1010 B)
📄 serial_port_base.hpp(4.86 KB)
📄 signal_set.hpp(748 B)
📄 signal_set_base.hpp(4.27 KB)
📄 socket_base.hpp(15.57 KB)
📄 spawn.hpp(30.51 KB)
📁 ssl
📄 ssl.hpp(848 B)
📄 static_thread_pool.hpp(826 B)
📄 steady_timer.hpp(1.13 KB)
📄 strand.hpp(16.96 KB)
📄 stream_file.hpp(931 B)
📄 streambuf.hpp(826 B)
📄 system_context.hpp(2.57 KB)
📄 system_executor.hpp(21.6 KB)
📄 system_timer.hpp(1.13 KB)
📄 this_coro.hpp(7.06 KB)
📄 thread_pool.hpp(30.6 KB)
📄 time_traits.hpp(2.23 KB)
📁 traits
📁 ts
📄 unyield.hpp(381 B)
📄 use_awaitable.hpp(5.21 KB)
📄 use_future.hpp(4.59 KB)
📄 uses_executor.hpp(2.11 KB)
📄 version.hpp(686 B)
📄 wait_traits.hpp(1.42 KB)
📄 writable_pipe.hpp(940 B)
📄 write.hpp(56.97 KB)
📄 write_at.hpp(32.28 KB)
📄 yield.hpp(482 B)

Editing: basic_io_object.hpp

//
// basic_io_object.hpp
// ~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff 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 BOOST_ASIO_BASIC_IO_OBJECT_HPP
#define BOOST_ASIO_BASIC_IO_OBJECT_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include <boost/asio/detail/config.hpp>
#include <boost/asio/io_context.hpp>

#include <boost/asio/detail/push_options.hpp>

namespace boost {
namespace asio {

namespace detail
{
  // Type trait used to determine whether a service supports move.
  template <typename IoObjectService>
  class service_has_move
  {
  private:
    typedef IoObjectService service_type;
    typedef typename service_type::implementation_type implementation_type;

template <typename T, typename U>
    static auto asio_service_has_move_eval(T* t, U* u)
      -> decltype(t->move_construct(*u, *u), char());
    static char (&asio_service_has_move_eval(...))[2];

public:
    static const bool value =
      sizeof(asio_service_has_move_eval(
        static_cast<service_type*>(0),
        static_cast<implementation_type*>(0))) == 1;
  };
}

/// Base class for all I/O objects.
/**
 * @note All I/O objects are non-copyable. However, when using C++0x, certain
 * I/O objects do support move construction and move assignment.
 */
#if defined(GENERATING_DOCUMENTATION)
template <typename IoObjectService>
#else
template <typename IoObjectService,
    bool Movable = detail::service_has_move<IoObjectService>::value>
#endif
class basic_io_object
{
public:
  /// The type of the service that will be used to provide I/O operations.
  typedef IoObjectService service_type;

/// The underlying implementation type of I/O object.
  typedef typename service_type::implementation_type implementation_type;

#if !defined(BOOST_ASIO_NO_DEPRECATED)
  /// (Deprecated: Use get_executor().) Get the io_context associated with the
  /// object.
  /**
   * This function may be used to obtain the io_context object that the I/O
   * object uses to dispatch handlers for asynchronous operations.
   *
   * @return A reference to the io_context object that the I/O object will use
   * to dispatch handlers. Ownership is not transferred to the caller.
   */
  boost::asio::io_context& get_io_context()
  {
    return service_.get_io_context();
  }

/// (Deprecated: Use get_executor().) Get the io_context associated with the
  /// object.
  /**
   * This function may be used to obtain the io_context object that the I/O
   * object uses to dispatch handlers for asynchronous operations.
   *
   * @return A reference to the io_context object that the I/O object will use
   * to dispatch handlers. Ownership is not transferred to the caller.
   */
  boost::asio::io_context& get_io_service()
  {
    return service_.get_io_context();
  }
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)

/// The type of the executor associated with the object.
  typedef boost::asio::io_context::executor_type executor_type;

/// Get the executor associated with the object.
  executor_type get_executor() noexcept
  {
    return service_.get_io_context().get_executor();
  }

protected:
  /// Construct a basic_io_object.
  /**
   * Performs:
   * @code get_service().construct(get_implementation()); @endcode
   */
  explicit basic_io_object(boost::asio::io_context& io_context)
    : service_(boost::asio::use_service<IoObjectService>(io_context))
  {
    service_.construct(implementation_);
  }

#if defined(GENERATING_DOCUMENTATION)
  /// Move-construct a basic_io_object.
  /**
   * Performs:
   * @code get_service().move_construct(
   *     get_implementation(), other.get_implementation()); @endcode
   *
   * @note Available only for services that support movability,
   */
  basic_io_object(basic_io_object&& other);

/// Move-assign a basic_io_object.
  /**
   * Performs:
   * @code get_service().move_assign(get_implementation(),
   *     other.get_service(), other.get_implementation()); @endcode
   *
   * @note Available only for services that support movability,
   */
  basic_io_object& operator=(basic_io_object&& other);

/// Perform a converting move-construction of a basic_io_object.
  template <typename IoObjectService1>
  basic_io_object(IoObjectService1& other_service,
      typename IoObjectService1::implementation_type& other_implementation);
#endif // defined(GENERATING_DOCUMENTATION)

/// Protected destructor to prevent deletion through this type.
  /**
   * Performs:
   * @code get_service().destroy(get_implementation()); @endcode
   */
  ~basic_io_object()
  {
    service_.destroy(implementation_);
  }

/// Get the service associated with the I/O object.
  service_type& get_service()
  {
    return service_;
  }

/// Get the service associated with the I/O object.
  const service_type& get_service() const
  {
    return service_;
  }

/// Get the underlying implementation of the I/O object.
  implementation_type& get_implementation()
  {
    return implementation_;
  }

/// Get the underlying implementation of the I/O object.
  const implementation_type& get_implementation() const
  {
    return implementation_;
  }

private:
  basic_io_object(const basic_io_object&);
  basic_io_object& operator=(const basic_io_object&);

// The service associated with the I/O object.
  service_type& service_;

/// The underlying implementation of the I/O object.
  implementation_type implementation_;
};

// Specialisation for movable objects.
template <typename IoObjectService>
class basic_io_object<IoObjectService, true>
{
public:
  typedef IoObjectService service_type;
  typedef typename service_type::implementation_type implementation_type;

#if !defined(BOOST_ASIO_NO_DEPRECATED)
  boost::asio::io_context& get_io_context()
  {
    return service_->get_io_context();
  }

boost::asio::io_context& get_io_service()
  {
    return service_->get_io_context();
  }
#endif // !defined(BOOST_ASIO_NO_DEPRECATED)

typedef boost::asio::io_context::executor_type executor_type;

executor_type get_executor() noexcept
  {
    return service_->get_io_context().get_executor();
  }

protected:
  explicit basic_io_object(boost::asio::io_context& io_context)
    : service_(&boost::asio::use_service<IoObjectService>(io_context))
  {
    service_->construct(implementation_);
  }

basic_io_object(basic_io_object&& other)
    : service_(&other.get_service())
  {
    service_->move_construct(implementation_, other.implementation_);
  }

template <typename IoObjectService1>
  basic_io_object(IoObjectService1& other_service,
      typename IoObjectService1::implementation_type& other_implementation)
    : service_(&boost::asio::use_service<IoObjectService>(
          other_service.get_io_context()))
  {
    service_->converting_move_construct(implementation_,
        other_service, other_implementation);
  }

~basic_io_object()
  {
    service_->destroy(implementation_);
  }

basic_io_object& operator=(basic_io_object&& other)
  {
    service_->move_assign(implementation_,
        *other.service_, other.implementation_);
    service_ = other.service_;
    return *this;
  }

service_type& get_service()
  {
    return *service_;
  }

const service_type& get_service() const
  {
    return *service_;
  }

implementation_type& get_implementation()
  {
    return implementation_;
  }

const implementation_type& get_implementation() const
  {
    return implementation_;
  }

private:
  basic_io_object(const basic_io_object&);
  void operator=(const basic_io_object&);

IoObjectService* service_;
  implementation_type implementation_;
};

} // namespace asio
} // namespace boost

#include <boost/asio/detail/pop_options.hpp>

#endif // BOOST_ASIO_BASIC_IO_OBJECT_HPP

X7ROOT File Manager

Editing: basic_io_object.hpp

Upload File

Create Folder