Commit ae46af0e authored by Joseph Noir's avatar Joseph Noir

Add datagram sink, source, manager and handles

These componets take a similar role to scribes for udp based
communication.
parent a96be3d0
...@@ -23,6 +23,10 @@ set (LIBCAF_IO_SRCS ...@@ -23,6 +23,10 @@ set (LIBCAF_IO_SRCS
src/acceptor_manager.cpp src/acceptor_manager.cpp
src/multiplexer.cpp src/multiplexer.cpp
src/uri.cpp src/uri.cpp
src/datagram_sink_manager.cpp
src/datagram_source_manager.cpp
src/datagram_sink.cpp
src/datagram_source.cpp
# BASP files # BASP files
src/header.cpp src/header.cpp
src/message_type.cpp src/message_type.cpp
......
...@@ -29,13 +29,19 @@ ...@@ -29,13 +29,19 @@
#include "caf/io/fwd.hpp" #include "caf/io/fwd.hpp"
#include "caf/io/accept_handle.hpp" #include "caf/io/accept_handle.hpp"
#include "caf/io/datagram_sink.hpp"
#include "caf/io/receive_policy.hpp" #include "caf/io/receive_policy.hpp"
#include "caf/io/datagram_source.hpp"
#include "caf/io/system_messages.hpp" #include "caf/io/system_messages.hpp"
#include "caf/io/connection_handle.hpp" #include "caf/io/connection_handle.hpp"
#include "caf/io/datagram_sink_handle.hpp"
#include "caf/io/datagram_source_handle.hpp"
#include "caf/io/network/native_socket.hpp" #include "caf/io/network/native_socket.hpp"
#include "caf/io/network/stream_manager.hpp" #include "caf/io/network/stream_manager.hpp"
#include "caf/io/network/acceptor_manager.hpp" #include "caf/io/network/acceptor_manager.hpp"
#include "caf/io/network/datagram_sink_manager.hpp"
#include "caf/io/network/datagram_source_manager.hpp"
namespace caf { namespace caf {
namespace io { namespace io {
...@@ -267,6 +273,12 @@ protected: ...@@ -267,6 +273,12 @@ protected:
using scribe_map = std::unordered_map<connection_handle, using scribe_map = std::unordered_map<connection_handle,
intrusive_ptr<scribe>>; intrusive_ptr<scribe>>;
using datagram_sink_map = std::unordered_map<datagram_sink_handle,
intrusive_ptr<datagram_sink>>;
using datagram_source_map = std::unordered_map<datagram_source_handle,
intrusive_ptr<datagram_source>>;
/// @cond PRIVATE /// @cond PRIVATE
// meta programming utility // meta programming utility
...@@ -279,12 +291,25 @@ protected: ...@@ -279,12 +291,25 @@ protected:
return scribes_; return scribes_;
} }
inline datagram_sink_map& get_map(datagram_sink_handle) {
return datagram_sinks_;
}
inline datagram_source_map& get_map(datagram_source_handle) {
return datagram_sources_;
}
// meta programming utility (not implemented) // meta programming utility (not implemented)
static intrusive_ptr<doorman> ptr_of(accept_handle); static intrusive_ptr<doorman> ptr_of(accept_handle);
// meta programming utility (not implemented) // meta programming utility (not implemented)
static intrusive_ptr<scribe> ptr_of(connection_handle); static intrusive_ptr<scribe> ptr_of(connection_handle);
// meta programming utility (not implemented)
static intrusive_ptr<datagram_sink> ptr_of(datagram_sink_handle);
// meta programming utility (not implemented)
static intrusive_ptr<datagram_source> ptr_of(datagram_source_handle);
/// @endcond /// @endcond
/// Returns the `multiplexer` running this broker. /// Returns the `multiplexer` running this broker.
...@@ -318,6 +343,8 @@ protected: ...@@ -318,6 +343,8 @@ protected:
private: private:
scribe_map scribes_; scribe_map scribes_;
doorman_map doormen_; doorman_map doormen_;
datagram_sink_map datagram_sinks_;
datagram_source_map datagram_sources_;
detail::intrusive_partitioned_list<mailbox_element, detail::disposer> cache_; detail::intrusive_partitioned_list<mailbox_element, detail::disposer> cache_;
std::vector<char> dummy_wr_buf_; std::vector<char> dummy_wr_buf_;
}; };
......
...@@ -29,7 +29,8 @@ ...@@ -29,7 +29,8 @@
namespace caf { namespace caf {
namespace io { namespace io {
/// Base class for `scribe` and `doorman`. /// Base class for `scribe` and `doorman` as well as `datagram_source`
/// and `datagram_sink`.
/// @ingroup Broker /// @ingroup Broker
template <class Base, class Handle, class SysMsgType> template <class Base, class Handle, class SysMsgType>
class broker_servant : public Base { class broker_servant : public Base {
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_DATAGRAM_SINK_HPP
#define CAF_IO_DATAGRAM_SINK_HPP
#include "caf/io/broker_servant.hpp"
#include "caf/io/system_messages.hpp"
#include "caf/io/datagram_sink_handle.hpp"
#include "caf/io/network/datagram_sink_manager.hpp"
namespace caf {
namespace io {
using datagram_sink_base = broker_servant<network::datagram_sink_manager,
datagram_sink_handle,
datagram_sent_msg>;
/// Manages writing to a datagram sink
/// @ingroup Broker
class datagram_sink : public datagram_sink_base {
public:
datagram_sink(abstract_broker* parent, datagram_sink_handle hdl);
~datagram_sink();
/// Returns the current write buffer.
virtual std::vector<char>& wr_buf() = 0;
void datagram_sent(execution_unit* ctx, size_t num_bytes) override;
void io_failure(execution_unit* ctx, network::operation op) override;
protected:
message detach_message() override;
};
} // namespace io
} // namespace caf
#endif // CAF_IO_DATAGRAM_SINK_HPP
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_DATAGRAM_SINK_HANDLE_HPP
#define CAF_IO_DATAGRAM_SINK_HANDLE_HPP
#include <functional>
#include "caf/error.hpp"
#include "caf/io/handle.hpp"
#include "caf/meta/type_name.hpp"
namespace caf {
namespace io {
struct invalid_datagram_sink_handle_t {
constexpr invalid_datagram_sink_handle_t() {
// nop
}
};
constexpr invalid_datagram_sink_handle_t invalid_datagram_sink_handle
= invalid_datagram_sink_handle_t{};
/// Generic type for identifying datagram sink.
class datagram_sink_handle : public handle<datagram_sink_handle,
invalid_datagram_sink_handle_t> {
public:
friend class handle<datagram_sink_handle, invalid_datagram_sink_handle_t>;
using super = handle<datagram_sink_handle, invalid_datagram_sink_handle_t>;
constexpr datagram_sink_handle() {
// nop
}
constexpr datagram_sink_handle(const invalid_datagram_sink_handle_t&) {
// nop
}
template <class Inspector>
friend typename Inspector::result_type inspect(Inspector& f,
datagram_sink_handle& x) {
return f(meta::type_name("datagram_sink_handle"), x.id_);
}
private:
inline datagram_sink_handle(int64_t handle_id) : super(handle_id) {
// nop
}
};
} // namespace io
} // namespace caf
namespace std {
template<>
struct hash<caf::io::datagram_sink_handle> {
size_t operator()(const caf::io::datagram_sink_handle& hdl) const {
hash<int64_t> f;
return f(hdl.id());
}
};
} // namespace std
#endif // CAF_IO_DATAGRAM_SINK_HANDLE_HPP
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_DATAGRAM_SOURCE_HPP
#define CAF_IO_DATAGRAM_SOURCE_HPP
#include "caf/io/broker_servant.hpp"
#include "caf/io/system_messages.hpp"
#include "caf/io/datagram_source_handle.hpp"
#include "caf/io/network/datagram_source_manager.hpp"
namespace caf {
namespace io {
using datagram_source_base = broker_servant<network::datagram_source_manager,
datagram_source_handle,
new_datagram_msg>;
/// Manages reading from a datagram source
/// @ingroup Broker
class datagram_source : public datagram_source_base {
public:
datagram_source(abstract_broker* parent, datagram_source_handle hdl);
~datagram_source();
/// Implicitly starts the read loop on first call.
virtual void configure_read(receive_policy::config config) = 0;
/// Returns the current input buffer.
virtual std::vector<char>& rd_buf() = 0;
bool consume(execution_unit* ctx, const void* buf, size_t besize) override;
void io_failure(execution_unit* ctx, network::operation op) override;
protected:
message detach_message() override;
};
} // namespace io
} // namespace caf
#endif // CAF_IO_DATAGRAM_SOURCE_HPP
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_DATAGRAM_SOURCE_HANDLE_HPP
#define CAF_IO_DATAGRAM_SOURCE_HANDLE_HPP
#include <functional>
#include "caf/error.hpp"
#include "caf/io/handle.hpp"
#include "caf/meta/type_name.hpp"
namespace caf {
namespace io {
struct invalid_datagram_source_handle_t {
constexpr invalid_datagram_source_handle_t() {
// nop
}
};
constexpr invalid_datagram_source_handle_t invalid_datagram_source_handle
= invalid_datagram_source_handle_t{};
/// Generic type for identifying a datagram source.
class datagram_source_handle : public handle<datagram_source_handle,
invalid_datagram_source_handle_t> {
public:
friend class handle<datagram_source_handle, invalid_datagram_source_handle_t>;
using super = handle<datagram_source_handle, invalid_datagram_source_handle_t>;
constexpr datagram_source_handle() {
// nop
}
constexpr datagram_source_handle(const invalid_datagram_source_handle_t&) {
// nop
}
template <class Inspector>
friend typename Inspector::result_type inspect(Inspector& f,
datagram_source_handle& x) {
return f(meta::type_name("datagram_source_handle"), x.id_);
}
private:
inline datagram_source_handle(int64_t handle_id) : super(handle_id) {
// nop
}
};
} // namespace io
} // namespace caf
namespace std {
template<>
struct hash<caf::io::datagram_source_handle> {
size_t operator()(const caf::io::datagram_source_handle& hdl) const {
hash<int64_t> f;
return f(hdl.id());
}
};
} // namespace std
#endif // CAF_IO_DATAGRAM_SOURCE_HANDLE_HPP
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_NETWORK_DATAGRAM_SINK_MANGER_HPP
#define CAF_IO_NETWORK_DATAGRAM_SINK_MANGER_HPP
#include "caf/io/network/manager.hpp"
namespace caf {
namespace io {
namespace network {
/// A datagram manager provides callbacks for outgoing
/// datagrams as well as for error handling.
class datagram_sink_manager : public manager {
public:
datagram_sink_manager(abstract_broker* ptr);
~datagram_sink_manager();
/// Called by the underlying I/O device whenever it sent a datagram.
virtual void datagram_sent(execution_unit* ctx, size_t num_bytes) = 0;
};
} // namespace network
} // namespace io
} // namespace caf
#endif // CAF_IO_NETWORK_DATAGRAM_SINK_MANGER_HPP
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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. *
******************************************************************************/
#ifndef CAF_IO_NETWORK_DATAGRAM_SOURCE_MANGER_HPP
#define CAF_IO_NETWORK_DATAGRAM_SOURCE_MANGER_HPP
#include "caf/io/network/manager.hpp"
namespace caf {
namespace io {
namespace network {
/// A datagram source manager provides callbacks for incoming
/// datagrams as well as for error handling.
class datagram_source_manager : public manager {
public:
datagram_source_manager(abstract_broker* ptr);
~datagram_source_manager();
/// Called by the underlying I/O device whenever it received data.
/// @returns `true` if the manager accepts further reads, otherwise `false`.
virtual bool consume(execution_unit* ctx, const void* buf, size_t besize) = 0;
};
} // namespace network
} // namespace io
} // namespace caf
#endif // CAF_IO_NETWORK_DATAGRAM_SOURCE_MANGER_HPP
...@@ -30,6 +30,8 @@ ...@@ -30,6 +30,8 @@
#include "caf/io/handle.hpp" #include "caf/io/handle.hpp"
#include "caf/io/accept_handle.hpp" #include "caf/io/accept_handle.hpp"
#include "caf/io/connection_handle.hpp" #include "caf/io/connection_handle.hpp"
#include "caf/io/datagram_sink_handle.hpp"
#include "caf/io/datagram_source_handle.hpp"
namespace caf { namespace caf {
namespace io { namespace io {
...@@ -126,6 +128,58 @@ inspect(Inspector& f, acceptor_passivated_msg& x) { ...@@ -126,6 +128,58 @@ inspect(Inspector& f, acceptor_passivated_msg& x) {
return f(meta::type_name("acceptor_passivated_msg"), x.handle); return f(meta::type_name("acceptor_passivated_msg"), x.handle);
} }
/// Signalizes that a {@link broker} datagram sink was closed.
struct datagram_sink_closed_msg {
datagram_sink_handle handle;
};
/// @relates datagram_sink_closed_msg
template <class Inspector>
typename Inspector::result_type
inspect(Inspector& f, datagram_sink_closed_msg& x) {
return f(meta::type_name("datagram_sink_closed_msg"), x.handle);
}
/// Signalizes that a {@link broker} datagram source was closed.
struct datagram_source_closed_msg {
datagram_source_handle handle;
};
/// @relates datagram_source_closed_msg
template <class Inspector>
typename Inspector::result_type
inspect(Inspector& f, datagram_source_closed_msg& x) {
return f(meta::type_name("datagram_source_closed_msg"), x.handle);
}
/// Signalizes that a datagram with a certain size has been sent.
struct datagram_sent_msg {
// Handle to the endpoint used.
datagram_sink_handle handle;
// number of bytes written.
uint64_t written;
};
/// @relates datagram_sent_msg
template <class Inspector>
typename Inspector::result_type inspect(Inspector& f, datagram_sent_msg& x) {
return f(meta::type_name("datagram_sent_msg"), x.handle, x.written);
}
/// Signalizes newly arrived datagram for a {@link broker}.
struct new_datagram_msg {
/// Handle to the related datagram endpoint.
datagram_source_handle handle;
/// Buffer containing the received data.
std::vector<char> buf;
};
/// @relates new_datagram_msg
template <class Inspector>
typename Inspector::result_type inspect(Inspector& f, new_datagram_msg& x) {
return f(meta::type_name("new_datagram_msg"), x.handle, x.buf);
}
} // namespace io } // namespace io
} // namespace caf } // namespace caf
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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/io/datagram_sink.hpp"
#include "caf/logger.hpp"
namespace caf {
namespace io {
datagram_sink::datagram_sink(abstract_broker* parent, datagram_sink_handle hdl)
: datagram_sink_base(parent, hdl) {
// nop
}
datagram_sink::~datagram_sink() {
CAF_LOG_TRACE("");
}
message datagram_sink::detach_message() {
return make_message(endpoint_closed_msg{hdl()});
}
void datagram_sink::datagram_sent(execution_unit* ctx, size_t written) {
CAF_LOG_TRACE(CAF_ARG(written));
if (detached())
return;
using sent_t = datagram_sent_msg;
using tmp_t = mailbox_element_vals<datagram_sent_msg>;
tmp_t tmp{strong_actor_ptr{}, message_id::make(),
mailbox_element::forwarding_stack{},
sent_t{hdl(), written}};
invoke_mailbox_element_impl(ctx, tmp);
}
void datagram_sink::io_failure(execution_unit* ctx, network::operation op) {
CAF_LOG_TRACE(CAF_ARG(hdl()) << CAF_ARG(op));
// keep compiler happy when compiling w/o logging
static_cast<void>(op);
detach(ctx, true);
}
} // namespace io
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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/io/network/datagram_sink_manager.hpp"
namespace caf {
namespace io {
namespace network {
datagram_sink_manager::datagram_sink_manager(abstract_broker* ptr)
: manager(ptr) {
// nop
}
datagram_sink_manager::~datagram_sink_manager() {
// nop
}
} // namespace network
} // namespace io
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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/io/datagram_source.hpp"
#include "caf/logger.hpp"
namespace caf {
namespace io {
datagram_source::datagram_source(abstract_broker* parent,
datagram_source_handle hdl)
: datagram_source_base(parent, hdl) {
// nop
}
/*
datagram_source::~datagram_source() {
CAF_LOG_TRACE("");
}
message datagram_source::detach_message() {
return make_message(endpoint_closed_msg{hdl()});
}
bool datagram_source::consume(execution_unit* ctx, const void*,
size_t num_bytes) {
CAF_ASSERT(ctx != nullptr);
CAF_LOG_TRACE(CAF_ARG(num_bytes));
if (detached())
// we are already disconnected from the broker while the multiplexer
// did not yet remove the socket, this can happen if an I/O event causes
// the broker to call close_all() while the pollset contained
// further activities for the broker
return false;
// keep a strong reference to our parent until we leave scope
// to avoid UB when becoming detached during invocation
auto guard = parent_;
auto& buf = rd_buf();
CAF_ASSERT(buf.size() >= num_bytes);
// make sure size is correct, swap into message, and then call client
buf.resize(num_bytes);
auto& msg_buf = msg().buf;
msg_buf.swap(buf);
auto result = invoke_mailbox_element(ctx);
// swap buffer back to stream and implicitly flush wr_buf()
msg_buf.swap(buf);
// flush(); // <-- TODO: here from scribe, not sure why?
return result;
}
void datagram_source::io_failure(execution_unit* ctx, network::operation op) {
CAF_LOG_TRACE(CAF_ARG(hdl()) << CAF_ARG(op));
// keep compiler happy when compiling w/o logging
static_cast<void>(op);
detach(ctx, true);
}
*/
} // namespace io
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2016 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* 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/io/network/datagram_source_manager.hpp"
namespace caf {
namespace io {
namespace network {
datagram_source_manager::datagram_source_manager(abstract_broker* ptr)
: manager(ptr) {
// nop
}
datagram_source_manager::~datagram_source_manager() {
// nop
}
} // namespace network
} // namespace io
} // namespace caf
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