diff options
author | 2015-08-24 13:22:48 +0300 | |
---|---|---|
committer | 2015-08-24 13:22:48 +0300 | |
commit | dab741a80699f86e86c91718872a052cca9bbb25 (patch) | |
tree | 1959c4a2cea440170a5113dcb067796cb20ffb64 /external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp | |
parent | d3f26ece7d4383df0b22fe9c3cb3e695381ec737 (diff) |
Fixed dependencies of Control Plane to use external_lib sources
Diffstat (limited to 'external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp')
-rw-r--r-- | external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp | 144 |
1 files changed, 144 insertions, 0 deletions
diff --git a/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp b/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp new file mode 100644 index 00000000..46fe2441 --- /dev/null +++ b/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/dbuffer.hpp @@ -0,0 +1,144 @@ +/* + Copyright (c) 2007-2015 Contributors as noted in the AUTHORS file + + This file is part of libzmq, the ZeroMQ core engine in C++. + + libzmq is free software; you can redistribute it and/or modify it under + the terms of the GNU Lesser General Public License (LGPL) as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + As a special exception, the Contributors give you permission to link + this library with independent modules to produce an executable, + regardless of the license terms of these independent modules, and to + copy and distribute the resulting executable under terms of your choice, + provided that you also meet, for each linked independent module, the + terms and conditions of the license of that module. An independent + module is a module which is not derived from or based on this library. + If you modify this library, you must extend this exception to your + version of the library. + + libzmq is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __ZMQ_DBUFFER_HPP_INCLUDED__ +#define __ZMQ_DBUFFER_HPP_INCLUDED__ + +#include <stdlib.h> +#include <stddef.h> +#include <algorithm> + +#include "mutex.hpp" +#include "msg.hpp" + +namespace zmq +{ + + // dbuffer is a single-producer single-consumer double-buffer + // implementation. + // + // The producer writes to a back buffer and then tries to swap + // pointers between the back and front buffers. If it fails, + // due to the consumer reading from the front buffer, it just + // gives up, which is ok since writes are many and redundant. + // + // The reader simply reads from the front buffer. + // + // has_msg keeps track of whether there has been a not yet read + // value written, it is used by ypipe_conflate to mimic ypipe + // functionality regarding a reader being asleep + + template <typename T> class dbuffer_t; + + template <> class dbuffer_t<msg_t> + { + public: + + inline dbuffer_t () + : back (&storage[0]) + , front (&storage[1]) + , has_msg (false) + { + back->init (); + front->init (); + } + + inline ~dbuffer_t() + { + back->close (); + front->close (); + } + + inline void write (const msg_t &value_) + { + msg_t& xvalue = const_cast<msg_t&>(value_); + + zmq_assert (xvalue.check ()); + back->move (xvalue); // cannot just overwrite, might leak + + zmq_assert (back->check ()); + + if (sync.try_lock ()) + { + std::swap (back, front); + has_msg = true; + + sync.unlock (); + } + } + + inline bool read (msg_t *value_) + { + if (!value_) + return false; + + { + scoped_lock_t lock (sync); + if (!has_msg) + return false; + + zmq_assert (front->check ()); + + *value_ = *front; + front->init (); // avoid double free + + has_msg = false; + return true; + } + } + + + inline bool check_read () + { + scoped_lock_t lock (sync); + + return has_msg; + } + + inline bool probe (bool (*fn)(const msg_t &)) + { + scoped_lock_t lock (sync); + return (*fn) (*front); + } + + + private: + msg_t storage[2]; + msg_t *back, *front; + + mutex_t sync; + bool has_msg; + + // Disable copying of dbuffer. + dbuffer_t (const dbuffer_t&); + const dbuffer_t &operator = (const dbuffer_t&); + }; +} + +#endif |