// Filename:    stl_hash_map.h

// hash_map和hash_multimap是对hashtable的简单包装, 非常easy理解

/*

 * Copyright (c) 1996

 * Silicon Graphics Computer Systems, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Silicon Graphics makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 *

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Hewlett-Packard Company makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 *

 */

/* NOTE: This is an internal header file, included by other STL headers.

 *   You should not attempt to use it directly.

 */

#ifndef __SGI_STL_INTERNAL_HASH_MAP_H

#define __SGI_STL_INTERNAL_HASH_MAP_H

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)

#pragma set woff 1174

#endif

// 假设编译器不能依据前面模板參数推导出后面使用的默认參数类型,

// 那么就须要手工指定, 而且对于主要的数据类型, 在<stl_hash_fun.h>

// 中都提供hash函数

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES

template <class Key, class T, class HashFcn = hash<Key>,

          class EqualKey = equal_to<Key>,

          class Alloc = alloc>

#else

template <class Key, class T, class HashFcn, class EqualKey,

          class Alloc = alloc>

#endif

class hash_map

{

private:

  typedef hashtable<pair<const Key, T>, Key, HashFcn,

                    select1st<pair<const Key, T> >, EqualKey, Alloc> ht;

  ht rep;

public:

  // 注意: reference, pointer, iterator都为const, 由于不能改动hashtable

  // 内部的元素, 否则会导致hashtable失效

  typedef typename ht::key_type key_type;

  typedef T data_type;

  typedef T mapped_type;

  typedef typename ht::value_type value_type;

  typedef typename ht::hasher hasher;

  typedef typename ht::key_equal key_equal;

  typedef typename ht::size_type size_type;

  typedef typename ht::difference_type difference_type;

  typedef typename ht::pointer pointer;

  typedef typename ht::const_pointer const_pointer;

  typedef typename ht::reference reference;

  typedef typename ht::const_reference const_reference;

  typedef typename ht::iterator iterator;

  typedef typename ht::const_iterator const_iterator;

  // 返回hash相关函数

  hasher hash_funct() const { return rep.hash_funct(); }

  key_equal key_eq() const { return rep.key_eq(); }

public:

  hash_map() : rep(100, hasher(), key_equal()) {}

  explicit hash_map(size_type n) : rep(n, hasher(), key_equal()) {}

  hash_map(size_type n, const hasher& hf) : rep(n, hf, key_equal()) {}

