hash_policy.hpp

linux下编程用 编译软件

	};
      
      cc_hash_max_collision_check_resize_trigger(float load = 0.5);
      
      void
      swap(PB_ASSOC_CLASS_C_DEC& r_other);
      
      inline float
      get_load() const;
      
    protected:
      inline void
      notify_insert_search_start();

      inline void
      notify_insert_search_collision();

      inline void
      notify_insert_search_end();

      inline void
      notify_find_search_start();

      inline void
      notify_find_search_collision();

      inline void
      notify_find_search_end();

      inline void
      notify_erase_search_start();

      inline void
      notify_erase_search_collision();

      inline void
      notify_erase_search_end();

      inline void
      notify_inserted(size_type num_entries);

      inline void
      notify_erased(size_type num_entries);

      void
      notify_cleared();

      void
      notify_resized(size_type new_size);

      void
      notify_externally_resized(size_type new_size);

      inline bool
      is_resize_needed() const;

      inline bool
      is_grow_needed(size_type size, size_type num_entries) const;

      inline bool
      is_shrink_needed(size_type size, size_type num_entries) const;

    private:
      template<typename Key>
      class max_col_checker
      {
      public:
	max_col_checker(size_type size, size_type* p_max_col) 
	: m_p_max_col(p_max_col), m_a_col(size, 0)
	{ }

	void
	operator()(const std::pair<const Key, size_type>& r_key_pos_pair)
	{ ++m_a_col[r_key_pos_pair.second]; }

      private:
	std::vector<size_type> m_a_col;
	
	size_type* const m_p_max_col;
      };
      
    private:
      inline float
      get_load_imp(pb_assoc::detail::int_to_type<true>) const;
      
      float m_load;
      
      size_type m_size;
      
      size_type m_num_col;
      
      size_type m_max_col;
      
      bool m_resize_needed;
      
      static pb_assoc::detail::int_to_type<External_Load_Access>
      s_external_load_access_ind;
    };

#include <ext/pb_assoc/detail/resize_policy/cc_hash_max_collision_resize_trigger_imp.hpp>

#undef PB_ASSOC_CLASS_T_DEC
#undef PB_ASSOC_CLASS_C_DEC

#undef PB_ASSOC_DBG_ASSERT
#undef PB_ASSOC_DBG_VERIFY
#undef PB_ASSOC_DBG_ONLY

#define PB_ASSOC_CLASS_T_DEC \
	template<typename Size_Type>

#define PB_ASSOC_CLASS_C_DEC \
	hash_exponential_size_policy< \
		Size_Type>

  template<typename Size_Type =	size_t>
  class hash_exponential_size_policy
  {
  public:
    typedef Size_Type size_type;

    hash_exponential_size_policy(size_type start_size = 8, 
				 size_type grow_factor = 2);

    void
    swap(PB_ASSOC_CLASS_C_DEC& r_other);

  protected:
    size_type
    get_init_size(size_type suggested_size) const;

    size_type
    get_nearest_larger_size(size_type cur_size) const;

    size_type
    get_nearest_smaller_size(size_type cur_size) const;

#ifdef PB_ASSOC_HT_EXPONENTIAL_SIZE_POLICY_DEBUG
    void
    assert_is_one_of_my_sizes(size_type size) const;
#endif // #ifdef PB_ASSOC_HT_EXPONENTIAL_SIZE_POLICY_DEBUG

  private:
    size_type m_start_size;
    size_type m_grow_factor;
  };

#include <ext/pb_assoc/detail/resize_policy/hash_exponential_size_policy_imp.hpp>

#undef PB_ASSOC_CLASS_T_DEC
#undef PB_ASSOC_CLASS_C_DEC

#undef PB_ASSOC_DBG_ASSERT
#undef PB_ASSOC_DBG_VERIFY
#undef PB_ASSOC_DBG_ONLY

#define PB_ASSOC_CLASS_T_DEC

#define PB_ASSOC_CLASS_C_DEC \
	hash_prime_size_policy

