把ACE的ACE_Hash_Map_ManagerEx改写了一下

最新推荐文章于 2019-10-26 19:10:48 发布
最新推荐文章于 2019-10-26 19:10:48 发布
阅读量952 收藏
点赞数
文章标签： iterator table algorithm reference date class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ball32109/article/details/7881994
版权 
在写dl engine的时候，一直不想依赖于其它库，但hash map这种常用的map肯定会经常用到，而stl的hash_map非线程安全，就打算自已把stl 的hash map或者ACE的hash map改写一下。因为最近一直在用ACE做项目，对ACE_Hash_Map_ManagerEx比较熟悉，就把它的源码看了几遍，发现ACE的hash map和stl的实现差不多，都是用桶开链法实现，不同点就在于ace的hash map好像没有在hash负载较高的时候，像stl那样会重新找一个接近元素数量的质数再重新分配(不知道我有没有看漏)。下面源码把只是把ace hash map常用的方法改写，不常用的干掉。只实现一部分功能。而类型萃取type_trait这些都没改写。因为我没用到，有用到的时候再写

/*
 * hash_map.hpp
 *
 *  Created on: 2012-7-27
 *      Author: QS
 */

#ifndef HASH_MAP_HPP_
#define HASH_MAP_HPP_
#include "hash_map_entry.hpp"
#include "hash_map_iterator_base.hpp"
#include "hash_map_algorithm.hpp"
#include "../lock/RWLock.h"
#include "../Util.h"
#include <strings.h>
#include <stdlib.h>
namespace DL
{

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map
{

	friend class hash_map_iterator_base<Key, Value, Lock, Hash, Equal> ;
public:
	typedef Key key_type;
	typedef Value date_type;

	typedef hash_map_entry<Key, Value> value_type;
	typedef value_type &reference;
	typedef value_type const &const_reference;
	typedef value_type *pointer;
	typedef value_type const *const_pointer;
	typedef ptrdiff_t difference_type;
	typedef size_t size_type;

	typedef hash_map_iterator<Key, Value, Lock, Hash, Equal> iterator;
	typedef hash_map_const_iterator<Key, Value, Lock, Hash, Equal> const_iterator;

public:
	hash_map(int init_size);
	~hash_map();

	int bind(Key key, Value value);
	int unbind(Key key);
	int unbind_all(void);

	int find(const Key &key, Value &value);

	iterator begin(void);
	iterator end(void);
	const_iterator begin(void) const;
	const_iterator end(void) const;

	Lock &mutex(void);

protected:

	int __find_location(const Key &key, hash_map_entry<Key, Value> *&entry, int &loc);
	int __bind(Key key, Value value);
	int __unbind(Key key);
	int __unbind_all(void);
	int __find(const Key &key, Value &value);

	int hash(Key key);
	int equal(const Key &key_one, const Key &key_two);

	int create_bucket(int size);
private:
	int __total_size;
	int __cur_size;
	Lock __lock;
	Hash __hash;
	Equal __compare;
	DL::hash_map_entry<Key, Value> *__table;
};

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
hash_map<Key, Value, Lock, Hash, Equal>::hash_map(int init_size) :
	__total_size(0), __cur_size(0)
{
	this->create_bucket(init_size);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
hash_map<Key, Value, Lock, Hash, Equal>::~hash_map()
{
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::create_bucket(int size)
{
	int bytes = size * sizeof(hash_map_entry<Key, Value> );
	this->__table = (hash_map_entry<Key, Value>*) malloc(bytes);
	this->__total_size = size;

	for (int i = 0; i < this->__total_size; i++)
	{
		new (&__table[i]) hash_map_entry<Key, Value> (&__table[i], &__table[i]);
	}
	return 0;
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::bind(Key key, Value value)
{
	//lock
	WriteGurad<Lock> lock(this->__lock);
	return this->__bind(key, value);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::unbind(Key key)
{
	//lock
	WriteGurad<Lock> lock(this->__lock);
	return this->__unbind(key);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::unbind_all(void)
{
	//lock
	WriteGurad<Lock> lock(this->__lock);
	return this->__unbind_all();
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::find(const Key &key, Value &value)
{
	//lock
	ReadGurad<Lock> lock(this->__lock);
	return this->__find(key, value);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
typename hash_map<Key, Value, Lock, Hash, Equal>::iterator hash_map<Key, Value, Lock, Hash, Equal>::begin(void)
{
	return iterator(*this);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
typename hash_map<Key, Value, Lock, Hash, Equal>::iterator hash_map<Key, Value, Lock, Hash, Equal>::end(void)
{
	return iterator(*this, 1);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
typename hash_map<Key, Value, Lock, Hash, Equal>::const_iterator hash_map<Key, Value, Lock, Hash, Equal>::begin(void) const
{
	return const_iterator(*this);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
typename hash_map<Key, Value, Lock, Hash, Equal>::const_iterator hash_map<Key, Value, Lock, Hash, Equal>::end(void) const
{
	return const_iterator(*this, 1);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::__find_location(const Key &key, hash_map_entry<Key, Value> *&entry, int &loc)
{
	JUDGE_RETURN(this->__total_size != 0,-1);
	loc = this->hash(key) % this->__total_size;

	hash_map_entry<Key, Value> *temp = this->__table[loc].__next;
	while (temp != &this->__table[loc] && this->equal(temp->__key, key) == 0)
	{
		temp = temp->__next;
	}

	if (temp == &this->__table[loc])
	{
		return -1;
	}
	else
	{
		entry = temp;
		return 0;
	}

	return 1;
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::__bind(Key key, Value value)
{
	int loc = 0;
	hash_map_entry<Key, Value> *entry = NULL;
	if (this->__find_location(key, entry, loc) == -1)
	{
		void *ptr = malloc(sizeof(hash_map_entry<Key, Value> ));
		bzero(ptr, sizeof(hash_map_entry<Key, Value> ));

		entry = new (ptr) hash_map_entry<Key, Value> (this->__table[loc].__next, &this->__table[loc]);
		entry->init(key, value);
		this->__table[loc].__next = entry;
		entry->__next->__prev = entry;
		this->__cur_size++;
		return 0;
	}
	return 1;
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::__unbind(Key key)
{
	hash_map_entry<Key, Value> *entry = NULL;
	int loc = 0;
	if (this->__find_location(key, entry, loc) == -1)
	{
		return -1;
	}
	entry->__next->__prev = entry->__prev;
	entry->__prev->__next = entry->__next;
	entry->~hash_map_entry<Key, Value> ();
	free(entry);
	this->__cur_size--;
	return 0;
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::__unbind_all(void)
{
	for (size_t i = 0; i < this->__total_size; i++)
	{
		hash_map_entry<Key, Value> *ptr = this->__table[i].__next;
		for (; ptr != &this->__table[i];)
		{
			hash_map_entry<Key, Value> *slot_ptr = ptr;
			ptr = ptr->__next;

			slot_ptr->~hash_map_entry<Key, Value> ();
			free(slot_ptr);
		}

		this->__table[i].__next_ = &this->__table[i];
		this->__table[i].__prev = &this->__table[i];
	}
	return 0;
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::__find(const Key &key, Value &value)
{
	hash_map_entry<Key, Value> *entry = 0;
	int loc = 0;
	if (this->__find_location(key, entry, loc) == -1)
	{
		return -1;
	}
	else
	{
		value = entry->__value;
		return 0;
	}
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::hash(Key key)
{
	return this->__hash(key);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
int hash_map<Key, Value, Lock, Hash, Equal>::equal(const Key &key_one, const Key &key_two)
{
	return this->__compare(key_one, key_two);
}

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
Lock &hash_map<Key, Value, Lock, Hash, Equal>::mutex(void)
{
	return this->__lock;
}

}
;
#endif /* HASH_MAP_HPP_ */

/*
 * hash_map_entry.hpp
 *
 *  Created on: 2012-7-27
 *      Author: QS
 */

#ifndef HASH_MAP_ENTRY_HPP_
#define HASH_MAP_ENTRY_HPP_

namespace DL
{
template<typename Key, typename Value>
class hash_map_entry
{
public:
	hash_map_entry(hash_map_entry<Key, Value> *next, hash_map_entry<Key, Value> *prev)
	{
		this->__next = next;
		this->__prev = prev;
	}
	virtual ~hash_map_entry()
	{

	}

	int init(Key key, Value value)
	{
		this->__key = key;
		this->__value = value;
		return 0;
	}

public:
	hash_map_entry<Key, Value> *__next;
	hash_map_entry<Key, Value> *__prev;
	Key __key;
	Value __value;

};
}
#endif /* HASH_MAP_ENTRY_HPP_ */


/*
 * hash_map_iterator_base.hpp
 *
 *  Created on: 2012-7-27
 *      Author: QS
 */

#ifndef HASH_MAP_ITERATOR_BASE_HPP_
#define HASH_MAP_ITERATOR_BASE_HPP_

namespace DL
{
template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map;

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map_iterator_base
{
public:
	typedef hash_map<Key, Value, Lock, Hash, Equal> container_type;
	typedef typename hash_map<Key, Value, Lock, Hash, Equal>::value_type value_type;
	typedef typename hash_map<Key, Value, Lock, Hash, Equal>::reference reference;
	typedef typename hash_map<Key, Value, Lock, Hash, Equal>::pointer pointer;
	typedef typename hash_map<Key, Value, Lock, Hash, Equal>::difference_type difference_type;

	hash_map_iterator_base(hash_map<Key, Value, Lock, Hash, Equal> &hash_map, bool head)
	{
		this->__hash_map = &hash_map;
		this->__index = head ? -1 : hash_map.__total_size;
		this->__next = &hash_map.__table[head ? 0 : hash_map.__total_size - 1];

	}
	hash_map_iterator_base(hash_map<Key, Value, Lock, Hash, Equal> &hash_map, hash_map_entry<Key, Value> *entry, int index);

	int next(hash_map_entry<Key, Value> *&entry) const
	{
		if (this->__hash_map->__table != 0 && this->__index < this->__hash_map->__total_size && this->__index >= 0 && this->__next
				!= &this->__hash_map->__table[this->__index])
		{
			entry = this->__next;
			return 1;
		}
		else
			return 0;
	}

	int done(void) const
	{
		return 0;
	}

	hash_map_entry<Key, Value> &operator*(void) const
	{
		hash_map_entry<Key, Value> *retv = 0;
		this->next(retv);
		return *retv;
	}
	hash_map_entry<Key, Value> *operator->(void) const
	{
		hash_map_entry<Key, Value> *retv = 0;
		this->next(retv);
		return retv;
	}

protected:
	int forward(void)
	{
		if (this->__hash_map == 0)
			return -1;
		else if (this->__index == -1)
		{
			this->__index++;
			return this->forward();
		}
		else if (this->__index >= this->__hash_map->__total_size)
			return 0;

		this->__next = this->__next->__next;
		if (this->__next == &this->__hash_map->__table[this->__index])
		{
			while (++this->__index < this->__hash_map->__total_size)
			{
				this->__next = this->__hash_map->__table[this->__index].__next;
				if (this->__next != &this->__hash_map->__table[this->__index])
					break;
			}
		}
		return this->__index < this->__hash_map->__total_size;
	}

	int reverse(void)
	{

		return 0;
	}

protected:
	hash_map<Key, Value, Lock, Hash, Equal> *__hash_map;
	int __index;
	hash_map_entry<Key, Value> *__next;
};

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map_const_iterator_base
{
public:

	typedef hash_map<Key, Value, Lock, Hash, Equal> contianer_type;
	typedef typename contianer_type::value_type value_type;
	typedef typename contianer_type::reference reference;
	typedef typename contianer_type::pointer pointer;
	typedef typename contianer_type::difference_type difference_type;

	hash_map_const_iterator_base(contianer_type &hash_map, bool head)
	{

	}
	hash_map_const_iterator_base(contianer_type &hash_map, hash_map_entry<Key, Value> *entry, int index)
	{

	}

	int next(hash_map_entry<Key, Value> *&entry) const
	{
		return 0;
	}

	int done(void) const;

	hash_map_entry<Key, Value> &operator*(void) const;
	hash_map_entry<Key, Value> *operator->(void) const;
};

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map_iterator: public hash_map_iterator_base<Key, Value, Lock, Hash, Equal>
{
public:
	typedef hash_map_iterator<Key, Value, Lock, Hash, Equal> self_type;
	typedef hash_map_iterator_base<Key, Value, Lock, Hash, Equal> super;
	typedef typename super::container_type container_type;

public:
	hash_map_iterator(container_type &container, int tail = 0) :
		super(container, tail == 0 ? 1 : 0)
	{
		if (tail == 0)
		{
			this->forward();
		}
	}

	self_type &operator++(void)
	{
		this->forward();
		return *this;
	}
	self_type operator++(int)
	{
		self_type retv(*this);
		++*this;
		return retv;
	}
	self_type &operator--(void)
	{
		this->reverse();
		return *this;
	}
	self_type operator--(int)
	{
		self_type retv(*this);
		--*this;
		return retv;
	}
};

template<typename Key, typename Value, typename Lock, typename Hash, typename Equal>
class hash_map_const_iterator: public hash_map_const_iterator_base<Key, Value, Lock, Hash, Equal>
{
public:
	typedef hash_map_const_iterator<Key, Value, Lock, Hash, Equal> self_type;
	typedef hash_map_const_iterator_base<Key, Value, Lock, Hash, Equal> super;
	typedef typename super::container_type container_type;

public:
	hash_map_const_iterator(container_type &container, int tail = 0) :
		super(container, tail == 0 ? 1 : 0)
	{
		if (tail == 0)
		{
			this->forward();
		}
	}
};
}
;
#endif /* HASH_MAP_ITERATOR_BASE_HPP_ */


/*
 * hash_map_algorithm.hpp
 *
 *  Created on: 2012-8-7
 *      Author: QS
 */

#ifndef HASH_MAP_ALGORITHM_HPP_
#define HASH_MAP_ALGORITHM_HPP_

namespace DL
{
template<typename T>
class hash
{
public:
	int operator ()(const T &t) const
	{
		return static_cast<int> (t);
	}
};

template<typename T>
class equal
{
public:
	bool operator ()(const T &lhs, const T &rhs) const
	{
		return lhs == rhs;
	}
};

}
;

#endif /* HASH_MAP_ALGORITHM_HPP_ */


ball32109
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树ACE_RB_Tree，哈希表ACE_Hash_Map_Manager
01-13 2630
红黑树红黑树是一种平衡二叉树，它在最差的情况下的对元素的查找性能（时间复杂度)优于其他任何一种数据结构。如果你的设计要求高效稳定，在查找的频率较高并且数据量比较大的情况下红黑树这种数据结构是一个较为理想的选择。ACE通过ACE_RB_Tree模板容器实现了红黑树的实现，提供了元素的插入查找删除遍历功能。ACE_RB_Tree通过ACE_Less_Than模板实现在插入树各个键元素之间进
ACE_Hash_Map_Manager
weixin_34132768的博客
10-15 233
// 实验hash表 ACE_Hash_Map_Manager&lt;ACE_INT32, ACE_INT32, ACE_Null_Mutex&gt; testHash; // 插入数据 for (int i = 0; i &lt; 9; i++) { testHash.bind (i, i); } // 遍历数据 for (AC...
ACE_Hash_Map_Manager_Ex ACE哈希表字符串处理
fcryuuhou的专栏
04-05 2042
由于STL没有提供hashmap (map、set其实是一个有序平衡树），在性能敏感时，Linux C++下一般使用ACE Hash_Map库来做哈希表。找了半天没找到中文文档，自己写一篇吧。 其官方文档在：http://www.dre.vanderbilt.edu/Doxygen/6.0.6/html/libace-doc/a00263.html 简单说，其步骤包括： 1） 声
ACE篇之十：ACE容器之五（映射表管理器）
daleboy的专栏
09-04 770
1、前言关联容器支持高效的元素读取，基于键而不是在容器中的位置。例子有映射表和二叉树。关联容器允许基于键进行读取和插入，但没有提供在容器中特定位置插入元素的机制映射表管理器ACE_Map_Manager，它被实现为动态的条目数组，每个条目由一个键/值对组成，一旦数组满了，就会分配新的内存，支持前向迭代和后向迭代。声明语句：ACE_Map_Manager map_;注意若有多个线程要
hashMap用对象作为key
ZeroBz的博客
08-29 1818
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((customerSiteId == null) ? 0 : customerSiteId.hashCode()); result = prime * result ...
pwwHash.zip_Big!_hash map
09-19
在IT领域，哈希表（Hash Map）是一种高效的数据结构，尤其在处理大数据时，它的作用至关重要。"pwwHash.zip_Big!_hash map"这个文件标题暗示了这是一个关于大规模数据处理和哈希映射的专题，可能包含了某种特定的...
hash_map的简单应用
01-05
hash_map
md5555.rar_hash_hash matlab
07-14
标题中的“md5555.rar_hash_hash matlab”暗示了我们正在讨论的是使用MATLAB进行MD5哈希计算。MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，设计用于产生一个128位（16字节）的数字指纹，通常表示为...
ip_set_hash_ipportip.rar_ip hash
09-20
这个模块包含了一系列函数，如`ip_set_init_hash_ipportip()`用于初始化哈希表，`ip_set_add_hash_ipportip()`和`ip_set_del_hash_ipportip()`分别用于添加和删除元素，以及`ip_set_test_elem_hash_ipportip()`用于...
ip_vs_sh.rar_ip hash
09-23
在这个主题中，我们将详细探讨“ip_vs_sh.rar_ip hash”算法，它是IPVS的一种调度策略。 标题“ip_vs_sh.rar_ip hash”中的“sh”代表“Source Hashing”，这是一种基于源IP地址进行哈希运算的调度算法。该算法的...
ACE-html-6.0.6官方文档
01-21
ACE-html-6.0.6官方文档
ACE_Hash_Map的使用示例
pleasetojava
07-13 221
一位网友说他不能在ACE中正常地使用嵌套使Hash_Map,我写下下面的代码作了简单测试,发现在ACE使用Hasp_Map还是可以的. // TestHaspMap.cpp:Definestheentrypointfortheconsoleapplication.//#include " stdafx.h " #include " ACE/Basic_Types.h " #include "...
hash_map自定义key类型的使用
cjc211322的专栏
01-13 1821
hash_map自定义key类型的使用
(转)C++中map，hash map常用操作
ai7090的专栏
12-16 555
1。目录 map简介 map的功能 使用map 在map中插入元素 查找并获取map中的元素 从map中删除元素 2。map简介 map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。 3。map的功能 自动建立Key － value的对应。key 和 valu...
ACE框架解读 - 源码篇
无忧的专栏
09-07 7001
最近学习ACE框架的源码，先考虑选取最新版本ACE6.0来阅读，但是发现代码量有30多万行，规模太大了花的时间会比较多，所以考虑选取旧一些的版本，最后选取ACE4.5版本来阅读，代码量13万行比较适中。 下面是我学习时的一些总结，把所有的目录和文件列出来，并针对每个文件里的主要类及其实现，根据自己的理解作了一些总结。 文件 总结 [CORBA]
【面试题】HashMap中如何将对象作为key
jackzhang11的博客
10-26 3177
我们都知道HashMap中包含若干个键值对<key, value>，而key可以使用很多类型，如Integer，String等等。那么，我们可以将自定义的对象作为这个key吗？ 答案是可以的，但是必须要重写hashcode()和equals()这两个方法。 如果不重写这两个方法会怎么样呢？假设我们创建了这个对象的两个实例，分别为obj1和obj2。obj1和obj2是完全一样的，因为他...
危险！在HashMap中将可变对象用作Key
gdp5211314的专栏
10-22 1069
本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢？ HashMap是一种用哈希值来存储和查找键值对（key-value pair，也称作entry）的一种数据结构。 为了正确使用HashMap，选择恰当的Key是非常重要的。Key在HashMap里是不可重复的。 内容
C++中,unordered_map和hash_map
最新发布
03-23
在C++中，unordered_map和hash_map都是用于实现哈希表的容器，用于存储键值对。它们的主要区别在于实现方式和标准支持。 unordered_map是C++11引入的标准库容器，使用哈希表实现。它提供了快速的查找、插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值