generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-10-30 13:47:13 +01:00
Code Issues Projects Releases Wiki Activity

Problem: formatting inconsistent

Browse Source 
Solution: applied clang-format
This commit is contained in:
sigiesec
2018-02-01 11:46:09 +01:00
parent 6d8baea714
commit 41f459e1dc
331 changed files with 13208 additions and 13691 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
src/mtrie.cpp
View File

@@ -38,25 +38,20 @@
#include "macros.hpp"
#include "mtrie.hpp"
zmq::mtrie_t::mtrie_t () :
pipes (0),
min (0),
count (0),
live_nodes (0)
zmq::mtrie_t::mtrie_t () : pipes (0), min (0), count (0), live_nodes (0)
{
}
zmq::mtrie_t::~mtrie_t ()
{
LIBZMQ_DELETE(pipes);
LIBZMQ_DELETE (pipes);
if (count == 1) {
zmq_assert (next.node);
LIBZMQ_DELETE(next.node);
}
else if (count > 1) {
LIBZMQ_DELETE (next.node);
} else if (count > 1) {
for (unsigned short i = 0; i != count; ++i) {
LIBZMQ_DELETE(next.table[i]);
LIBZMQ_DELETE (next.table[i]);
}
free (next.table);
}
@@ -67,8 +62,9 @@ bool zmq::mtrie_t::add (unsigned char *prefix_, size_t size_, pipe_t *pipe_)
return add_helper (prefix_, size_, pipe_);
}
bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
pipe_t *pipe_)
bool zmq::mtrie_t::add_helper (unsigned char *prefix_,
size_t size_,
pipe_t *pipe_)
{
// We are at the node corresponding to the prefix. We are done.
if (!size_) {
@@ -83,49 +79,42 @@ bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
unsigned char c = *prefix_;
if (c < min || c >= min + count) {
// The character is out of range of currently handled
// characters. We have to extend the table.
if (!count) {
min = c;
count = 1;
next.node = NULL;
}
else
if (count == 1) {
} else if (count == 1) {
unsigned char oldc = min;
mtrie_t *oldp = next.node;
count = (min < c ? c - min : min - c) + 1;
next.table = (mtrie_t**)
malloc (sizeof (mtrie_t*) * count);
next.table = (mtrie_t **) malloc (sizeof (mtrie_t *) * count);
alloc_assert (next.table);
for (unsigned short i = 0; i != count; ++i)
next.table [i] = 0;
next.table[i] = 0;
min = std::min (min, c);
next.table [oldc - min] = oldp;
}
else
if (min < c) {
next.table[oldc - min] = oldp;
} else if (min < c) {
// The new character is above the current character range.
unsigned short old_count = count;
count = c - min + 1;
next.table = (mtrie_t**) realloc (next.table,
sizeof (mtrie_t*) * count);
next.table =
(mtrie_t **) realloc (next.table, sizeof (mtrie_t *) * count);
alloc_assert (next.table);
for (unsigned short i = old_count; i != count; i++)
next.table [i] = NULL;
}
else {
next.table[i] = NULL;
} else {
// The new character is below the current character range.
unsigned short old_count = count;
count = (min + old_count) - c;
next.table = (mtrie_t**) realloc (next.table,
sizeof (mtrie_t*) * count);
next.table =
(mtrie_t **) realloc (next.table, sizeof (mtrie_t *) * count);
alloc_assert (next.table);
memmove (next.table + min - c, next.table,
old_count * sizeof (mtrie_t*));
old_count * sizeof (mtrie_t *));
for (unsigned short i = 0; i != min - c; i++)
next.table [i] = NULL;
next.table[i] = NULL;
min = c;
}
}
@@ -138,31 +127,38 @@ bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
++live_nodes;
}
return next.node->add_helper (prefix_ + 1, size_ - 1, pipe_);
}
else {
if (!next.table [c - min]) {
next.table [c - min] = new (std::nothrow) mtrie_t;
alloc_assert (next.table [c - min]);
} else {
if (!next.table[c - min]) {
next.table[c - min] = new (std::nothrow) mtrie_t;
alloc_assert (next.table[c - min]);
++live_nodes;
}
return next.table [c - min]->add_helper (prefix_ + 1, size_ - 1, pipe_);
return next.table[c - min]->add_helper (prefix_ + 1, size_ - 1, pipe_);
}
}
void zmq::mtrie_t::rm (pipe_t *pipe_,
void (*func_) (unsigned char *data_, size_t size_, void *arg_),
void *arg_, bool call_on_uniq_)
void (*func_) (unsigned char *data_,
size_t size_,
void *arg_),
void *arg_,
bool call_on_uniq_)
{
unsigned char *buff = NULL;
rm_helper (pipe_, &buff, 0, 0, func_, arg_, call_on_uniq_);
free (buff);
}
void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
size_t buffsize_, size_t maxbuffsize_,
void (*func_) (unsigned char *data_, size_t size_, void *arg_),
void *arg_, bool call_on_uniq_)
void zmq::mtrie_t::rm_helper (pipe_t *pipe_,
unsigned char **buff_,
size_t buffsize_,
size_t maxbuffsize_,
void (*func_) (unsigned char *data_,
size_t size_,
void *arg_),
void *arg_,
bool call_on_uniq_)
{
// Remove the subscription from this node.
if (pipes && pipes->erase (pipe_)) {
@@ -171,14 +167,14 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
}
if (pipes->empty ()) {
LIBZMQ_DELETE(pipes);
LIBZMQ_DELETE (pipes);
}
}
// Adjust the buffer.
if (buffsize_ >= maxbuffsize_) {
maxbuffsize_ = buffsize_ + 256;
*buff_ = (unsigned char*) realloc (*buff_, maxbuffsize_);
*buff_ = (unsigned char *) realloc (*buff_, maxbuffsize_);
alloc_assert (*buff_);
}
@@ -188,14 +184,14 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
// If there's one subnode (optimisation).
if (count == 1) {
(*buff_) [buffsize_] = min;
(*buff_)[buffsize_] = min;
buffsize_++;
next.node->rm_helper (pipe_, buff_, buffsize_, maxbuffsize_,
func_, arg_, call_on_uniq_);
next.node->rm_helper (pipe_, buff_, buffsize_, maxbuffsize_, func_,
arg_, call_on_uniq_);
// Prune the node if it was made redundant by the removal
if (next.node->is_redundant ()) {
LIBZMQ_DELETE(next.node);
LIBZMQ_DELETE (next.node);
count = 0;
--live_nodes;
zmq_assert (live_nodes == 0);
@@ -210,19 +206,18 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
// New max non-null character in the node table after the removal
unsigned char new_max = min;
for (unsigned short c = 0; c != count; c++) {
(*buff_) [buffsize_] = min + c;
if (next.table [c]) {
next.table [c]->rm_helper (pipe_, buff_, buffsize_ + 1,
maxbuffsize_, func_, arg_, call_on_uniq_);
(*buff_)[buffsize_] = min + c;
if (next.table[c]) {
next.table[c]->rm_helper (pipe_, buff_, buffsize_ + 1, maxbuffsize_,
func_, arg_, call_on_uniq_);
// Prune redundant nodes from the mtrie
if (next.table [c]->is_redundant ()) {
LIBZMQ_DELETE(next.table[c]);
if (next.table[c]->is_redundant ()) {
LIBZMQ_DELETE (next.table[c]);
zmq_assert (live_nodes > 0);
--live_nodes;
}
else {
} else {
// The node is not redundant, so it's a candidate for being
// the new min/max node.
//
@@ -247,22 +242,19 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
count = 0;
}
// Compact the node table if possible
else
if (live_nodes == 1) {
else if (live_nodes == 1) {
// If there's only one live node in the table we can
// switch to using the more compact single-node
// representation
zmq_assert (new_min == new_max);
zmq_assert (new_min >= min && new_min < min + count);
mtrie_t *node = next.table [new_min - min];
mtrie_t *node = next.table[new_min - min];
zmq_assert (node);
free (next.table);
next.node = node;
count = 1;
min = new_min;
}
else
if (new_min > min || new_max < min + count - 1) {
} else if (new_min > min || new_max < min + count - 1) {
zmq_assert (new_max - new_min + 1 > 1);
mtrie_t **old_table = next.table;
@@ -272,11 +264,11 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
zmq_assert (new_max - new_min + 1 < count);
count = new_max - new_min + 1;
next.table = (mtrie_t**) malloc (sizeof (mtrie_t*) * count);
next.table = (mtrie_t **) malloc (sizeof (mtrie_t *) * count);
alloc_assert (next.table);
memmove (next.table, old_table + (new_min - min),
sizeof (mtrie_t*) * count);
sizeof (mtrie_t *) * count);
free (old_table);
min = new_min;
@@ -288,15 +280,16 @@ bool zmq::mtrie_t::rm (unsigned char *prefix_, size_t size_, pipe_t *pipe_)
return rm_helper (prefix_, size_, pipe_);
}
bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
pipe_t *pipe_)
bool zmq::mtrie_t::rm_helper (unsigned char *prefix_,
size_t size_,
pipe_t *pipe_)
{
if (!size_) {
if (pipes) {
pipes_t::size_type erased = pipes->erase (pipe_);
zmq_assert (erased == 1);
if (pipes->empty ()) {
LIBZMQ_DELETE(pipes);
LIBZMQ_DELETE (pipes);
}
}
return !pipes;
@@ -306,8 +299,7 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
if (!count || c < min || c >= min + count)
return false;
mtrie_t *next_node =
count == 1 ? next.node : next.table [c - min];
mtrie_t *next_node = count == 1 ? next.node : next.table[c - min];
if (!next_node)
return false;
@@ -315,7 +307,7 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
bool ret = next_node->rm_helper (prefix_ + 1, size_ - 1, pipe_);
if (next_node->is_redundant ()) {
LIBZMQ_DELETE(next_node);
LIBZMQ_DELETE (next_node);
zmq_assert (count > 0);
if (count == 1) {
@@ -323,9 +315,8 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
count = 0;
--live_nodes;
zmq_assert (live_nodes == 0);
}
else {
next.table [c - min] = 0;
} else {
next.table[c - min] = 0;
zmq_assert (live_nodes > 1);
--live_nodes;
@@ -336,47 +327,43 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
// representation
unsigned short i;
for (i = 0; i < count; ++i)
if (next.table [i])
if (next.table[i])
break;
zmq_assert (i < count);
min += i;
count = 1;
mtrie_t *oldp = next.table [i];
mtrie_t *oldp = next.table[i];
free (next.table);
next.node = oldp;
}
else
if (c == min) {
} else if (c == min) {
// We can compact the table "from the left"
unsigned short i;
for (i = 1; i < count; ++i)
if (next.table [i])
if (next.table[i])
break;
zmq_assert (i < count);
min += i;
count -= i;
mtrie_t **old_table = next.table;
next.table = (mtrie_t**) malloc (sizeof (mtrie_t*) * count);
next.table = (mtrie_t **) malloc (sizeof (mtrie_t *) * count);
alloc_assert (next.table);
memmove (next.table, old_table + i, sizeof (mtrie_t*) * count);
memmove (next.table, old_table + i, sizeof (mtrie_t *) * count);
free (old_table);
}
else
if (c == min + count - 1) {
} else if (c == min + count - 1) {
// We can compact the table "from the right"
unsigned short i;
for (i = 1; i < count; ++i)
if (next.table [count - 1 - i])
if (next.table[count - 1 - i])
break;
zmq_assert (i < count);
count -= i;
mtrie_t **old_table = next.table;
next.table = (mtrie_t**) malloc (sizeof (mtrie_t*) * count);
next.table = (mtrie_t **) malloc (sizeof (mtrie_t *) * count);
alloc_assert (next.table);
memmove (next.table, old_table, sizeof (mtrie_t*) * count);
memmove (next.table, old_table, sizeof (mtrie_t *) * count);
free (old_table);
}
}
@@ -385,16 +372,17 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
return ret;
}
void zmq::mtrie_t::match (unsigned char *data_, size_t size_,
void (*func_) (pipe_t *pipe_, void *arg_), void *arg_)
void zmq::mtrie_t::match (unsigned char *data_,
size_t size_,
void (*func_) (pipe_t *pipe_, void *arg_),
void *arg_)
{
mtrie_t *current = this;
while (true) {
// Signal the pipes attached to this node.
if (current->pipes) {
for (pipes_t::iterator it = current->pipes->begin ();
it != current->pipes->end (); ++it)
it != current->pipes->end (); ++it)
func_ (*it, arg_);
}
@@ -408,7 +396,7 @@ void zmq::mtrie_t::match (unsigned char *data_, size_t size_,
// If there's one subnode (optimisation).
if (current->count == 1) {
if (data_ [0] != current->min)
if (data_[0] != current->min)
break;
current = current->next.node;
data_++;
@@ -417,12 +405,12 @@ void zmq::mtrie_t::match (unsigned char *data_, size_t size_,
}
// If there are multiple subnodes.
if (data_ [0] < current->min || data_ [0] >=
current->min + current->count)
if (data_[0] < current->min
|| data_[0] >= current->min + current->count)
break;
if (!current->next.table [data_ [0] - current->min])
if (!current->next.table[data_[0] - current->min])
break;
current = current->next.table [data_ [0] - current->min];
current = current->next.table[data_[0] - current->min];
data_++;
size_--;
}