generic-library/cppzmq
1
0
Fork 0
mirror of https://github.com/zeromq/cppzmq.git synced 2025-03-04 07:27:27 +01:00
Code Issues Projects Releases Wiki Activity

Problem: zmq_addon.hpp not follow clang-format

Browse Source
This commit is contained in:
Pawel Kurdybacha 2018-05-11 20:32:23 +01:00
parent 5031278f18
commit cd72eef3fd
1 changed files with 208 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

496
zmq_addon.hpp
View File

@ -31,8 +31,8 @@
#include <sstream>
#include <stdexcept>
namespace zmq {
namespace zmq
{
#ifdef ZMQ_HAS_RVALUE_REFS
/*
@ -44,479 +44,399 @@ namespace zmq {
*/
class multipart_t
{
private:
private:
std::deque<message_t> m_parts;
public:
public:
typedef std::deque<message_t>::iterator iterator;
typedef std::deque<message_t>::const_iterator const_iterator;
typedef std::deque<message_t>::reverse_iterator reverse_iterator;
typedef std::deque<message_t>::const_reverse_iterator const_reverse_iterator;
typedef std::deque<message_t>::const_reverse_iterator
const_reverse_iterator;
// Default constructor
multipart_t()
{}
multipart_t () {}
// Construct from socket receive
multipart_t(socket_t& socket)
{
recv(socket);
}
multipart_t (socket_t &socket) { recv (socket); }
// Construct from memory block
multipart_t(const void *src, size_t size)
{
addmem(src, size);
}
multipart_t (const void *src, size_t size) { addmem (src, size); }
// Construct from string
multipart_t(const std::string& string)
{
addstr(string);
}
multipart_t (const std::string &string) { addstr (string); }
// Construct from message part
multipart_t(message_t&& message)
{
add(std::move(message));
}
multipart_t (message_t &&message) { add (std::move (message)); }
// Move constructor
multipart_t(multipart_t&& other)
{
m_parts = std::move(other.m_parts);
}
multipart_t (multipart_t &&other) { m_parts = std::move (other.m_parts); }
// Move assignment operator
multipart_t& operator=(multipart_t&& other)
multipart_t &operator= (multipart_t &&other)
{
m_parts = std::move(other.m_parts);
m_parts = std::move (other.m_parts);
return *this;
}
// Destructor
virtual ~multipart_t()
{
clear();
}
virtual ~multipart_t () { clear (); }
message_t& operator[] (size_t n)
{
return m_parts[n];
}
message_t &operator[] (size_t n) { return m_parts[n]; }
const message_t& operator[] (size_t n) const
{
return m_parts[n];
}
const message_t &operator[] (size_t n) const { return m_parts[n]; }
message_t& at (size_t n)
{
return m_parts.at(n);
}
message_t &at (size_t n) { return m_parts.at (n); }
const message_t& at (size_t n) const
{
return m_parts.at(n);
}
const message_t &at (size_t n) const { return m_parts.at (n); }
iterator begin()
{
return m_parts.begin();
}
iterator begin () { return m_parts.begin (); }
const_iterator begin() const
{
return m_parts.begin();
}
const_iterator begin () const { return m_parts.begin (); }
const_iterator cbegin() const
{
return m_parts.cbegin();
}
const_iterator cbegin () const { return m_parts.cbegin (); }
reverse_iterator rbegin()
{
return m_parts.rbegin();
}
reverse_iterator rbegin () { return m_parts.rbegin (); }
const_reverse_iterator rbegin() const
{
return m_parts.rbegin();
}
const_reverse_iterator rbegin () const { return m_parts.rbegin (); }
iterator end()
{
return m_parts.end();
}
iterator end () { return m_parts.end (); }
const_iterator end() const
{
return m_parts.end();
}
const_iterator end () const { return m_parts.end (); }
const_iterator cend() const
{
return m_parts.cend();
}
const_iterator cend () const { return m_parts.cend (); }
reverse_iterator rend()
{
return m_parts.rend();
}
reverse_iterator rend () { return m_parts.rend (); }
const_reverse_iterator rend() const
{
return m_parts.rend();
}
const_reverse_iterator rend () const { return m_parts.rend (); }
// Delete all parts
void clear()
{
m_parts.clear();
}
void clear () { m_parts.clear (); }
// Get number of parts
size_t size() const
{
return m_parts.size();
}
size_t size () const { return m_parts.size (); }
// Check if number of parts is zero
bool empty() const
{
return m_parts.empty();
}
bool empty () const { return m_parts.empty (); }
// Receive multipart message from socket
bool recv(socket_t& socket, int flags = 0)
bool recv (socket_t &socket, int flags = 0)
{
clear();
clear ();
bool more = true;
while (more)
{
while (more) {
message_t message;
if (!socket.recv(&message, flags))
if (!socket.recv (&message, flags))
return false;
more = message.more();
add(std::move(message));
more = message.more ();
add (std::move (message));
}
return true;
}
// Send multipart message to socket
bool send(socket_t& socket, int flags = 0)
bool send (socket_t &socket, int flags = 0)
{
flags &= ~(ZMQ_SNDMORE);
bool more = size() > 0;
while (more)
{
message_t message = pop();
more = size() > 0;
if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
bool more = size () > 0;
while (more) {
message_t message = pop ();
more = size () > 0;
if (!socket.send (message, (more ? ZMQ_SNDMORE : 0) | flags))
return false;
}
clear();
clear ();
return true;
}
// Concatenate other multipart to front
void prepend(multipart_t&& other)
void prepend (multipart_t &&other)
{
while (!other.empty())
push(other.remove());
while (!other.empty ())
push (other.remove ());
}
// Concatenate other multipart to back
void append(multipart_t&& other)
void append (multipart_t &&other)
{
while (!other.empty())
add(other.pop());
while (!other.empty ())
add (other.pop ());
}
// Push memory block to front
void pushmem(const void *src, size_t size)
void pushmem (const void *src, size_t size)
{
m_parts.push_front(message_t(src, size));
m_parts.push_front (message_t (src, size));
}
// Push memory block to back
void addmem(const void *src, size_t size)
void addmem (const void *src, size_t size)
{
m_parts.push_back(message_t(src, size));
m_parts.push_back (message_t (src, size));
}
// Push string to front
void pushstr(const std::string& string)
void pushstr (const std::string &string)
{
m_parts.push_front(message_t(string.data(), string.size()));
m_parts.push_front (message_t (string.data (), string.size ()));
}
// Push string to back
void addstr(const std::string& string)
void addstr (const std::string &string)
{
m_parts.push_back(message_t(string.data(), string.size()));
m_parts.push_back (message_t (string.data (), string.size ()));
}
// Push type (fixed-size) to front
template<typename T>
void pushtyp(const T& type)
template <typename T> void pushtyp (const T &type)
{
static_assert(!std::is_same<T, std::string>::value, "Use pushstr() instead of pushtyp<std::string>()");
m_parts.push_front(message_t(&type, sizeof(type)));
static_assert (!std::is_same<T, std::string>::value,
"Use pushstr() instead of pushtyp<std::string>()");
m_parts.push_front (message_t (&type, sizeof (type)));
}
// Push type (fixed-size) to back
template<typename T>
void addtyp(const T& type)
template <typename T> void addtyp (const T &type)
{
static_assert(!std::is_same<T, std::string>::value, "Use addstr() instead of addtyp<std::string>()");
m_parts.push_back(message_t(&type, sizeof(type)));
static_assert (!std::is_same<T, std::string>::value,
"Use addstr() instead of addtyp<std::string>()");
m_parts.push_back (message_t (&type, sizeof (type)));
}
// Push message part to front
void push(message_t&& message)
void push (message_t &&message)
{
m_parts.push_front(std::move(message));
m_parts.push_front (std::move (message));
}
// Push message part to back
void add(message_t&& message)
{
m_parts.push_back(std::move(message));
}
void add (message_t &&message) { m_parts.push_back (std::move (message)); }
// Pop string from front
std::string popstr()
std::string popstr ()
{
std::string string(m_parts.front().data<char>(), m_parts.front().size());
m_parts.pop_front();
std::string string (m_parts.front ().data<char> (),
m_parts.front ().size ());
m_parts.pop_front ();
return string;
}
// Pop type (fixed-size) from front
template<typename T>
T poptyp()
template <typename T> T poptyp ()
{
static_assert(!std::is_same<T, std::string>::value, "Use popstr() instead of poptyp<std::string>()");
if (sizeof(T) != m_parts.front().size())
throw std::runtime_error("Invalid type, size does not match the message size");
T type = *m_parts.front().data<T>();
m_parts.pop_front();
static_assert (!std::is_same<T, std::string>::value,
"Use popstr() instead of poptyp<std::string>()");
if (sizeof (T) != m_parts.front ().size ())
throw std::runtime_error (
"Invalid type, size does not match the message size");
T type = *m_parts.front ().data<T> ();
m_parts.pop_front ();
return type;
}
// Pop message part from front
message_t pop()
message_t pop ()
{
message_t message = std::move(m_parts.front());
m_parts.pop_front();
message_t message = std::move (m_parts.front ());
m_parts.pop_front ();
return message;
}
// Pop message part from back
message_t remove()
message_t remove ()
{
message_t message = std::move(m_parts.back());
m_parts.pop_back();
message_t message = std::move (m_parts.back ());
m_parts.pop_back ();
return message;
}
// Get pointer to a specific message part
const message_t* peek(size_t index) const
{
return &m_parts[index];
}
const message_t *peek (size_t index) const { return &m_parts[index]; }
// Get a string copy of a specific message part
std::string peekstr(size_t index) const
std::string peekstr (size_t index) const
{
std::string string(m_parts[index].data<char>(), m_parts[index].size());
std::string string (m_parts[index].data<char> (),
m_parts[index].size ());
return string;
}
// Peek type (fixed-size) from front
template<typename T>
T peektyp(size_t index) const
template <typename T> T peektyp (size_t index) const
{
static_assert(!std::is_same<T, std::string>::value, "Use peekstr() instead of peektyp<std::string>()");
if(sizeof(T) != m_parts[index].size())
throw std::runtime_error("Invalid type, size does not match the message size");
T type = *m_parts[index].data<T>();
static_assert (!std::is_same<T, std::string>::value,
"Use peekstr() instead of peektyp<std::string>()");
if (sizeof (T) != m_parts[index].size ())
throw std::runtime_error (
"Invalid type, size does not match the message size");
T type = *m_parts[index].data<T> ();
return type;
}
// Create multipart from type (fixed-size)
template<typename T>
static multipart_t create(const T& type)
template <typename T> static multipart_t create (const T &type)
{
multipart_t multipart;
multipart.addtyp(type);
multipart.addtyp (type);
return multipart;
}
// Copy multipart
multipart_t clone() const
multipart_t clone () const
{
multipart_t multipart;
for (size_t i = 0; i < size(); i++)
multipart.addmem(m_parts[i].data(), m_parts[i].size());
for (size_t i = 0; i < size (); i++)
multipart.addmem (m_parts[i].data (), m_parts[i].size ());
return multipart;
}
// Dump content to string
std::string str() const
std::string str () const
{
std::stringstream ss;
for (size_t i = 0; i < m_parts.size(); i++)
{
const unsigned char* data = m_parts[i].data<unsigned char>();
size_t size = m_parts[i].size();
for (size_t i = 0; i < m_parts.size (); i++) {
const unsigned char *data = m_parts[i].data<unsigned char> ();
size_t size = m_parts[i].size ();
// Dump the message as text or binary
bool isText = true;
for (size_t j = 0; j < size; j++)
{
if (data[j] < 32 || data[j] > 127)
{
for (size_t j = 0; j < size; j++) {
if (data[j] < 32 || data[j] > 127) {
isText = false;
break;
}
}
ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size << "] ";
if (size >= 1000)
{
ss << "\n[" << std::dec << std::setw (3) << std::setfill ('0')
<< size << "] ";
if (size >= 1000) {
ss << "... (to big to print)";
continue;
}
for (size_t j = 0; j < size; j++)
{
for (size_t j = 0; j < size; j++) {
if (isText)
ss << static_cast<char>(data[j]);
ss << static_cast<char> (data[j]);
else
ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<short>(data[j]);
ss << std::hex << std::setw (2) << std::setfill ('0')
<< static_cast<short> (data[j]);
}
}
return ss.str();
return ss.str ();
}
// Check if equal to other multipart
bool equal(const multipart_t* other) const
bool equal (const multipart_t *other) const
{
if (size() != other->size())
if (size () != other->size ())
return false;
for (size_t i = 0; i < size(); i++)
if (*peek(i) != *other->peek(i))
for (size_t i = 0; i < size (); i++)
if (*peek (i) != *other->peek (i))
return false;
return true;
}
private:
private:
// Disable implicit copying (moving is more efficient)
multipart_t(const multipart_t& other) ZMQ_DELETED_FUNCTION;
void operator=(const multipart_t& other) ZMQ_DELETED_FUNCTION;
}; // class multipart_t
multipart_t (const multipart_t &other) ZMQ_DELETED_FUNCTION;
void operator= (const multipart_t &other) ZMQ_DELETED_FUNCTION;
}; // class multipart_t
inline std::ostream& operator<<(std::ostream& os, const multipart_t& msg)
inline std::ostream &operator<< (std::ostream &os, const multipart_t &msg)
{
return os << msg.str();
return os << msg.str ();
}
#endif // ZMQ_HAS_RVALUE_REFS
#endif // ZMQ_HAS_RVALUE_REFS
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
class active_poller_t
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \
&& defined(ZMQ_HAVE_POLLER)
class active_poller_t
{
public:
active_poller_t () = default;
~active_poller_t () = default;
active_poller_t (const active_poller_t &) = delete;
active_poller_t &operator= (const active_poller_t &) = delete;
active_poller_t (active_poller_t &&src) = default;
active_poller_t &operator= (active_poller_t &&src) = default;
using handler_t = std::function<void(short)>;
void add (zmq::socket_t &socket, short events, handler_t handler)
{
public:
active_poller_t () = default;
~active_poller_t () = default;
active_poller_t(const active_poller_t&) = delete;
active_poller_t &operator=(const active_poller_t&) = delete;
active_poller_t(active_poller_t&& src) = default;
active_poller_t &operator=(active_poller_t&& src) = default;
using handler_t = std::function<void(short)>;
void add (zmq::socket_t &socket, short events, handler_t handler)
{
auto it = decltype (handlers)::iterator {};
auto inserted = bool {};
std::tie(it, inserted) = handlers.emplace (static_cast<void*>(socket), std::make_shared<handler_t> (std::move (handler)));
try
{
base_poller.add (socket, events, inserted && *(it->second) ? it->second.get() : nullptr);
need_rebuild |= inserted;
auto it = decltype (handlers)::iterator{};
auto inserted = bool{};
std::tie (it, inserted) =
handlers.emplace (static_cast<void *> (socket),
std::make_shared<handler_t> (std::move (handler)));
try {
base_poller.add (socket, events,
inserted && *(it->second) ? it->second.get ()
: nullptr);
need_rebuild |= inserted;
}
catch (const zmq::error_t &) {
// rollback
if (inserted) {
handlers.erase (static_cast<void *> (socket));
}
catch (const zmq::error_t&)
{
// rollback
if (inserted)
{
handlers.erase (static_cast<void*>(socket));
}
throw;
throw;
}
}
void remove (zmq::socket_t &socket)
{
base_poller.remove (socket);
handlers.erase (static_cast<void *> (socket));
need_rebuild = true;
}
void modify (zmq::socket_t &socket, short events)
{
base_poller.modify (socket, events);
}
int wait (std::chrono::milliseconds timeout)
{
if (need_rebuild) {
poller_events.resize (handlers.size ());
poller_handlers.clear ();
poller_handlers.reserve (handlers.size ());
for (const auto &handler : handlers) {
poller_handlers.push_back (handler.second);
}
need_rebuild = false;
}
void remove (zmq::socket_t &socket)
{
base_poller.remove (socket);
handlers.erase (static_cast<void*>(socket));
need_rebuild = true;
const int count = base_poller.wait_all (poller_events, timeout);
if (count != 0) {
std::for_each (poller_events.begin (),
poller_events.begin () + count,
[](zmq_poller_event_t &event) {
if (event.user_data != NULL)
(*reinterpret_cast<handler_t *> (
event.user_data)) (event.events);
});
}
return count;
}
void modify (zmq::socket_t &socket, short events)
{
base_poller.modify (socket, events);
}
bool empty () const { return handlers.empty (); }
int wait (std::chrono::milliseconds timeout)
{
if (need_rebuild) {
poller_events.resize (handlers.size ());
poller_handlers.clear ();
poller_handlers.reserve (handlers.size ());
for (const auto &handler : handlers) {
poller_handlers.push_back (handler.second);
}
need_rebuild = false;
}
const int count = base_poller.wait_all (poller_events, timeout);
if (count != 0) {
std::for_each (poller_events.begin (), poller_events.begin () + count,
[](zmq_poller_event_t& event) {
if (event.user_data != NULL)
(*reinterpret_cast<handler_t*> (event.user_data)) (event.events);
});
}
return count;
}
size_t size () const { return handlers.size (); }
bool empty () const
{
return handlers.empty ();
}
private:
bool need_rebuild{false};
size_t size () const
{
return handlers.size ();
}
private:
bool need_rebuild {false};
poller_t<handler_t> base_poller {};
std::unordered_map<void*, std::shared_ptr<handler_t>> handlers {};
std::vector<zmq_poller_event_t> poller_events {};
std::vector<std::shared_ptr<handler_t>> poller_handlers {};
}; // class active_poller_t
poller_t<handler_t> base_poller{};
std::unordered_map<void *, std::shared_ptr<handler_t>> handlers{};
std::vector<zmq_poller_event_t> poller_events{};
std::vector<std::shared_ptr<handler_t>> poller_handlers{};
}; // class active_poller_t
#endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
} // namespace zmq
} // namespace zmq
#endif // __ZMQ_ADDON_HPP_INCLUDED__
#endif // __ZMQ_ADDON_HPP_INCLUDED__