generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-11-07 05:58:45 +01:00
Code Issues Projects Releases Wiki Activity

Problem: inconsistent naming style for private data members, conflicts with naming of local variables and member functions

Browse Source 
Solution: apply and check _lower_case naming style for private data members
This commit is contained in:
Simon Giesecke
2018-05-27 11:10:39 +02:00
parent 06cfd0d8ad
commit e3c73d9881
143 changed files with 5783 additions and 4051 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/v2_decoder.cpp
View File

@@ -42,51 +42,51 @@ zmq::v2_decoder_t::v2_decoder_t (size_t bufsize_,
int64_t maxmsgsize_,
bool zero_copy_) :
decoder_base_t<v2_decoder_t, shared_message_memory_allocator> (bufsize_),
msg_flags (0),
zero_copy (zero_copy_),
maxmsgsize (maxmsgsize_)
_msg_flags (0),
_zero_copy (zero_copy_),
_max_msg_size (maxmsgsize_)
{
int rc = in_progress.init ();
int rc = _in_progress.init ();
errno_assert (rc == 0);
// At the beginning, read one byte and go to flags_ready state.
next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
next_step (_tmpbuf, 1, &v2_decoder_t::flags_ready);
}
zmq::v2_decoder_t::~v2_decoder_t ()
{
int rc = in_progress.close ();
int rc = _in_progress.close ();
errno_assert (rc == 0);
}
int zmq::v2_decoder_t::flags_ready (unsigned char const *)
{
msg_flags = 0;
if (tmpbuf[0] & v2_protocol_t::more_flag)
msg_flags |= msg_t::more;
if (tmpbuf[0] & v2_protocol_t::command_flag)
msg_flags |= msg_t::command;
_msg_flags = 0;
if (_tmpbuf[0] & v2_protocol_t::more_flag)
_msg_flags |= msg_t::more;
if (_tmpbuf[0] & v2_protocol_t::command_flag)
_msg_flags |= msg_t::command;
// The payload length is either one or eight bytes,
// depending on whether the 'large' bit is set.
if (tmpbuf[0] & v2_protocol_t::large_flag)
next_step (tmpbuf, 8, &v2_decoder_t::eight_byte_size_ready);
if (_tmpbuf[0] & v2_protocol_t::large_flag)
next_step (_tmpbuf, 8, &v2_decoder_t::eight_byte_size_ready);
else
next_step (tmpbuf, 1, &v2_decoder_t::one_byte_size_ready);
next_step (_tmpbuf, 1, &v2_decoder_t::one_byte_size_ready);
return 0;
}
int zmq::v2_decoder_t::one_byte_size_ready (unsigned char const *read_from_)
{
return size_ready (tmpbuf[0], read_from_);
return size_ready (_tmpbuf[0], read_from_);
}
int zmq::v2_decoder_t::eight_byte_size_ready (unsigned char const *read_from_)
{
// The payload size is encoded as 64-bit unsigned integer.
// The most significant byte comes first.
const uint64_t msg_size = get_uint64 (tmpbuf);
const uint64_t msg_size = get_uint64 (_tmpbuf);
return size_ready (msg_size, read_from_);
}
@@ -95,8 +95,8 @@ int zmq::v2_decoder_t::size_ready (uint64_t msg_size_,
unsigned char const *read_pos_)
{
// Message size must not exceed the maximum allowed size.
if (maxmsgsize >= 0)
if (unlikely (msg_size_ > static_cast<uint64_t> (maxmsgsize))) {
if (_max_msg_size >= 0)
if (unlikely (msg_size_ > static_cast<uint64_t> (_max_msg_size))) {
errno = EMSGSIZE;
return -1;
}
@@ -107,31 +107,31 @@ int zmq::v2_decoder_t::size_ready (uint64_t msg_size_,
return -1;
}
int rc = in_progress.close ();
int rc = _in_progress.close ();
assert (rc == 0);
// the current message can exceed the current buffer. We have to copy the buffer
// data into a new message and complete it in the next receive.
shared_message_memory_allocator &allocator = get_allocator ();
if (unlikely (!zero_copy
if (unlikely (!_zero_copy
|| ((unsigned char *) read_pos_ + msg_size_
> (allocator.data () + allocator.size ())))) {
// a new message has started, but the size would exceed the pre-allocated arena
// this happens every time when a message does not fit completely into the buffer
rc = in_progress.init_size (static_cast<size_t> (msg_size_));
rc = _in_progress.init_size (static_cast<size_t> (msg_size_));
} else {
// construct message using n bytes from the buffer as storage
// increase buffer ref count
// if the message will be a large message, pass a valid refcnt memory location as well
rc =
in_progress.init (const_cast<unsigned char *> (read_pos_),
static_cast<size_t> (msg_size_),
shared_message_memory_allocator::call_dec_ref,
allocator.buffer (), allocator.provide_content ());
_in_progress.init (const_cast<unsigned char *> (read_pos_),
static_cast<size_t> (msg_size_),
shared_message_memory_allocator::call_dec_ref,
allocator.buffer (), allocator.provide_content ());
// For small messages, data has been copied and refcount does not have to be increased
if (in_progress.is_zcmsg ()) {
if (_in_progress.is_zcmsg ()) {
allocator.advance_content ();
allocator.inc_ref ();
}
@@ -139,20 +139,20 @@ int zmq::v2_decoder_t::size_ready (uint64_t msg_size_,
if (unlikely (rc)) {
errno_assert (errno == ENOMEM);
rc = in_progress.init ();
rc = _in_progress.init ();
errno_assert (rc == 0);
errno = ENOMEM;
return -1;
}
in_progress.set_flags (msg_flags);
_in_progress.set_flags (_msg_flags);
// this sets read_pos to
// the message data address if the data needs to be copied
// for small message / messages exceeding the current buffer
// or
// to the current start address in the buffer because the message
// was constructed to use n bytes from the address passed as argument
next_step (in_progress.data (), in_progress.size (),
next_step (_in_progress.data (), _in_progress.size (),
&v2_decoder_t::message_ready);
return 0;
@@ -162,6 +162,6 @@ int zmq::v2_decoder_t::message_ready (unsigned char const *)
{
// Message is completely read. Signal this to the caller
// and prepare to decode next message.
next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
next_step (_tmpbuf, 1, &v2_decoder_t::flags_ready);
return 1;
}