Commit 3743404c authored by Joseph Noir's avatar Joseph Noir

Cleanup file structure & initialization

parent 8113c99c
......@@ -50,6 +50,7 @@ set(LIBCAF_IO_SRCS
src/newb_tcp.cpp
src/newb_udp.cpp
src/newb.cpp
src/policies.cpp
)
add_custom_target(libcaf_io)
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/policy/transport.hpp"
#include "caf/io/network/native_socket.hpp"
namespace caf {
namespace io {
struct newb_base;
} // namespace io
namespace policy {
struct accept {
accept(bool manual_read = false)
: manual_read(manual_read) {
// nop
}
virtual ~accept();
virtual expected<io::network::native_socket>
create_socket(uint16_t port, const char* host, bool reuse = false) = 0;
virtual std::pair<io::network::native_socket, transport_ptr>
accept_event(io::newb_base*) {
return {0, nullptr};
}
/// If `requires_raw_data` is set to true, the acceptor will only call
/// this function for new read event and let the policy handle everything
/// else.
virtual void read_event(io::newb_base*) {
// nop
}
virtual error write_event(io::newb_base*) {
return none;
}
virtual void init(io::newb_base&) {
// nop
}
bool manual_read;
};
using accept_policy_ptr = std::unique_ptr<accept>;
} // namespace policy
} // namespace caf
......@@ -19,7 +19,7 @@
#pragma once
#include "caf/actor.hpp"
#include "caf/io/network/newb.hpp"
#include "caf/io/newb.hpp"
#include "caf/binary_deserializer.hpp"
#include "caf/binary_serializer.hpp"
......@@ -57,11 +57,11 @@ struct datagram_basp {
static constexpr size_t header_size = basp_header_len;
using message_type = new_basp_msg;
using result_type = optional<message_type>;
io::network::newb<message_type>* parent;
io::newb<message_type>* parent;
message_type msg;
datagram_basp(io::network::newb<message_type>* parent) : parent(parent) {
// nop
void init(io::newb<message_type>* n) {
parent = n;
}
error read(char* bytes, size_t count) {
......@@ -90,14 +90,14 @@ struct datagram_basp {
return none;
}
size_t write_header(io::network::byte_buffer& buf,
io::network::header_writer* hw) {
size_t write_header(io::byte_buffer& buf,
io::header_writer* hw) {
CAF_ASSERT(hw != nullptr);
(*hw)(buf);
return header_size;
}
void prepare_for_sending(io::network::byte_buffer& buf,
void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) {
stream_serializer<charbuf> out{&parent->backend(),
buf.data() + hstart + offset,
......@@ -111,13 +111,12 @@ struct stream_basp {
static constexpr size_t header_size = basp_header_len;
using message_type = new_basp_msg;
using result_type = optional<message_type>;
io::network::newb<message_type>* parent;
io::newb<message_type>* parent;
message_type msg;
bool expecting_header = true;
stream_basp(io::network::newb<message_type>* parent) : parent(parent) {
// TODO: this is dangerous ...
// Maybe we need an init function that is called with `start()`?
void init(io::newb<message_type>* n) {
parent = n;
parent->configure_read(io::receive_policy::exactly(basp_header_len));
}
......@@ -157,14 +156,14 @@ struct stream_basp {
return none;
}
size_t write_header(io::network::byte_buffer& buf,
io::network::header_writer* hw) {
size_t write_header(io::byte_buffer& buf,
io::header_writer* hw) {
CAF_ASSERT(hw != nullptr);
(*hw)(buf);
return header_size;
}
void prepare_for_sending(io::network::byte_buffer& buf,
void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) {
stream_serializer<charbuf> out{&parent->backend(),
buf.data() + hstart + offset,
......
......@@ -26,7 +26,7 @@
#include "caf/binary_serializer.hpp"
#include "caf/defaults.hpp"
#include "caf/error.hpp"
#include "caf/io/network/newb.hpp"
#include "caf/io/newb.hpp"
namespace caf {
namespace policy {
......@@ -80,17 +80,22 @@ struct ordering {
size_t max_pending_messages;
bool use_timeouts;
std::chrono::milliseconds pending_to = std::chrono::milliseconds(100);
io::network::newb<message_type>* parent;
io::newb<message_type>* parent;
Next next;
std::map<sequence_type, std::vector<char>, sequence_comperator> pending;
ordering(io::network::newb<message_type>* parent, bool use_timeouts = true)
: max_pending_messages(get_or(parent->config(),
"middleman.max-pending-messages",
caf::defaults::middleman::max_pending_messages)),
use_timeouts(use_timeouts),
parent(parent),
next(parent) {
void init(io::newb<message_type>* n, bool enable_timeouts = true) {
this->use_timeouts = enable_timeouts;
parent = n;
next.init(parent);
max_pending_messages = get_or(parent->config(),
"middleman.max-pending-messages",
max_pending_messages);
}
ordering()
: max_pending_messages(caf::defaults::middleman::max_pending_messages),
use_timeouts(false) {
// nop
}
......@@ -152,8 +157,8 @@ struct ordering {
return next.timeout(atm, id);
}
void write_header(io::network::byte_buffer& buf,
io::network::header_writer* hw) {
void write_header(io::byte_buffer& buf,
io::header_writer* hw) {
binary_serializer bs(&parent->backend(), buf);
bs(ordering_header{seq_write});
seq_write += 1;
......@@ -161,7 +166,7 @@ struct ordering {
return;
}
void prepare_for_sending(io::network::byte_buffer& buf,
void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) {
next.prepare_for_sending(buf, hstart, offset + header_size, plen);
}
......
......@@ -19,7 +19,7 @@
#pragma once
#include "caf/actor.hpp"
#include "caf/io/network/newb.hpp"
#include "caf/io/newb.hpp"
namespace caf {
namespace policy {
......@@ -37,11 +37,11 @@ typename Inspector::result_type inspect(Inspector& fun, new_raw_msg& data) {
struct raw {
using message_type = new_raw_msg;
using result_type = optional<message_type>;
io::network::newb<message_type>* parent;
io::newb<message_type>* parent;
message_type msg;
raw(io::network::newb<message_type>* parent) : parent(parent) {
// nop
void init(io::newb<message_type>* n) {
this->parent = n;
}
error read(char* bytes, size_t count) {
......@@ -55,12 +55,12 @@ struct raw {
return none;
}
size_t write_header(io::network::byte_buffer&,
io::network::header_writer*) {
size_t write_header(io::byte_buffer&,
io::header_writer*) {
return 0;
}
void prepare_for_sending(io::network::byte_buffer&, size_t, size_t, size_t) {
void prepare_for_sending(io::byte_buffer&, size_t, size_t, size_t) {
// nop
}
};
......
......@@ -25,7 +25,7 @@
#include "caf/binary_deserializer.hpp"
#include "caf/binary_serializer.hpp"
#include "caf/error.hpp"
#include "caf/io/network/newb.hpp"
#include "caf/io/newb.hpp"
namespace caf {
namespace policy {
......@@ -57,14 +57,13 @@ struct reliability {
id_type id_write = 0;
// TODO: Make this configurable.
std::chrono::milliseconds retransmit_to = std::chrono::milliseconds(100);
io::network::newb<message_type>* parent;
io::newb<message_type>* parent;
Next next;
std::unordered_map<id_type, io::network::byte_buffer> unacked;
std::unordered_map<id_type, io::byte_buffer> unacked;
reliability(io::network::newb<message_type>* parent)
: parent(parent),
next(parent) {
// nop
void init(io::newb<message_type>* n) {
parent = n;
next.init(parent);
}
error read(char* bytes, size_t count) {
......@@ -106,22 +105,22 @@ struct reliability {
return next.timeout(atm, id);
}
void write_header(io::network::byte_buffer& buf,
io::network::header_writer* hw) {
void write_header(io::byte_buffer& buf,
io::header_writer* hw) {
binary_serializer bs(&parent->backend(), buf);
bs(reliability_header{id_write, false});
next.write_header(buf, hw);
return;
}
void prepare_for_sending(io::network::byte_buffer& buf,
void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) {
next.prepare_for_sending(buf, hstart, offset + header_size, plen);
// Set timeout for retransmission.
parent->set_timeout(retransmit_to, reliability_atom::value, id_write);
// Add to unacked.
unacked.emplace(id_write,
io::network::byte_buffer(buf.begin() + hstart, buf.end()));
io::byte_buffer(buf.begin() + hstart, buf.end()));
id_write += 1;
}
};
......
......@@ -18,28 +18,29 @@
#pragma once
#include "caf/io/network/newb.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/policy/accept.hpp"
#include "caf/policy/transport.hpp"
namespace caf {
namespace policy {
struct tcp_transport : public io::network::transport_policy {
struct tcp_transport : public transport {
tcp_transport();
io::network::rw_state read_some(io::network::newb_base* parent) override;
io::network::rw_state read_some(io::newb_base* parent) override;
bool should_deliver() override;
void prepare_next_read(io::network::newb_base*) override;
void prepare_next_read(io::newb_base*) override;
void configure_read(io::receive_policy::config config) override;
io::network::rw_state write_some(io::network::newb_base* parent) override;
io::network::rw_state write_some(io::newb_base* parent) override;
void prepare_next_write(io::network::newb_base* parent) override;
void prepare_next_write(io::newb_base* parent) override;
void flush(io::network::newb_base* parent) override;
void flush(io::newb_base* parent) override;
expected<io::network::native_socket>
connect(const std::string& host, uint16_t port,
......@@ -56,18 +57,18 @@ struct tcp_transport : public io::network::transport_policy {
size_t written;
};
struct accept_tcp : public io::network::accept_policy {
struct accept_tcp : public accept {
expected<io::network::native_socket>
create_socket(uint16_t port,const char* host,bool reuse = false) override;
std::pair<io::network::native_socket, io::network::transport_policy_ptr>
accept(io::network::newb_base* parent) override;
std::pair<io::network::native_socket, transport_ptr>
accept_event(io::newb_base* parent) override;
void init(io::network::newb_base& n) override;
void init(io::newb_base& n) override;
};
template <class T>
using tcp_protocol = io::network::generic_protocol<T>;
using tcp_protocol = generic_protocol<T>;
} // namespace policy
} // namespace caf
......@@ -18,35 +18,37 @@
#pragma once
#include "caf/io/network/newb.hpp"
#include "caf/io/network/ip_endpoint.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/policy/accept.hpp"
#include "caf/policy/transport.hpp"
namespace caf {
namespace policy {
struct udp_transport : public io::network::transport_policy {
struct udp_transport : public transport {
udp_transport();
io::network::rw_state read_some(io::network::newb_base* parent) override;
io::network::rw_state read_some(io::newb_base* parent) override;
inline bool should_deliver() override {
CAF_LOG_TRACE("");
return received_bytes != 0 && sender == endpoint;
}
void prepare_next_read(io::network::newb_base*) override;
void prepare_next_read(io::newb_base*) override;
inline void configure_read(io::receive_policy::config) override {
// nop
}
io::network::rw_state write_some(io::network::newb_base* parent) override;
io::network::rw_state write_some(io::newb_base* parent) override;
void prepare_next_write(io::network::newb_base* parent) override;
void prepare_next_write(io::newb_base* parent) override;
io::network::byte_buffer& wr_buf() override;
byte_buffer& wr_buf() override;
void flush(io::network::newb_base* parent) override;
void flush(io::newb_base* parent) override;
expected<io::network::native_socket>
connect(const std::string& host, uint16_t port,
......@@ -68,18 +70,18 @@ struct udp_transport : public io::network::transport_policy {
io::network::ip_endpoint sender;
};
struct accept_udp : public io::network::accept_policy {
struct accept_udp : public accept {
expected<io::network::native_socket>
create_socket(uint16_t port, const char* host, bool reuse = false) override;
std::pair<io::network::native_socket, io::network::transport_policy_ptr>
accept(io::network::newb_base*) override;
std::pair<io::network::native_socket, transport_ptr>
accept_event(io::newb_base*) override;
void init(io::network::newb_base& n) override;
void init(io::newb_base& n) override;
};
template <class T>
using udp_protocol = io::network::generic_protocol<T>;
using udp_protocol = generic_protocol<T>;
} // namespace policy
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/callback.hpp"
#include "caf/error.hpp"
namespace caf {
namespace io {
struct newb_base;
template <class T>
struct newb;
} // namespace io
namespace policy {
using byte_buffer = std::vector<char>;
using header_writer = caf::callback<byte_buffer&>;
struct protocol_base {
virtual ~protocol_base();
virtual error read(char* bytes, size_t count) = 0;
virtual error timeout(atom_value, uint32_t) = 0;
virtual void write_header(byte_buffer&, header_writer*) = 0;
virtual void prepare_for_sending(byte_buffer&, size_t, size_t, size_t) = 0;
};
template <class T>
struct protocol : protocol_base {
using message_type = T;
virtual ~protocol() override {
// nop
}
virtual void init(io::newb<message_type>* parent) = 0;
};
template <class T>
using protocol_ptr = std::unique_ptr<protocol<T>>;
template <class T>
struct generic_protocol
: public protocol<typename T::message_type> {
void init(io::newb<typename T::message_type>* parent) override {
impl.init(parent);
}
error read(char* bytes, size_t count) override {
return impl.read(bytes, count);
}
error timeout(atom_value atm, uint32_t id) override {
return impl.timeout(atm, id);
}
void write_header(byte_buffer& buf, header_writer* hw) override {
impl.write_header(buf, hw);
}
void prepare_for_sending(byte_buffer& buf, size_t hstart,
size_t offset, size_t plen) override {
impl.prepare_for_sending(buf, hstart, offset, plen);
}
private:
T impl;
};
} // namespace policy
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/error.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/io/network/protocol.hpp"
#include "caf/io/network/rw_state.hpp"
#include "caf/io/receive_policy.hpp"
#include "caf/logger.hpp"
#include "caf/policy/protocol.hpp"
#include "caf/sec.hpp"
namespace caf {
namespace io {
struct newb_base;
} // namespace io
namespace policy {
struct transport {
transport();
virtual ~transport();
virtual io::network::rw_state write_some(io::newb_base*);
virtual io::network::rw_state read_some(io::newb_base*);
virtual bool should_deliver();
virtual bool must_read_more(io::newb_base*);
virtual void prepare_next_read(io::newb_base*);
virtual void prepare_next_write(io::newb_base*);
virtual void configure_read(io::receive_policy::config);
virtual void flush(io::newb_base*);
virtual byte_buffer& wr_buf();
template <class T>
error read_some(io::newb_base* parent, protocol<T>& policy) {
using io::network::rw_state;
CAF_LOG_TRACE("");
size_t reads = 0;
while (reads < max_consecutive_reads || must_read_more(parent)) {
auto read_result = read_some(parent);
switch (read_result) {
case rw_state::success:
if (received_bytes == 0)
return none;
if (should_deliver()) {
auto res = policy.read(receive_buffer.data(), received_bytes);
prepare_next_read(parent);
if (res)
return res;
}
break;
case rw_state::indeterminate:
// No error, but don't continue reading.
return none;
case rw_state::failure:
// Reading failed.
return sec::runtime_error;
}
++reads;
}
return none;
}
virtual expected<io::network::native_socket>
connect(const std::string&, uint16_t,
optional<io::network::protocol::network> = none);
size_t received_bytes;
size_t max_consecutive_reads;
byte_buffer offline_buffer;
byte_buffer receive_buffer;
byte_buffer send_buffer;
};
using transport_ptr = std::unique_ptr<transport>;
} // namespace policy
} // namespace caf
......@@ -16,85 +16,16 @@
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#include "caf/io/network/newb.hpp"
#include "caf/io/newb.hpp"
namespace caf {
namespace io {
namespace network {
// -- newb_base ----------------------------------------------------------------
newb_base::newb_base(default_multiplexer& dm, native_socket sockfd)
newb_base::newb_base(network::default_multiplexer& dm,
network::native_socket sockfd)
: event_handler(dm, sockfd) {
// nop
}
// -- transport_policy ---------------------------------------------------------
transport_policy::transport_policy()
: received_bytes{0},
max_consecutive_reads{50} {
// nop
}
transport_policy::~transport_policy() {
// nop
}
io::network::rw_state transport_policy::write_some(newb_base*) {
return io::network::rw_state::indeterminate;
}
io::network::rw_state transport_policy::read_some(newb_base*) {
return io::network::rw_state::indeterminate;
}
bool transport_policy::should_deliver() {
return true;
}
bool transport_policy::must_read_more(newb_base*) {
return false;
}
void transport_policy::prepare_next_read(newb_base*) {
// nop
}
void transport_policy::prepare_next_write(newb_base*) {
// nop
}
void transport_policy::configure_read(receive_policy::config) {
// nop
}
void transport_policy::flush(newb_base*) {
// nop
}
byte_buffer& transport_policy::wr_buf() {
return offline_buffer;
}
expected<native_socket>
transport_policy::connect(const std::string&, uint16_t,
optional<io::network::protocol::network>) {
return sec::bad_function_call;
}
// -- accept_policy ------------------------------------------------------------
accept_policy::~accept_policy() {
// nop
}
// -- protocol_policy_base -----------------------------------------------------
protocol_policy_base::~protocol_policy_base() {
// nop
}
} // namespace network
} // namespace io
} // namespace caf
......@@ -17,6 +17,7 @@
******************************************************************************/
#include "caf/policy/newb_tcp.hpp"
#include "caf/io/newb.hpp"
#include "caf/config.hpp"
......@@ -71,7 +72,7 @@ tcp_transport::tcp_transport()
configure_read(io::receive_policy::at_most(1024));
}
io::network::rw_state tcp_transport::read_some(io::network::newb_base* parent) {
io::network::rw_state tcp_transport::read_some(io::newb_base* parent) {
CAF_LOG_TRACE("");
size_t len = receive_buffer.size() - collected;
void* buf = receive_buffer.data() + collected;
......@@ -100,7 +101,7 @@ bool tcp_transport::should_deliver() {
return collected >= read_threshold;
}
void tcp_transport::prepare_next_read(io::network::newb_base*) {
void tcp_transport::prepare_next_read(io::newb_base*) {
collected = 0;
received_bytes = 0;
switch (rd_flag) {
......@@ -130,7 +131,7 @@ void tcp_transport::configure_read(io::receive_policy::config config) {
maximum = config.second;
}
io::network::rw_state tcp_transport::write_some(io::network::newb_base* parent) {
io::network::rw_state tcp_transport::write_some(io::newb_base* parent) {
CAF_LOG_TRACE("");
const void* buf = send_buffer.data() + written;
auto len = send_buffer.size() - written;
......@@ -150,7 +151,7 @@ io::network::rw_state tcp_transport::write_some(io::network::newb_base* parent)
return io::network::rw_state::success;
}
void tcp_transport::prepare_next_write(io::network::newb_base* parent) {
void tcp_transport::prepare_next_write(io::newb_base* parent) {
written = 0;
send_buffer.clear();
if (offline_buffer.empty()) {
......@@ -161,7 +162,7 @@ void tcp_transport::prepare_next_write(io::network::newb_base* parent) {
}
}
void tcp_transport::flush(io::network::newb_base* parent) {
void tcp_transport::flush(io::newb_base* parent) {
CAF_ASSERT(parent != nullptr);
CAF_LOG_TRACE(CAF_ARG(offline_buffer.size()));
if (!offline_buffer.empty() && !writing) {
......@@ -182,8 +183,8 @@ accept_tcp::create_socket(uint16_t port, const char* host, bool reuse) {
return io::network::new_tcp_acceptor_impl(port, host, reuse);
}
std::pair<io::network::native_socket, io::network::transport_policy_ptr>
accept_tcp::accept(io::network::newb_base* parent) {
std::pair<io::network::native_socket, transport_ptr>
accept_tcp::accept_event(io::newb_base* parent) {
using namespace io::network;
sockaddr_storage addr;
std::memset(&addr, 0, sizeof(addr));
......@@ -196,11 +197,11 @@ accept_tcp::accept(io::network::newb_base* parent) {
return {invalid_native_socket, nullptr};
}
}
transport_policy_ptr ptr{new tcp_transport};
transport_ptr ptr{new tcp_transport};
return {result, std::move(ptr)};
}
void accept_tcp::init(io::network::newb_base& n) {
void accept_tcp::init(io::newb_base& n) {
n.start();
}
......
......@@ -20,6 +20,9 @@
#include "caf/config.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/io/newb.hpp"
#ifdef CAF_WINDOWS
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
......@@ -71,7 +74,7 @@ udp_transport::udp_transport()
// nop
}
io::network::rw_state udp_transport::read_some(io::network::newb_base* parent) {
io::network::rw_state udp_transport::read_some(io::newb_base* parent) {
CAF_LOG_TRACE(CAF_ARG(parent->fd()));
memset(sender.address(), 0, sizeof(sockaddr_storage));
io::network::socket_size_type len = sizeof(sockaddr_storage);
......@@ -97,12 +100,12 @@ io::network::rw_state udp_transport::read_some(io::network::newb_base* parent) {
return io::network::rw_state::success;
}
void udp_transport::prepare_next_read(io::network::newb_base*) {
void udp_transport::prepare_next_read(io::newb_base*) {
received_bytes = 0;
receive_buffer.resize(maximum);
}
io::network::rw_state udp_transport::write_some(io::network::newb_base* parent) {
io::network::rw_state udp_transport::write_some(io::newb_base* parent) {
using namespace caf::io::network;
CAF_LOG_TRACE(CAF_ARG(parent->fd()) << CAF_ARG(send_buffer.size()));
socket_size_type len = static_cast<socket_size_type>(*endpoint.clength());
......@@ -128,7 +131,7 @@ io::network::rw_state udp_transport::write_some(io::network::newb_base* parent)
return io::network::rw_state::success;
}
void udp_transport::prepare_next_write(io::network::newb_base* parent) {
void udp_transport::prepare_next_write(io::newb_base* parent) {
written = 0;
send_buffer.clear();
send_sizes.clear();
......@@ -146,7 +149,7 @@ void udp_transport::prepare_next_write(io::network::newb_base* parent) {
}
}
io::network::byte_buffer& udp_transport::wr_buf() {
io::byte_buffer& udp_transport::wr_buf() {
if (!offline_buffer.empty()) {
auto chunk_size = offline_buffer.size() - offline_sum;
offline_sizes.push_back(chunk_size);
......@@ -155,7 +158,7 @@ io::network::byte_buffer& udp_transport::wr_buf() {
return offline_buffer;
}
void udp_transport::flush(io::network::newb_base* parent) {
void udp_transport::flush(io::newb_base* parent) {
CAF_ASSERT(parent != nullptr);
CAF_LOG_TRACE(CAF_ARG(offline_buffer.size()));
if (!offline_buffer.empty() && !writing) {
......@@ -183,19 +186,19 @@ accept_udp::create_socket(uint16_t port, const char* host, bool reuse) {
return (*res).first;
}
std::pair<io::network::native_socket, io::network::transport_policy_ptr>
accept_udp::accept(io::network::newb_base*) {
std::pair<io::network::native_socket, transport_ptr>
accept_udp::accept_event(io::newb_base*) {
auto res = io::network::new_local_udp_endpoint_impl(0, nullptr);
if (!res) {
CAF_LOG_DEBUG("failed to create local endpoint");
return {io::network::invalid_native_socket, nullptr};
}
auto sock = std::move(res->first);
io::network::transport_policy_ptr ptr{new udp_transport};
transport_ptr ptr{new udp_transport};
return {sock, std::move(ptr)};
}
void accept_udp::init(io::network::newb_base& n) {
void accept_udp::init(io::newb_base& n) {
n.start();
}
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#include "caf/policy/accept.hpp"
#include "caf/policy/protocol.hpp"
#include "caf/policy/transport.hpp"
namespace caf {
namespace policy {
// -- transport_policy ---------------------------------------------------------
transport::transport()
: received_bytes{0},
max_consecutive_reads{50} {
// nop
}
transport::~transport() {
// nop
}
io::network::rw_state transport::write_some(io::newb_base*) {
return io::network::rw_state::indeterminate;
}
io::network::rw_state transport::read_some(io::newb_base*) {
return io::network::rw_state::indeterminate;
}
bool transport::should_deliver() {
return true;
}
bool transport::must_read_more(io::newb_base*) {
return false;
}
void transport::prepare_next_read(io::newb_base*) {
// nop
}
void transport::prepare_next_write(io::newb_base*) {
// nop
}
void transport::configure_read(io::receive_policy::config) {
// nop
}
void transport::flush(io::newb_base*) {
// nop
}
byte_buffer& transport::wr_buf() {
return offline_buffer;
}
expected<io::network::native_socket>
transport::connect(const std::string&, uint16_t,
optional<io::network::protocol::network>) {
return sec::bad_function_call;
}
// -- accept_policy ------------------------------------------------------------
accept::~accept() {
// nop
}
// -- protocol_policy_base -----------------------------------------------------
protocol_base::~protocol_base() {
// nop
}
} // namespace policy
} // namespace caf
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment