RubyGems - couchbase - Versions diffs - 3.0.0.alpha.2 → 3.0.0 - Mend

couchbase 3.0.0.alpha.2 → 3.0.0

Files changed (887) hide show

data/ext/third_party/asio/asio/src/examples/cpp03/tutorial/daytime7/.gitignore DELETED

@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/examples/cpp03/tutorial/daytime7/server.cpp DELETED

@@ -1,160 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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)
-//
-#include <ctime>
-#include <iostream>
-#include <string>
-#include <boost/array.hpp>
-#include <boost/bind/bind.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
-#include <asio.hpp>
-using asio::ip::tcp;
-using asio::ip::udp;
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-class tcp_connection
-  : public boost::enable_shared_from_this<tcp_connection>
-{
-public:
-  typedef boost::shared_ptr<tcp_connection> pointer;
-  static pointer create(asio::io_context& io_context)
-  {
-    return pointer(new tcp_connection(io_context));
-  }
-  tcp::socket& socket()
-  {
-    return socket_;
-  }
-  void start()
-  {
-    message_ = make_daytime_string();
-    asio::async_write(socket_, asio::buffer(message_),
-        boost::bind(&tcp_connection::handle_write, shared_from_this()));
-  }
-private:
-  tcp_connection(asio::io_context& io_context)
-    : socket_(io_context)
-  {
-  }
-  void handle_write()
-  {
-  }
-  tcp::socket socket_;
-  std::string message_;
-};
-class tcp_server
-{
-public:
-  tcp_server(asio::io_context& io_context)
-    : io_context_(io_context),
-      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  {
-    start_accept();
-  }
-private:
-  void start_accept()
-  {
-    tcp_connection::pointer new_connection =
-      tcp_connection::create(io_context_);
-    acceptor_.async_accept(new_connection->socket(),
-        boost::bind(&tcp_server::handle_accept, this, new_connection,
-          asio::placeholders::error));
-  }
-  void handle_accept(tcp_connection::pointer new_connection,
-      const asio::error_code& error)
-  {
-    if (!error)
-    {
-      new_connection->start();
-    }
-    start_accept();
-  }
-  asio::io_context& io_context_;
-  tcp::acceptor acceptor_;
-};
-class udp_server
-{
-public:
-  udp_server(asio::io_context& io_context)
-    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  {
-    start_receive();
-  }
-private:
-  void start_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(recv_buffer_), remote_endpoint_,
-        boost::bind(&udp_server::handle_receive, this,
-          asio::placeholders::error));
-  }
-  void handle_receive(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      boost::shared_ptr<std::string> message(
-          new std::string(make_daytime_string()));
-      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-          boost::bind(&udp_server::handle_send, this, message));
-      start_receive();
-    }
-  }
-  void handle_send(boost::shared_ptr<std::string> /*message*/)
-  {
-  }
-  udp::socket socket_;
-  udp::endpoint remote_endpoint_;
-  boost::array<char, 1> recv_buffer_;
-};
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-    tcp_server server1(io_context);
-    udp_server server2(io_context);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp03/tutorial/daytime_dox.txt DELETED

