trie.cpp 10.8 KB
Newer Older
1
/*
2
    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
3

4
    This file is part of libzmq, the ZeroMQ core engine in C++.
5

6 7 8
    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
9 10
    (at your option) any later version.

11 12 13 14 15 16 17 18 19 20 21 22 23 24
    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.
25

26
    You should have received a copy of the GNU Lesser General Public License
27 28 29
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

30
#include "precompiled.hpp"
31 32 33 34
#include "macros.hpp"
#include "err.hpp"
#include "trie.hpp"

35 36 37 38 39
#include <stdlib.h>

#include <new>
#include <algorithm>

40
zmq::trie_t::trie_t () :
41 42
    refcnt (0),
    min (0),
43 44
    count (0),
    live_nodes (0)
45 46 47
{
}

48
zmq::trie_t::~trie_t ()
49
{
50 51
    if (count == 1) {
        zmq_assert (next.node);
52
        LIBZMQ_DELETE(next.node);
53
    }
54 55 56 57
    else if (count > 1) {
        for (unsigned short i = 0; i != count; ++i) {
            LIBZMQ_DELETE(next.table[i]);
        }
58 59 60 61
        free (next.table);
    }
}

62
bool zmq::trie_t::add (unsigned char *prefix_, size_t size_)
63 64 65 66
{
    //  We are at the node corresponding to the prefix. We are done.
    if (!size_) {
        ++refcnt;
67
        return refcnt == 1;
68 69 70 71 72 73
    }

    unsigned char c = *prefix_;
    if (c < min || c >= min + count) {

        //  The character is out of range of currently handled
74
        //  characters. We have to extend the table.
75 76 77 78 79
        if (!count) {
            min = c;
            count = 1;
            next.node = NULL;
        }
80 81
        else
        if (count == 1) {
82
            unsigned char oldc = min;
83
            trie_t *oldp = next.node;
84
            count = (min < c ? c - min : min - c) + 1;
85 86
            next.table = (trie_t**)
                malloc (sizeof (trie_t*) * count);
87
            alloc_assert (next.table);
88
            for (unsigned short i = 0; i != count; ++i)
89 90 91 92
                next.table [i] = 0;
            min = std::min (min, c);
            next.table [oldc - min] = oldp;
        }
93 94
        else
        if (min < c) {
95
            //  The new character is above the current character range.
96
            unsigned short old_count = count;
97
            count = c - min + 1;
98 99
            next.table = (trie_t**) realloc ((void*) next.table,
                sizeof (trie_t*) * count);
100
            zmq_assert (next.table);
101
            for (unsigned short i = old_count; i != count; i++)
102 103 104 105 106
                next.table [i] = NULL;
        }
        else {

            //  The new character is below the current character range.
107
            unsigned short old_count = count;
108
            count = (min + old_count) - c;
109 110
            next.table = (trie_t**) realloc ((void*) next.table,
                sizeof (trie_t*) * count);
111 112
            zmq_assert (next.table);
            memmove (next.table + min - c, next.table,
113
                old_count * sizeof (trie_t*));
114
            for (unsigned short i = 0; i != min - c; i++)
115 116 117 118 119 120 121 122
                next.table [i] = NULL;
            min = c;
        }
    }

    //  If next node does not exist, create one.
    if (count == 1) {
        if (!next.node) {
123
            next.node = new (std::nothrow) trie_t;
124
            alloc_assert (next.node);
125
            ++live_nodes;
126
            zmq_assert (live_nodes == 1);
127
        }
128
        return next.node->add (prefix_ + 1, size_ - 1);
129 130 131
    }
    else {
        if (!next.table [c - min]) {
132
            next.table [c - min] = new (std::nothrow) trie_t;
133
            alloc_assert (next.table [c - min]);
134
            ++live_nodes;
135
            zmq_assert (live_nodes > 1);
136
        }
137
        return next.table [c - min]->add (prefix_ + 1, size_ - 1);
138 139 140
    }
}

141
bool zmq::trie_t::rm (unsigned char *prefix_, size_t size_)
142
{
143 144 145 146 147 148 149 150 151 152
    //  TODO: Shouldn't an error be reported if the key does not exist?
    if (!size_) {
        if (!refcnt)
            return false;
        refcnt--;
        return refcnt == 0;
    }
    unsigned char c = *prefix_;
    if (!count || c < min || c >= min + count)
        return false;
153

154 155
    trie_t *next_node =
        count == 1 ? next.node : next.table [c - min];
156

157 158
    if (!next_node)
        return false;
159

160
    bool ret = next_node->rm (prefix_ + 1, size_ - 1);
161

162 163
    //  Prune redundant nodes
    if (next_node->is_redundant ()) {
164
        LIBZMQ_DELETE(next_node);
165
        zmq_assert (count > 0);
166

167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
        if (count == 1) {
            //  The just pruned node is was the only live node
            next.node = 0;
            count = 0;
            --live_nodes;
            zmq_assert (live_nodes == 0);
        }
        else {
            next.table [c - min] = 0;
            zmq_assert (live_nodes > 1);
            --live_nodes;

            //  Compact the table if possible
            if (live_nodes == 1) {
                //  We can switch to using the more compact single-node
                //  representation since the table only contains one live node
                trie_t *node = 0;
                //  Since we always compact the table the pruned node must
                //  either be the left-most or right-most ptr in the node
                //  table
                if (c == min) {
                    //  The pruned node is the left-most node ptr in the
                    //  node table => keep the right-most node
                    node = next.table [count - 1];
                    min += count - 1;
                }
                else
                if (c == min + count - 1) {
                    //  The pruned node is the right-most node ptr in the
                    //  node table => keep the left-most node
                    node = next.table [0];
                }
                zmq_assert (node);
                free (next.table);
                next.node = node;
                count = 1;
            }
            else
            if (c == min) {
                //  We can compact the table "from the left".
                //  Find the left-most non-null node ptr, which we'll use as
                //  our new min
                unsigned char new_min = min;
                for (unsigned short i = 1; i < count; ++i) {
                    if (next.table [i]) {
                        new_min = i + min;
                        break;
                    }
                }
                zmq_assert (new_min != min);

                trie_t **old_table = next.table;
                zmq_assert (new_min > min);
                zmq_assert (count > new_min - min);

                count = count - (new_min - min);
                next.table = (trie_t**) malloc (sizeof (trie_t*) * count);
                alloc_assert (next.table);

                memmove (next.table, old_table + (new_min - min),
                        sizeof (trie_t*) * count);
                free (old_table);

                min = new_min;
            }
            else
            if (c == min + count - 1) {
                //  We can compact the table "from the right".
                //  Find the right-most non-null node ptr, which we'll use to
                //  determine the new table size
                unsigned short new_count = count;
                for (unsigned short i = 1; i < count; ++i) {
                    if (next.table [count - 1 - i]) {
                        new_count = count - i;
                        break;
                    }
                }
                zmq_assert (new_count != count);
                count = new_count;

                trie_t **old_table = next.table;
                next.table = (trie_t**) malloc (sizeof (trie_t*) * count);
                alloc_assert (next.table);

                memmove (next.table, old_table, sizeof (trie_t*) * count);
                free (old_table);
            }
        }
    }
    return ret;
257 258
}

259
bool zmq::trie_t::check (unsigned char *data_, size_t size_)
260 261 262
{
    //  This function is on critical path. It deliberately doesn't use
    //  recursion to get a bit better performance.
263
    trie_t *current = this;
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
    while (true) {

        //  We've found a corresponding subscription!
        if (current->refcnt)
            return true;

        //  We've checked all the data and haven't found matching subscription.
        if (!size_)
            return false;

        //  If there's no corresponding slot for the first character
        //  of the prefix, the message does not match.
        unsigned char c = *data_;
        if (c < current->min || c >= current->min + current->count)
            return false;

        //  Move to the next character.
        if (current->count == 1)
            current = current->next.node;
        else {
            current = current->next.table [c - current->min];
            if (!current)
                return false;
        }
        data_++;
        size_--;
    }
}
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328

void zmq::trie_t::apply (void (*func_) (unsigned char *data_, size_t size_,
    void *arg_), void *arg_)
{
    unsigned char *buff = NULL;
    apply_helper (&buff, 0, 0, func_, arg_);
    free (buff);
}

void zmq::trie_t::apply_helper (
    unsigned char **buff_, size_t buffsize_, size_t maxbuffsize_,
    void (*func_) (unsigned char *data_, size_t size_, void *arg_), void *arg_)
{
    //  If this node is a subscription, apply the function.
    if (refcnt)
        func_ (*buff_, buffsize_, arg_);

    //  Adjust the buffer.
    if (buffsize_ >= maxbuffsize_) {
        maxbuffsize_ = buffsize_ + 256;
        *buff_ = (unsigned char*) realloc (*buff_, maxbuffsize_);
        zmq_assert (*buff_);
    }

    //  If there are no subnodes in the trie, return.
    if (count == 0)
        return;

    //  If there's one subnode (optimisation).
    if (count == 1) {
        (*buff_) [buffsize_] = min;
        buffsize_++;
        next.node->apply_helper (buff_, buffsize_, maxbuffsize_, func_, arg_);
        return;
    }

    //  If there are multiple subnodes.
329
    for (unsigned short c = 0; c != count; c++) {
330 331 332 333
        (*buff_) [buffsize_] = min + c;
        if (next.table [c])
            next.table [c]->apply_helper (buff_, buffsize_ + 1, maxbuffsize_,
                func_, arg_);
334
    }
335 336
}

337
bool zmq::trie_t::is_redundant () const
338 339 340
{
    return refcnt == 0 && live_nodes == 0;
}