QPID-5217 - Added the missing 'dx' prefix on the hash-table module types and functions.

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@1530378 13f79535-47bb-0310-9956-ffa450edef68

8 files changed, 87 insertions, 87 deletions

diff --git a/qpid/extras/dispatch/include/qpid/dispatch/hash.h b/qpid/extras/dispatch/include/qpid/dispatch/hash.h
index bf22c2c603..3026c55dcf 100644
--- a/qpid/extras/dispatch/include/qpid/dispatch/hash.h
+++ b/qpid/extras/dispatch/include/qpid/dispatch/hash.h
@@ -23,22 +23,22 @@
 #include <qpid/dispatch/iterator.h>
 #include <qpid/dispatch/error.h>
 
-typedef struct hash_t        hash_t;
-typedef struct hash_handle_t hash_handle_t;
+typedef struct dx_hash_t        dx_hash_t;
+typedef struct dx_hash_handle_t dx_hash_handle_t;
 
-hash_t *hash(int bucket_exponent, int batch_size, int value_is_const);
-void hash_free(hash_t *h);
+dx_hash_t *dx_hash(int bucket_exponent, int batch_size, int value_is_const);
+void dx_hash_free(dx_hash_t *h);
 
-size_t hash_size(hash_t *h);
-dx_error_t hash_insert(hash_t *h, dx_field_iterator_t *key, void *val, hash_handle_t **handle);
-dx_error_t hash_insert_const(hash_t *h, dx_field_iterator_t *key, const void *val, hash_handle_t **handle);
-dx_error_t hash_retrieve(hash_t *h, dx_field_iterator_t *key, void **val);
-dx_error_t hash_retrieve_const(hash_t *h, dx_field_iterator_t *key, const void **val);
-dx_error_t hash_remove(hash_t *h, dx_field_iterator_t *key);
+size_t dx_hash_size(dx_hash_t *h);
+dx_error_t dx_hash_insert(dx_hash_t *h, dx_field_iterator_t *key, void *val, dx_hash_handle_t **handle);
+dx_error_t dx_hash_insert_const(dx_hash_t *h, dx_field_iterator_t *key, const void *val, dx_hash_handle_t **handle);
+dx_error_t dx_hash_retrieve(dx_hash_t *h, dx_field_iterator_t *key, void **val);
+dx_error_t dx_hash_retrieve_const(dx_hash_t *h, dx_field_iterator_t *key, const void **val);
+dx_error_t dx_hash_remove(dx_hash_t *h, dx_field_iterator_t *key);
 
-void hash_handle_free(hash_handle_t *handle);
-const unsigned char *hash_key_by_handle(const hash_handle_t *handle);
-dx_error_t hash_remove_by_handle(hash_t *h, hash_handle_t *handle);
+void dx_hash_handle_free(dx_hash_handle_t *handle);
+const unsigned char *dx_hash_key_by_handle(const dx_hash_handle_t *handle);
+dx_error_t dx_hash_remove_by_handle(dx_hash_t *h, dx_hash_handle_t *handle);
 
 
 #endif