@@ -1,500 +0,0 @@
-//
-// Copyright (c) 2003-2020 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)
-//
-/**
-\page tutdaytime1 Daytime.1 - A synchronous TCP daytime client
-This tutorial program shows how to use asio to implement a client application
-with TCP.
-\dontinclude daytime1/client.cpp
-\skip #include
-We start by including the necessary header files.
-\until asio.hpp
-The purpose of this application is to access a daytime service,
-so we need the user to specify the server.
-\until }
-All programs that use asio need to have at least one asio::io_context
-object.
-\until asio::io_context
-We need to turn the server name that was specified as a parameter to the
-application, into a TCP endpoint. To do this we use an
-asio::ip::tcp::resolver object.
-\until tcp::resolver
-A resolver takes a host name and service name and turns them into a list of
-endpoints. We perform a resolve call using the name of the server, specified in
-<tt>argv[1]</tt>, and the name of the service, in this case <tt>"daytime"</tt>.
-The list of endpoints is returned using an object of type
-asio::ip::tcp::resolver::results_type. This object is a range, with begin() and
-end() member functions that may be used for iterating over the results.
-\until resolver.resolve
-Now we create and connect the socket. The list of endpoints obtained above may
-contain both IPv4 and IPv6 endpoints, so we need to try each of them until we
-find one that works. This keeps the client program independent of a specific IP
-version. The asio::connect() function does this for us automatically.
-\until asio::connect
-The connection is open. All we need to do now is read the response from the
-daytime service.
-We use a <tt>boost::array</tt> to hold the received data. The asio::buffer()
-function automatically determines the size of the array to help prevent buffer
-overruns. Instead of a <tt>boost::array</tt>, we could have used a <tt>char
-[]</tt> or <tt>std::vector</tt>.
-\until read_some
-When the server closes the connection, the asio::ip::tcp::socket::read_some()
-function will exit with the asio::error::eof error, which is how we know to
-exit the loop.
-\until }
-Finally, handle any exceptions that may have been thrown.
-\until }
-\until }
-See the \ref tutdaytime1src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Next: \ref tutdaytime2
-*/
-/**
-\page tutdaytime1src Source listing for Daytime.1
-\include daytime1/client.cpp
-Return to \ref tutdaytime1
-*/
-/**
-\page tutdaytime2 Daytime.2 - A synchronous TCP daytime server
-This tutorial program shows how to use asio to implement a server application
-with TCP.
-\dontinclude daytime2/server.cpp
-\skip #include
-\until using
-We define the function <tt>make_daytime_string()</tt> to create the string to
-be sent back to the client. This function will be reused in all of our daytime
-server applications.
-\until asio::io_context
-A asio::ip::tcp::acceptor object needs to be created to listen
-for new connections. It is initialised to listen on TCP port 13, for IP version 4.
-\until tcp::acceptor
-This is an iterative server, which means that it will handle one
-connection at a time. Create a socket that will represent the connection to the
-client, and then wait for a connection.
-\until acceptor.accept
-A client is accessing our service. Determine the current time
-and transfer this information to the client.
-\until }
-\until }
-Finally, handle any exceptions.
-\until }
-\until }
-See the \ref tutdaytime2src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime1 \n
-Next: \ref tutdaytime3
-*/
-/**
-\page tutdaytime2src Source listing for Daytime.2
-\include daytime2/server.cpp
-Return to \ref tutdaytime2
-*/
-/**
-\page tutdaytime3 Daytime.3 - An asynchronous TCP daytime server
-\section tutdaytime3funcmain The main() function
-\dontinclude daytime3/server.cpp
-\skip int main()
-\until try
-\until {
-We need to create a server object to accept incoming client connections. The
-asio::io_context object provides I/O services, such as sockets, that the
-server object will use.
-\until tcp_server
-Run the asio::io_context object so that it will perform asynchronous operations
-on your behalf.
-\until return 0;
-\until }
-\section tutdaytime3classtcp_server The tcp_server class
-\dontinclude daytime3/server.cpp
-\skip class tcp_server
-\until public:
-The constructor initialises an acceptor to listen on TCP port 13.
-\until private:
-The function <tt>start_accept()</tt> creates a socket and initiates an
-asynchronous accept operation to wait for a new connection.
-\until }
-The function <tt>handle_accept()</tt> is called when the asynchronous accept
-operation initiated by <tt>start_accept()</tt> finishes. It services the client
-request, and then calls <tt>start_accept()</tt> to initiate the next accept
-operation.
-\until }
-\until }
-\section tutdaytime3classtcp_connection The tcp_connection class
-We will use <tt>shared_ptr</tt> and <tt>enable_shared_from_this</tt> because we
-want to keep the <tt>tcp_connection</tt> object alive as long as there is an
-operation that refers to it.
-\dontinclude daytime3/server.cpp
-\skip class tcp_connection
-\until shared_ptr
-\until }
-\until }
-In the function <tt>start()</tt>, we call asio::async_write() to serve the data
-to the client. Note that we are using asio::async_write(), rather than
-asio::ip::tcp::socket::async_write_some(), to ensure that the entire block of
-data is sent.
-\until {
-The data to be sent is stored in the class member <tt>message_</tt> as we need
-to keep the data valid until the asynchronous operation is complete.
-\until message_
-When initiating the asynchronous operation, and if using \ref boost_bind, you
-must specify only the arguments that match the handler's parameter list. In
-this program, both of the argument placeholders (asio::placeholders::error and
-asio::placeholders::bytes_transferred) could potentially have been removed,
-since they are not being used in <tt>handle_write()</tt>.
-\until placeholders::bytes_transferred
-Any further actions for this client connection are now the responsibility of
-<tt>handle_write()</tt>.
-\until };
-\section tutdaytime3remunused Removing unused handler parameters
-You may have noticed that the <tt>error</tt>, and <tt>bytes_transferred</tt>
-parameters are not used in the body of the <tt>handle_write()</tt> function. If
-parameters are not needed, it is possible to remove them from the function so
-that it looks like:
-\code
-  void handle_write()
-  {
-  }
-\endcode
-The asio::async_write() call used to initiate the call can then be changed to
-just:
-\code
-  asio::async_write(socket_, asio::buffer(message_),
-      boost::bind(&tcp_connection::handle_write, shared_from_this()));
-\endcode
-See the \ref tutdaytime3src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime2 \n
-Next: \ref tutdaytime4
-*/
-/**
-\page tutdaytime3src Source listing for Daytime.3
-\include daytime3/server.cpp
-Return to \ref tutdaytime3
-*/
-/**
-\page tutdaytime4 Daytime.4 - A synchronous UDP daytime client
-This tutorial program shows how to use asio to implement a client application
-with UDP.
-\dontinclude daytime4/client.cpp
-\skip #include
-\until using asio::ip::udp;
-The start of the application is essentially the same as for the TCP daytime
-client.
-\until asio::io_context
-We use an asio::ip::udp::resolver object to find the correct remote endpoint to
-use based on the host and service names. The query is restricted to return only
-IPv4 endpoints by the asio::ip::udp::v4() argument.
-\until udp::v4
-The asio::ip::udp::resolver::resolve() function is guaranteed to return at
-least one endpoint in the list if it does not fail. This means it is safe to
-dereference the return value directly.
-\until udp::endpoint
-Since UDP is datagram-oriented, we will not be using a stream socket. Create an
-asio::ip::udp::socket and initiate contact with the remote endpoint.
-\until receiver_endpoint
-Now we need to be ready to accept whatever the server sends back to us. The
-endpoint on our side that receives the server's response will be initialised by
-asio::ip::udp::socket::receive_from().
-\until }
-Finally, handle any exceptions that may have been thrown.
-\until }
-\until }
-See the \ref tutdaytime4src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime3 \n
-Next: \ref tutdaytime5
-*/
-/**
-\page tutdaytime4src Source listing for Daytime.4
-\include daytime4/client.cpp
-Return to \ref tutdaytime4
-*/
-/**
-\page tutdaytime5 Daytime.5 - A synchronous UDP daytime server
-This tutorial program shows how to use asio to implement a server application
-with UDP.
-\dontinclude daytime5/server.cpp
-\skip int main()
-\until asio::io_context
-Create an asio::ip::udp::socket object to receive requests on UDP port 13.
-\until udp::socket
-Wait for a client to initiate contact with us. The remote_endpoint object will
-be populated by asio::ip::udp::socket::receive_from().
-\until receive_from
-Determine what we are going to send back to the client.
-\until std::string message
-Send the response to the remote_endpoint.
-\until }
-\until }
-Finally, handle any exceptions.
-\until }
-\until }
-See the \ref tutdaytime5src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime4 \n
-Next: \ref tutdaytime6
-*/
-/**
-\page tutdaytime5src Source listing for Daytime.5
-\include daytime5/server.cpp
-Return to \ref tutdaytime5
-*/
-/**
-\page tutdaytime6 Daytime.6 - An asynchronous UDP daytime server
-\section tutdaytime6funcmain The main() function
-\dontinclude daytime6/server.cpp
-\skip int main()
-\until try
-\until {
-Create a server object to accept incoming client requests, and run
-the asio::io_context object.
-\until return 0;
-\until }
-\section tutdaytime6classudp_server The udp_server class
-\dontinclude daytime6/server.cpp
-\skip class udp_server
-\until public:
-The constructor initialises a socket to listen on UDP port 13.
-\until private:
-\until {
-The function asio::ip::udp::socket::async_receive_from() will cause the
-application to listen in the background for a new request. When such a request
-is received, the asio::io_context object will invoke the
-<tt>handle_receive()</tt> function with two arguments: a value of type
-asio::error_code indicating whether the operation succeeded or failed, and a
-<tt>size_t</tt> value <tt>bytes_transferred</tt> specifying the number of bytes
-received.
-\until }
-The function <tt>handle_receive()</tt> will service the client request.
-\until {
-The <tt>error</tt> parameter contains the result of the asynchronous operation.
-Since we only provide the 1-byte <tt>recv_buffer_</tt> to contain the client's
-request, the asio::io_context object would return an error if the client sent
-anything larger. We can ignore such an error if it comes up.
-\until {
-Determine what we are going to send.
-\until make_daytime_string()
-We now call asio::ip::udp::socket::async_send_to() to serve the data to the
-client.
-\until asio::placeholders::bytes_transferred
-When initiating the asynchronous operation, and if using \ref boost_bind, you
-must specify only the arguments that match the handler's parameter list. In
-this program, both of the argument placeholders (asio::placeholders::error and
-asio::placeholders::bytes_transferred) could potentially have been removed.
-Start listening for the next client request.
-\until start_receive
-Any further actions for this client request are now the responsibility of
-<tt>handle_send()</tt>.
-\until }
-\until }
-The function <tt>handle_send()</tt> is invoked after the service request has
-been completed.
-\until }
-\until }
-See the \ref tutdaytime6src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime5 \n
-Next: \ref tutdaytime7
-*/
-/**
-\page tutdaytime6src Source listing for Daytime.6
-\include daytime6/server.cpp
-Return to \ref tutdaytime6
-*/
-/**
-\page tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server
-This tutorial program shows how to combine the two asynchronous servers that we
-have just written, into a single server application.
-\section tutdaytime7funcmain The main() function
-\dontinclude daytime7/server.cpp
-\skip int main()
-\until asio::io_context
-We will begin by creating a server object to accept a TCP client connection.
-\until tcp_server
-We also need a server object to accept a UDP client request.
-\until udp_server
-We have created two lots of work for the asio::io_context object to do.
-\until return 0;
-\until }
-\section tutdaytime7classtcp The tcp_connection and tcp_server classes
-The following two classes are taken from \ref tutdaytime3 "Daytime.3".
-\dontinclude daytime7/server.cpp
-\skip class tcp_connection
-\until };
-\until };
-\section tutdaytime7classudp The udp_server class
-Similarly, this next class is taken from the
-\ref tutdaytime6 "previous tutorial step".
-\dontinclude daytime7/server.cpp
-\skip class udp_server
-\until };
-See the \ref tutdaytime7src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime6
-*/
-/**
-\page tutdaytime7src Source listing for Daytime.7
-\include daytime7/server.cpp
-Return to \ref tutdaytime7
-*/