  hash_map(size_type n, const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

#else

  hash_map(const value_type* f, const value_type* l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

public:

  // 以下都是对hashtable的简单封装, 见<stl_hashtable.h>

  size_type size() const { return rep.size(); }

  size_type max_size() const { return rep.max_size(); }

  bool empty() const { return rep.empty(); }

  void swap(hash_map& hs) { rep.swap(hs.rep); }

  friend bool

  operator== __STL_NULL_TMPL_ARGS (const hash_map&, const hash_map&);

  iterator begin() { return rep.begin(); }

  iterator end() { return rep.end(); }

  const_iterator begin() const { return rep.begin(); }

  const_iterator end() const { return rep.end(); }

public:

  // 不同意插入key同样的元素

  pair<iterator, bool> insert(const value_type& obj)

    { return rep.insert_unique(obj); }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  void insert(InputIterator f, InputIterator l) { rep.insert_unique(f,l); }

#else

  void insert(const value_type* f, const value_type* l) {

    rep.insert_unique(f,l);

  }

  void insert(const_iterator f, const_iterator l) { rep.insert_unique(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

  pair<iterator, bool> insert_noresize(const value_type& obj)

    { return rep.insert_unique_noresize(obj); }

  iterator find(const key_type& key) { return rep.find(key); }

  const_iterator find(const key_type& key) const { return rep.find(key); }

  // 假设key存在则返回相应的元素, 否则新建一个key

  T& operator[](const key_type& key)

  {

    return rep.find_or_insert(value_type(key, T())).second;

  }

  // 以下封装见<stl_hashtable.h>

  size_type count(const key_type& key) const { return rep.count(key); }

  pair<iterator, iterator> equal_range(const key_type& key)

    { return rep.equal_range(key); }

  pair<const_iterator, const_iterator> equal_range(const key_type& key) const

    { return rep.equal_range(key); }

  size_type erase(const key_type& key) {return rep.erase(key); }

  void erase(iterator it) { rep.erase(it); }

  void erase(iterator f, iterator l) { rep.erase(f, l); }

  void clear() { rep.clear(); }

public:

  void resize(size_type hint) { rep.resize(hint); }

  size_type bucket_count() const { return rep.bucket_count(); }

  size_type max_bucket_count() const { return rep.max_bucket_count(); }

  size_type elems_in_bucket(size_type n) const

    { return rep.elems_in_bucket(n); }

};

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline bool operator==(const hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                       const hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  return hm1.rep == hm2.rep;

}

// 假设编译器支持模板函数特化优先级

// 那么将全局的swap实现为使用hash_map私有的swap以提高效率

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline void swap(hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                 hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  hm1.swap(hm2);

}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

// hash_multimap和hash_map除去同意key反复外, 其余性质一致

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES

template <class Key, class T, class HashFcn = hash<Key>,

          class EqualKey = equal_to<Key>,

          class Alloc = alloc>

#else

template <class Key, class T, class HashFcn, class EqualKey,

          class Alloc = alloc>

#endif

class hash_multimap

{

private:

  typedef hashtable<pair<const Key, T>, Key, HashFcn,

                    select1st<pair<const Key, T> >, EqualKey, Alloc> ht;

  ht rep;

public:

  typedef typename ht::key_type key_type;

  typedef T data_type;

  typedef T mapped_type;

  typedef typename ht::value_type value_type;

  typedef typename ht::hasher hasher;

  typedef typename ht::key_equal key_equal;

  typedef typename ht::size_type size_type;

  typedef typename ht::difference_type difference_type;

  typedef typename ht::pointer pointer;

  typedef typename ht::const_pointer const_pointer;

  typedef typename ht::reference reference;

  typedef typename ht::const_reference const_reference;

  typedef typename ht::iterator iterator;

  typedef typename ht::const_iterator const_iterator;

  hasher hash_funct() const { return rep.hash_funct(); }

  key_equal key_eq() const { return rep.key_eq(); }

public:

  hash_multimap() : rep(100, hasher(), key_equal()) {}

  explicit hash_multimap(size_type n) : rep(n, hasher(), key_equal()) {}

  hash_multimap(size_type n, const hasher& hf) : rep(n, hf, key_equal()) {}

  hash_multimap(size_type n, const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

#else

  hash_multimap(const value_type* f, const value_type* l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

public:

  size_type size() const { return rep.size(); }

  size_type max_size() const { return rep.max_size(); }

  bool empty() const { return rep.empty(); }

  void swap(hash_multimap& hs) { rep.swap(hs.rep); }

  friend bool

  operator== __STL_NULL_TMPL_ARGS (const hash_multimap&, const hash_multimap&);

  iterator begin() { return rep.begin(); }

  iterator end() { return rep.end(); }

  const_iterator begin() const { return rep.begin(); }

  const_iterator end() const { return rep.end(); }

public:

  iterator insert(const value_type& obj) { return rep.insert_equal(obj); }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  void insert(InputIterator f, InputIterator l) { rep.insert_equal(f,l); }

#else

  void insert(const value_type* f, const value_type* l) {

    rep.insert_equal(f,l);

  }

  void insert(const_iterator f, const_iterator l) { rep.insert_equal(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

  iterator insert_noresize(const value_type& obj)

    { return rep.insert_equal_noresize(obj); }

  iterator find(const key_type& key) { return rep.find(key); }

  const_iterator find(const key_type& key) const { return rep.find(key); }

  size_type count(const key_type& key) const { return rep.count(key); }

  pair<iterator, iterator> equal_range(const key_type& key)

    { return rep.equal_range(key); }

  pair<const_iterator, const_iterator> equal_range(const key_type& key) const

    { return rep.equal_range(key); }

  size_type erase(const key_type& key) {return rep.erase(key); }

  void erase(iterator it) { rep.erase(it); }

  void erase(iterator f, iterator l) { rep.erase(f, l); }

  void clear() { rep.clear(); }

public:

  void resize(size_type hint) { rep.resize(hint); }

  size_type bucket_count() const { return rep.bucket_count(); }

  size_type max_bucket_count() const { return rep.max_bucket_count(); }

  size_type elems_in_bucket(size_type n) const

    { return rep.elems_in_bucket(n); }

};

template <class Key, class T, class HF, class EqKey, class Alloc>

inline bool operator==(const hash_multimap<Key, T, HF, EqKey, Alloc>& hm1,

                       const hash_multimap<Key, T, HF, EqKey, Alloc>& hm2)

{

  return hm1.rep == hm2.rep;

}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline void swap(hash_multimap<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                 hash_multimap<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  hm1.swap(hm2);

}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)

#pragma reset woff 1174

#endif

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_HASH_MAP_H */

// Local Variables:

// mode:C++

// End:

最新文章

  1. jquery基础
  2. 【转】C#中WinForm程序退出方法技巧总结
  3. Android 数据库管理— — —升级数据库
  4. [转]PowerDesigner设置集锦
  5. NGINX源代码剖析 之 CPU绑定(CPU亲和性)
  6. ORACLE【1】：触发器详解
  7. 花非花-记一次linux上运行时报找不到库函数错误
  8. CCNA网络工程师学习进程（8）访问控制列表ACL
  9. 1000行代码徒手写正则表达式引擎【1】--JAVA中正则表达式的使用
  10. Java集合系列[3]----HashMap源码分析
  11. Odd-e CSD Course Day 5
  12. python冒泡排序法
  13. php 实现简拼
  14. 虚拟机VM三种网络连接方式说明
  15. 从零开始学 Web 之 HTML5（三）网络监听，全屏，文件读取，地理定位接口，应用程序缓存
  16. Delphi中Json格式读写
  17. CF438D The Child and Sequence（线段树）
  18. 表达式树(Expression Tree)
  19. HDU 3903 Trigonometric Function（数学定理）
  20. EditPlus 4.3.2560 中文版已经发布

热门文章

  1. vue项目，封装api并使用
  2. POJ3764 The xor-longest Path（字典树)
  3. codeforces 914 D Bash and a Tough Math Puzzle
  4. python编写登录与注册
  5. 紫书 例题 11-13 UVa 10735（混合图的欧拉回路）（最大流）
  6. LaTeX argmin argmax 下标使用方法
  7. Google笔试(2015年8月)
  8. HDU 5303 Delicious Apples (2015多校第二场 贪心 + 枚举)
  9. 图像几何变换（geometric transformation）
  10. BZOJ 3209 数位DP