diff --git a/qpid/extras/dispatch/src/agent.c b/qpid/extras/dispatch/src/agent.c
index b057e139ed..4cde9fb78d 100644
--- a/qpid/extras/dispatch/src/agent.c
+++ b/qpid/extras/dispatch/src/agent.c
@@ -37,7 +37,7 @@
 
 struct dx_agent_t {
     dx_dispatch_t     *dx;
-    hash_t            *class_hash;
+    dx_hash_t         *class_hash;
     dx_message_list_t  in_fifo;
     dx_message_list_t  out_fifo;
     sys_mutex_t       *lock;
@@ -71,7 +71,7 @@ static void dx_agent_process_get(dx_agent_t *agent, dx_parsed_field_t *map, dx_f
 
     dx_field_iterator_t    *cls_string = dx_parse_raw(cls);
     const dx_agent_class_t *cls_record;
-    hash_retrieve_const(agent->class_hash, cls_string, (const void**) &cls_record);
+    dx_hash_retrieve_const(agent->class_hash, cls_string, (const void**) &cls_record);
     if (cls_record == 0)
         return;
 
@@ -257,7 +257,7 @@ dx_agent_t *dx_agent(dx_dispatch_t *dx)
 {
     dx_agent_t *agent = NEW(dx_agent_t);
     agent->dx         = dx;
-    agent->class_hash = hash(6, 10, 1);
+    agent->class_hash = dx_hash(6, 10, 1);
     DEQ_INIT(agent->in_fifo);
     DEQ_INIT(agent->out_fifo);
     agent->lock    = sys_mutex();
@@ -273,7 +273,7 @@ void dx_agent_free(dx_agent_t *agent)
     dx_router_unregister_address(agent->address);
     sys_mutex_free(agent->lock);
     dx_timer_free(agent->timer);
-    hash_free(agent->class_hash);
+    dx_hash_free(agent->class_hash);
     free(agent);
 }
 
@@ -295,7 +295,7 @@ dx_agent_class_t *dx_agent_register_class(dx_dispatch_t        *dx,
     cls->query_handler  = query_handler;
 
     dx_field_iterator_t *iter = dx_field_iterator_string(fqname, ITER_VIEW_ALL);
-    int result = hash_insert_const(agent->class_hash, iter, cls, 0);
+    int result = dx_hash_insert_const(agent->class_hash, iter, cls, 0);
     dx_field_iterator_free(iter);
     if (result < 0)
         assert(false);
diff --git a/qpid/extras/dispatch/src/container.c b/qpid/extras/dispatch/src/container.c
index 123e2ffb60..f206f492a1 100644
--- a/qpid/extras/dispatch/src/container.c
+++ b/qpid/extras/dispatch/src/container.c
@@ -88,8 +88,8 @@ typedef struct container_class_t {
 struct dx_container_t {
     dx_dispatch_t        *dx;
     dx_server_t          *server;
-    hash_t               *node_type_map;
-    hash_t               *node_map;
+    dx_hash_t            *node_type_map;
+    dx_hash_t            *node_map;
     sys_mutex_t          *lock;
     dx_node_t            *default_node;
     dxc_node_type_list_t  node_type_list;
@@ -108,7 +108,7 @@ static void setup_outgoing_link(dx_container_t *container, pn_link_t *pn_link)
 
     if (source) {
         iter   = dx_field_iterator_string(source, ITER_VIEW_NODE_ID);
-        hash_retrieve(container->node_map, iter, (void*) &node);
+        dx_hash_retrieve(container->node_map, iter, (void*) &node);
         dx_field_iterator_free(iter);
     }
     sys_mutex_unlock(container->lock);
@@ -149,7 +149,7 @@ static void setup_incoming_link(dx_container_t *container, pn_link_t *pn_link)
 
     if (target) {
         iter   = dx_field_iterator_string(target, ITER_VIEW_NODE_ID);
-        hash_retrieve(container->node_map, iter, (void*) &node);
+        dx_hash_retrieve(container->node_map, iter, (void*) &node);
         dx_field_iterator_free(iter);
     }
     sys_mutex_unlock(container->lock);
@@ -429,8 +429,8 @@ static void container_query_handler(void* context, const char *id, void *correla
     container_class_t *cls = (container_class_t*) context;
 
     if (cls->class_id == DX_CONTAINER_CLASS_CONTAINER) {
-        dx_agent_value_uint(correlator, "node_type_count", hash_size(cls->container->node_type_map));
-        dx_agent_value_uint(correlator, "node_count",      hash_size(cls->container->node_map));
+        dx_agent_value_uint(correlator, "node_type_count", dx_hash_size(cls->container->node_type_map));
+        dx_agent_value_uint(correlator, "node_count",      dx_hash_size(cls->container->node_map));
         if (cls->container->default_node)
             dx_agent_value_string(correlator, "default_node_type", cls->container->default_node->ntype->type_name);
         else
@@ -463,8 +463,8 @@ dx_container_t *dx_container(dx_dispatch_t *dx)
 
     container->dx            = dx;
     container->server        = dx->server;
-    container->node_type_map = hash(6,  4, 1);  // 64 buckets, item batches of 4
-    container->node_map      = hash(10, 32, 0); // 1K buckets, item batches of 32
+    container->node_type_map = dx_hash(6,  4, 1);  // 64 buckets, item batches of 4
+    container->node_map      = dx_hash(10, 32, 0); // 1K buckets, item batches of 32
     container->lock          = sys_mutex();
     container->default_node  = 0;
     DEQ_INIT(container->node_type_list);
@@ -507,7 +507,7 @@ int dx_container_register_node_type(dx_dispatch_t *dx, const dx_node_type_t *nt)
     nt_item->ntype = nt;
 
     sys_mutex_lock(container->lock);
-    result = hash_insert_const(container->node_type_map, iter, nt, 0);
+    result = dx_hash_insert_const(container->node_type_map, iter, nt, 0);
     DEQ_INSERT_TAIL(container->node_type_list, nt_item);
     sys_mutex_unlock(container->lock);
 
@@ -565,7 +565,7 @@ dx_node_t *dx_container_create_node(dx_dispatch_t        *dx,
     if (name) {
         dx_field_iterator_t *iter = dx_field_iterator_string(name, ITER_VIEW_ALL);
         sys_mutex_lock(container->lock);
-        result = hash_insert(container->node_map, iter, node, 0);
+        result = dx_hash_insert(container->node_map, iter, node, 0);
         sys_mutex_unlock(container->lock);
         dx_field_iterator_free(iter);
         if (result < 0) {
@@ -591,7 +591,7 @@ void dx_container_destroy_node(dx_node_t *node)
     if (node->name) {
         dx_field_iterator_t *iter = dx_field_iterator_string(node->name, ITER_VIEW_ALL);
         sys_mutex_lock(container->lock);
-        hash_remove(container->node_map, iter);
+        dx_hash_remove(container->node_map, iter);
         sys_mutex_unlock(container->lock);
         dx_field_iterator_free(iter);
         free(node->name);
diff --git a/qpid/extras/dispatch/src/hash.c b/qpid/extras/dispatch/src/hash.c
index a0d93f7567..24f0999fdc 100644
--- a/qpid/extras/dispatch/src/hash.c
+++ b/qpid/extras/dispatch/src/hash.c
@@ -23,18 +23,18 @@
 #include <stdio.h>
 #include <string.h>
 
-typedef struct hash_item_t {
-    DEQ_LINKS(struct hash_item_t);
+typedef struct dx_hash_item_t {
+    DEQ_LINKS(struct dx_hash_item_t);
     unsigned char *key;
     union {
         void       *val;
         const void *val_const;
     } v;
-} hash_item_t;
+} dx_hash_item_t;
 
-ALLOC_DECLARE(hash_item_t);
-ALLOC_DEFINE(hash_item_t);
-DEQ_DECLARE(hash_item_t, items_t);
+ALLOC_DECLARE(dx_hash_item_t);
+ALLOC_DEFINE(dx_hash_item_t);
+DEQ_DECLARE(dx_hash_item_t, items_t);
 
 
 typedef struct bucket_t {
@@ -42,7 +42,7 @@ typedef struct bucket_t {
 } bucket_t;
 
 
-struct hash_t {
+struct dx_hash_t {
     bucket_t     *buckets;
     unsigned int  bucket_count;
     unsigned int  bucket_mask;
@@ -52,17 +52,17 @@ struct hash_t {
 };
 
 
-struct hash_handle_t {
+struct dx_hash_handle_t {
     bucket_t    *bucket;
-    hash_item_t *item;
+    dx_hash_item_t *item;
 };
 
-ALLOC_DECLARE(hash_handle_t);
-ALLOC_DEFINE(hash_handle_t);
+ALLOC_DECLARE(dx_hash_handle_t);
+ALLOC_DEFINE(dx_hash_handle_t);
 
 
 // djb2 hash algorithm
-static unsigned long hash_function(dx_field_iterator_t *iter)
+static unsigned long dx_hash_function(dx_field_iterator_t *iter)
 {
     unsigned long hash = 5381;
     int c;
@@ -77,10 +77,10 @@ static unsigned long hash_function(dx_field_iterator_t *iter)
 }
 
 
-hash_t *hash(int bucket_exponent, int batch_size, int value_is_const)
+dx_hash_t *dx_hash(int bucket_exponent, int batch_size, int value_is_const)
 {
     int i;
-    hash_t *h = NEW(hash_t);
+    dx_hash_t *h = NEW(dx_hash_t);
 
     if (!h)
         return 0;
@@ -99,22 +99,22 @@ hash_t *hash(int bucket_exponent, int batch_size, int value_is_const)
 }
 
 
-void hash_free(hash_t *h)
+void dx_hash_free(dx_hash_t *h)
 {
     // TODO - Implement this
 }
 
 
-size_t hash_size(hash_t *h)
+size_t dx_hash_size(dx_hash_t *h)
 {
     return h ? h->size : 0;
 }
 
 
-static hash_item_t *hash_internal_insert(hash_t *h, dx_field_iterator_t *key, int *exists, hash_handle_t **handle)
+static dx_hash_item_t *dx_hash_internal_insert(dx_hash_t *h, dx_field_iterator_t *key, int *exists, dx_hash_handle_t **handle)
 {
-    unsigned long  idx  = hash_function(key) & h->bucket_mask;
-    hash_item_t   *item = DEQ_HEAD(h->buckets[idx].items);
+    unsigned long   idx  = dx_hash_function(key) & h->bucket_mask;
+    dx_hash_item_t *item = DEQ_HEAD(h->buckets[idx].items);
 
     while (item) {
         if (dx_field_iterator_equal(key, item->key))
@@ -129,7 +129,7 @@ static hash_item_t *hash_internal_insert(hash_t *h, dx_field_iterator_t *key, in
         return item;
     }
 
-    item = new_hash_item_t();
+    item = new_dx_hash_item_t();
     if (!item)
         return 0;
 
@@ -144,7 +144,7 @@ static hash_item_t *hash_internal_insert(hash_t *h, dx_field_iterator_t *key, in
     // If a pointer to a handle-pointer was supplied, create a handle for this item.
     //
     if (handle) {
-        *handle = new_hash_handle_t();
+        *handle = new_dx_hash_handle_t();
         (*handle)->bucket = &h->buckets[idx];
         (*handle)->item   = item;
     }
@@ -153,10 +153,10 @@ static hash_item_t *hash_internal_insert(hash_t *h, dx_field_iterator_t *key, in
 }
 
 
-dx_error_t hash_insert(hash_t *h, dx_field_iterator_t *key, void *val, hash_handle_t **handle)
+dx_error_t dx_hash_insert(dx_hash_t *h, dx_field_iterator_t *key, void *val, dx_hash_handle_t **handle)
 {
-    int          exists = 0;
-    hash_item_t *item   = hash_internal_insert(h, key, &exists, handle);
+    int             exists = 0;
+    dx_hash_item_t *item   = dx_hash_internal_insert(h, key, &exists, handle);
 
     if (!item)
         return DX_ERROR_ALLOC;
@@ -170,12 +170,12 @@ dx_error_t hash_insert(hash_t *h, dx_field_iterator_t *key, void *val, hash_hand
 }
 
 
-dx_error_t hash_insert_const(hash_t *h, dx_field_iterator_t *key, const void *val, hash_handle_t **handle)
+dx_error_t dx_hash_insert_const(dx_hash_t *h, dx_field_iterator_t *key, const void *val, dx_hash_handle_t **handle)
 {
     assert(h->is_const);
 
-    int          error = 0;
-    hash_item_t *item  = hash_internal_insert(h, key, &error, handle);
+    int             error = 0;
+    dx_hash_item_t *item  = dx_hash_internal_insert(h, key, &error, handle);
 
     if (item)
         item->v.val_const = val;
@@ -183,10 +183,10 @@ dx_error_t hash_insert_const(hash_t *h, dx_field_iterator_t *key, const void *va
 }
 
 
-static hash_item_t *hash_internal_retrieve(hash_t *h, dx_field_iterator_t *key)
+static dx_hash_item_t *dx_hash_internal_retrieve(dx_hash_t *h, dx_field_iterator_t *key)
 {
-    unsigned long  idx  = hash_function(key) & h->bucket_mask;
-    hash_item_t   *item = DEQ_HEAD(h->buckets[idx].items);
+    unsigned long   idx  = dx_hash_function(key) & h->bucket_mask;
+    dx_hash_item_t *item = DEQ_HEAD(h->buckets[idx].items);
 
     while (item) {
         if (dx_field_iterator_equal(key, item->key))
@@ -198,9 +198,9 @@ static hash_item_t *hash_internal_retrieve(hash_t *h, dx_field_iterator_t *key)
 }
 
 
-dx_error_t hash_retrieve(hash_t *h, dx_field_iterator_t *key, void **val)
+dx_error_t dx_hash_retrieve(dx_hash_t *h, dx_field_iterator_t *key, void **val)
 {
-    hash_item_t *item = hash_internal_retrieve(h, key);
+    dx_hash_item_t *item = dx_hash_internal_retrieve(h, key);
     if (item)
         *val = item->v.val;
     else
@@ -210,11 +210,11 @@ dx_error_t hash_retrieve(hash_t *h, dx_field_iterator_t *key, void **val)
 }
 
 
-dx_error_t hash_retrieve_const(hash_t *h, dx_field_iterator_t *key, const void **val)
+dx_error_t dx_hash_retrieve_const(dx_hash_t *h, dx_field_iterator_t *key, const void **val)
 {
     assert(h->is_const);
 
-    hash_item_t *item = hash_internal_retrieve(h, key);
+    dx_hash_item_t *item = dx_hash_internal_retrieve(h, key);
     if (item)
         *val = item->v.val_const;
     else
@@ -224,10 +224,10 @@ dx_error_t hash_retrieve_const(hash_t *h, dx_field_iterator_t *key, const void *
 }
 
 
-dx_error_t hash_remove(hash_t *h, dx_field_iterator_t *key)
+dx_error_t dx_hash_remove(dx_hash_t *h, dx_field_iterator_t *key)
 {
-    unsigned long  idx  = hash_function(key) & h->bucket_mask;
-    hash_item_t   *item = DEQ_HEAD(h->buckets[idx].items);
+    unsigned long   idx  = dx_hash_function(key) & h->bucket_mask;
+    dx_hash_item_t *item = DEQ_HEAD(h->buckets[idx].items);
 
     while (item) {
         if (dx_field_iterator_equal(key, item->key))
@@ -238,7 +238,7 @@ dx_error_t hash_remove(hash_t *h, dx_field_iterator_t *key)
     if (item) {
         free(item->key);
         DEQ_REMOVE(h->buckets[idx].items, item);
-        free_hash_item_t(item);
+        free_dx_hash_item_t(item);
         h->size--;
         return DX_ERROR_NONE;
     }
@@ -247,14 +247,14 @@ dx_error_t hash_remove(hash_t *h, dx_field_iterator_t *key)
 }
 
 
-void hash_handle_free(hash_handle_t *handle)
+void dx_hash_handle_free(dx_hash_handle_t *handle)
 {
     if (handle)
-        free_hash_handle_t(handle);
+        free_dx_hash_handle_t(handle);
 }
 
 
-const unsigned char *hash_key_by_handle(const hash_handle_t *handle)
+const unsigned char *dx_hash_key_by_handle(const dx_hash_handle_t *handle)
 {
     if (handle)
         return handle->item->key;
@@ -262,13 +262,13 @@ const unsigned char *hash_key_by_handle(const hash_handle_t *handle)
 }
 
 
-dx_error_t hash_remove_by_handle(hash_t *h, hash_handle_t *handle)
+dx_error_t dx_hash_remove_by_handle(dx_hash_t *h, dx_hash_handle_t *handle)
 {
     if (!handle)
         return DX_ERROR_NOT_FOUND;
     free(handle->item->key);
     DEQ_REMOVE(handle->bucket->items, handle->item);
-    free_hash_item_t(handle->item);
+    free_dx_hash_item_t(handle->item);
     h->size--;
     return DX_ERROR_NONE;
 }
diff --git a/qpid/extras/dispatch/src/router_agent.c b/qpid/extras/dispatch/src/router_agent.c
index c35f5fa768..0dee4841d5 100644
--- a/qpid/extras/dispatch/src/router_agent.c
+++ b/qpid/extras/dispatch/src/router_agent.c
@@ -48,7 +48,7 @@ static void dx_router_schema_handler(void *context, void *correlator)
 static const char *dx_router_addr_text(dx_address_t *addr)
 {
     if (addr) {
-        const unsigned char *text = hash_key_by_handle(addr->hash_handle);
+        const unsigned char *text = dx_hash_key_by_handle(addr->hash_handle);
         if (text)
             return (const char*) text;
     }
diff --git a/qpid/extras/dispatch/src/router_node.c b/qpid/extras/dispatch/src/router_node.c
index fb6dc13d34..de69e21605 100644
--- a/qpid/extras/dispatch/src/router_node.c
+++ b/qpid/extras/dispatch/src/router_node.c
@@ -421,7 +421,7 @@ static void router_rx_handler(void* context, dx_link_t *link, dx_delivery_t *del
 
         if (iter) {
             dx_field_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH);
-            hash_retrieve(router->addr_hash, iter, (void*) &addr);
+            dx_hash_retrieve(router->addr_hash, iter, (void*) &addr);
             dx_field_iterator_reset_view(iter, ITER_VIEW_NO_HOST);
             int is_local  = dx_field_iterator_prefix(iter, local_prefix);
             int is_direct = dx_field_iterator_prefix(iter, direct_prefix);
@@ -497,7 +497,7 @@ static void router_rx_handler(void* context, dx_link_t *link, dx_delivery_t *del
                         int origin = -1;
                         if (ingress_iter) {
                             dx_address_t *origin_addr;
-                            hash_retrieve(router->addr_hash, ingress_iter, (void*) &origin_addr);
+                            dx_hash_retrieve(router->addr_hash, ingress_iter, (void*) &origin_addr);
                             if (origin_addr && DEQ_SIZE(origin_addr->rnodes) == 1) {
                                 dx_router_ref_t *rref = DEQ_HEAD(origin_addr->rnodes);
                                 origin = rref->router->mask_bit;
@@ -764,14 +764,14 @@ static int router_outgoing_link_handler(void* context, dx_link_t *link)
         } else
             dx_log(module, LOG_INFO, "Registered local address: %s", r_src);
 
-        hash_retrieve(router->addr_hash, iter, (void**) &addr);
+        dx_hash_retrieve(router->addr_hash, iter, (void**) &addr);
         if (!addr) {
             addr = new_dx_address_t();
             memset(addr, 0, sizeof(dx_address_t));
             DEQ_ITEM_INIT(addr);
             DEQ_INIT(addr->rlinks);
             DEQ_INIT(addr->rnodes);
-            hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
+            dx_hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
             DEQ_INSERT_TAIL(router->addrs, addr);
         }
         dx_field_iterator_free(iter);
@@ -989,7 +989,7 @@ dx_router_t *dx_router(dx_dispatch_t *dx, const char *area, const char *id)
     router->router_id    = id;
     router->node         = dx_container_set_default_node_type(dx, &router_node, (void*) router, DX_DIST_BOTH);
     DEQ_INIT(router->addrs);
-    router->addr_hash    = hash(10, 32, 0);
+    router->addr_hash    = dx_hash(10, 32, 0);
 
     DEQ_INIT(router->links);
     DEQ_INIT(router->routers);
@@ -1069,14 +1069,14 @@ dx_address_t *dx_router_register_address(dx_dispatch_t        *dx,
     iter = dx_field_iterator_string(addr_string, ITER_VIEW_NO_HOST);
 
     sys_mutex_lock(router->lock);
-    hash_retrieve(router->addr_hash, iter, (void**) &addr);
+    dx_hash_retrieve(router->addr_hash, iter, (void**) &addr);
     if (!addr) {
         addr = new_dx_address_t();
         memset(addr, 0, sizeof(dx_address_t));
         DEQ_ITEM_INIT(addr);
         DEQ_INIT(addr->rlinks);
         DEQ_INIT(addr->rnodes);
-        hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
+        dx_hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
         DEQ_ITEM_INIT(addr);
         DEQ_INSERT_TAIL(router->addrs, addr);
     }
@@ -1108,7 +1108,7 @@ void dx_router_send(dx_dispatch_t       *dx,
 
     dx_field_iterator_reset_view(address, ITER_VIEW_ADDRESS_HASH);
     sys_mutex_lock(router->lock);
-    hash_retrieve(router->addr_hash, address, (void*) &addr);
+    dx_hash_retrieve(router->addr_hash, address, (void*) &addr);
     if (addr) {
         //
         // Forward to all of the local links receiving this address.
diff --git a/qpid/extras/dispatch/src/router_private.h b/qpid/extras/dispatch/src/router_private.h
index ac98fc155a..1457601b0b 100644
--- a/qpid/extras/dispatch/src/router_private.h
+++ b/qpid/extras/dispatch/src/router_private.h
@@ -109,7 +109,7 @@ struct dx_address_t {
     void                      *handler_context;  // In-Process Consumer context
     dx_router_link_ref_list_t  rlinks;           // Locally-Connected Consumers
     dx_router_ref_list_t       rnodes;           // Remotely-Connected Consumers
-    hash_handle_t             *hash_handle;      // Linkage back to the hash table entry
+    dx_hash_handle_t          *hash_handle;      // Linkage back to the hash table entry
 
     uint64_t deliveries_ingress;
     uint64_t deliveries_egress;
@@ -127,7 +127,7 @@ struct dx_router_t {
     dx_node_t              *node;
 
     dx_address_list_t       addrs;
-    hash_t                 *addr_hash;
+    dx_hash_t              *addr_hash;
     dx_address_t           *router_addr;
     dx_address_t           *hello_addr;
 
diff --git a/qpid/extras/dispatch/src/router_pynode.c b/qpid/extras/dispatch/src/router_pynode.c
index 83ff43eb87..7d6fd551af 100644
--- a/qpid/extras/dispatch/src/router_pynode.c
+++ b/qpid/extras/dispatch/src/router_pynode.c
@@ -59,7 +59,7 @@ static char *dx_add_router(dx_router_t *router, const char *address, int router_
     dx_field_iterator_t *iter = dx_field_iterator_string(address, ITER_VIEW_ADDRESS_HASH);
     dx_address_t        *addr;
 
-    hash_retrieve(router->addr_hash, iter, (void**) &addr);
+    dx_hash_retrieve(router->addr_hash, iter, (void**) &addr);
     assert(addr == 0);
 
     //
@@ -72,7 +72,7 @@ static char *dx_add_router(dx_router_t *router, const char *address, int router_
     DEQ_ITEM_INIT(addr);
     DEQ_INIT(addr->rlinks);
     DEQ_INIT(addr->rnodes);
-    hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
+    dx_hash_insert(router->addr_hash, iter, addr, &addr->hash_handle);
     DEQ_INSERT_TAIL(router->addrs, addr);
     dx_field_iterator_free(iter);
 
@@ -154,9 +154,9 @@ static char *dx_del_router(dx_router_t *router, int router_maskbit)
     dx_bitmask_free(rnode->valid_origins);
     free_dx_router_node_t(rnode);
 
-    hash_remove_by_handle(router->addr_hash, oaddr->hash_handle);
+    dx_hash_remove_by_handle(router->addr_hash, oaddr->hash_handle);
     DEQ_REMOVE(router->addrs, oaddr);
-    hash_handle_free(oaddr->hash_handle);
+    dx_hash_handle_free(oaddr->hash_handle);
     router->routers_by_mask_bit[router_maskbit] = 0;
     free_dx_address_t(oaddr);