#ifdef PB_ASSOC_HT_PRIME_SIZE_POLICY_DEBUG
#define PB_ASSOC_DBG_ASSERT(X) assert(X)
#define PB_ASSOC_DBG_VERIFY(X) assert(X)
#define PB_ASSOC_DBG_ONLY(X) X
#else // #ifdef PB_ASSOC_HT_PRIME_SIZE_POLICY_DEBUG
#define PB_ASSOC_DBG_ASSERT(X)
#define PB_ASSOC_DBG_VERIFY(X) {if((X)==0);}
#define PB_ASSOC_DBG_ONLY(X) ;
#endif // #ifdef PB_ASSOC_HT_PRIME_SIZE_POLICY_DEBUG

  struct hash_prime_size_policy
  {
    typedef size_t size_type;

    inline void
    swap(PB_ASSOC_CLASS_C_DEC& r_other);

  protected:
    inline size_type
    get_init_size(size_type suggested_size) const;
    
    inline size_type
    get_nearest_larger_size(size_type cur_size) const;
    
    inline size_type
    get_nearest_smaller_size(size_type cur_size) const;
    
    inline size_type
    get_nearest_larger_size_imp(size_type size) const;
    
#ifdef PB_ASSOC_HT_PRIME_SIZE_POLICY_DEBUG
    void
    assert_is_one_of_my_sizes(size_type size) const;
#endif // #ifdef PB_ASSOC_HT_PRIME_SIZE_POLICY_DEBUG
  };

#include <ext/pb_assoc/detail/resize_policy/hash_prime_size_policy_imp.hpp>

#undef PB_ASSOC_CLASS_T_DEC
#undef PB_ASSOC_CLASS_C_DEC

#undef PB_ASSOC_DBG_ASSERT
#undef PB_ASSOC_DBG_VERIFY
#undef PB_ASSOC_DBG_ONLY

#define PB_ASSOC_CLASS_T_DEC \
	template< \
		class Size_Policy, \
		class Trigger_Policy, \
		bool External_Size_Access, \
		typename Size_Type>

#define PB_ASSOC_CLASS_C_DEC \
	hash_standard_resize_policy< \
		Size_Policy, \
		Trigger_Policy, \
		External_Size_Access, \
		Size_Type>

  template<class Size_Policy =	pb_assoc::hash_exponential_size_policy<>,
	   class Trigger_Policy = pb_assoc::hash_load_check_resize_trigger<>,
	   bool External_Size_Access = false,
	   typename Size_Type = size_t>
  class hash_standard_resize_policy : public Size_Policy, public Trigger_Policy
  {
  public:
    typedef Size_Type 		size_type;
    typedef Trigger_Policy 	trigger_policy;
    typedef Size_Policy 	size_policy;

    enum
      {
	external_size_access = External_Size_Access
      };

    hash_standard_resize_policy(size_type suggested_size = 8);
    
    hash_standard_resize_policy(const Size_Policy&, 
				size_type suggested_size = 8);

    hash_standard_resize_policy(const Size_Policy&, const Trigger_Policy&, 
				size_type suggested_size = 8);

    virtual
    ~hash_standard_resize_policy();

    inline void
    swap(PB_ASSOC_CLASS_C_DEC& r_other);

    Size_Policy& 
    get_size_policy();

    const Size_Policy& 
    get_size_policy() const;

    Trigger_Policy& 
    get_trigger_policy();

    const Trigger_Policy& 
    get_trigger_policy() const;

    inline size_type
    get_actual_size() const;

    void
    resize(size_type suggested_new_size);

  protected:

    inline void
    notify_insert_search_start();

    inline void
    notify_insert_search_collision();

    inline void
    notify_insert_search_end();

    inline void
    notify_find_search_start();

    inline void
    notify_find_search_collision();

    inline void
    notify_find_search_end();

    inline void
    notify_erase_search_start();

    inline void
    notify_erase_search_collision();

    inline void
    notify_erase_search_end();

    inline void
    notify_inserted(size_type num_e);

    inline void
    notify_erased(size_type num_e);

    void
    notify_cleared();

    void
    notify_resized(size_type new_size);

    size_type
    get_init_size() const;

    inline bool
    is_resize_needed() const;

    size_type
    get_new_size(size_type size, size_type num_used_e) const;

  private:
    typedef Trigger_Policy my_trigger_policy_base;

    typedef Size_Policy my_size_policy_base;

    typedef
    pb_assoc::detail::int_to_type<false>
    external_resize_false_indicator;

    typedef
    pb_assoc::detail::int_to_type<true>
    external_resize_true_indicator;

    inline size_type
    get_actual_size(external_resize_true_indicator) const;

    void
    resize(size_type new_size, external_resize_true_indicator);

    virtual void
    do_resize(size_type new_size);

    static pb_assoc::detail::int_to_type<External_Size_Access>
    s_external_size_access_indicator;

    size_type m_size;
  };

#include <ext/pb_assoc/detail/resize_policy/hash_standard_resize_policy_imp.hpp>

#undef PB_ASSOC_CLASS_T_DEC
#undef PB_ASSOC_CLASS_C_DEC

#undef PB_ASSOC_DBG_ASSERT
#undef PB_ASSOC_DBG_VERIFY
#undef PB_ASSOC_DBG_ONLY

} // namespace pb_assoc

#endif // #ifndef HASH_POLICY_HPP