adaptor/gnu/hash_table.hpp

• View this file on GitHub
• Last update: 2024-07-07 00:38:12+09:00
• Include: #include "adaptor/gnu/hash_table.hpp"

Depends on

• internal/dev_env.hpp

Required by

• action/range_sequence_hash.hpp
• adaptor/map.hpp
• algebraic/rolling_hash.hpp
• data_structure/wavelet_matrix.hpp
• graph/centroid_decomposition.hpp
• graph/connected_components.hpp
• graph/internal/01bfs.hpp
• graph/internal/bfs.hpp
• graph/internal/dijkstra.hpp
• graph/is_bipartite.hpp
• graph/lowest_common_ancestor.hpp
• graph/manhattan_minimum_spanning_tree.hpp
• graph/minimum_paph_cover.hpp
• graph/parse_grid.hpp
• graph/reachability_test.hpp
• graph/shortest_path.hpp
• graph/spanning_tree.hpp
• graph/topological_sort.hpp
• graph/tree_diamiter.hpp
• graph/tree_hash.hpp
• hash/sequence_hasher.hpp
• include/actions.hpp
• include/adaptors.hpp
• include/algebraic.hpp
• include/all.hpp
• include/data_structures.hpp
• include/graph_theory.hpp
• include/hashes.hpp
• include/iterable.hpp
• include/numeric.hpp
• include/template.hpp
• internal/auto_holder.hpp
• iterable/counter.hpp
• iterable/inverse.hpp
• numeric/extremum_seeker.hpp
• numeric/fast_prime.hpp
• structure/graph.hpp
• template/standard.hpp
• template/using.hpp

Verified with

• verify/aizu-online-judge/1549/0000.test.cpp
• verify/aizu-online-judge/1549/0001.test.cpp
• verify/aizu-online-judge/1549/0002.test.cpp
• verify/aizu-online-judge/1549/0003.test.cpp
• verify/aizu-online-judge/alds1_14_b/0000.test.cpp
• verify/aizu-online-judge/grl_1_a/0000.test.cpp
• verify/aizu-online-judge/itp1_1_a/0000.test.cpp
• verify/aizu-online-judge/itp1_1_a/0001.test.cpp
• verify/aizu-online-judge/itp1_1_a/0005.test.cpp
• verify/aizu-online-judge/itp1_1_a/0006.test.cpp
• verify/aizu-online-judge/ntl_1_a/0000.test.cpp
• verify/yosupo-judge/associative_array/0002.test.cpp
• verify/yosupo-judge/associative_array/0003.test.cpp
• verify/yosupo-judge/factorize/0000.test.cpp
• verify/yosupo-judge/lca/0000.test.cpp
• verify/yosupo-judge/lca/0001.test.cpp
• verify/yosupo-judge/manhattanmst/0000.test.cpp
• verify/yosupo-judge/primality_test/0000.test.cpp
• verify/yosupo-judge/primitive_root/0000.test.cpp
• verify/yosupo-judge/range_kth_smallest/0000.test.cpp
• verify/yosupo-judge/range_kth_smallest/0001.test.cpp
• verify/yosupo-judge/range_kth_smallest/0002.test.cpp
• verify/yosupo-judge/range_kth_smallest/0003.test.cpp
• verify/yosupo-judge/rectangle_sum/0000.test.cpp
• verify/yosupo-judge/rectangle_sum/0001.test.cpp
• verify/yosupo-judge/shortest_path/0000.test.cpp
• verify/yosupo-judge/shortest_path/0001.test.cpp
• verify/yosupo-judge/shortest_path/0002.test.cpp
• verify/yosupo-judge/static_range_frequency/0000.test.cpp
• verify/yosupo-judge/static_range_frequency/0001.test.cpp
• verify/yukicoder/738/0000.test.cpp

Code

#pragma once


#include <functional>
#include <stdexcept>

#include <ext/pb_ds/assoc_container.hpp>


#include "internal/dev_env.hpp"



namespace uni {

namespace gnu {


template<class Base>
struct hash_table : Base {
    using key_type = typename Base::key_type;
    using value_type = typename Base::value_type;
    using mapped_type = typename Base::mapped_type;

    inline bool contains(const key_type& key) const noexcept(NO_EXCEPT) {
        return this->Base::find(key) != this->Base::end();
    }

    template<class K, class T>
    inline decltype(auto) emplace(K&& key, T&& val) noexcept(NO_EXCEPT) {
        return this->Base::insert({ std::forward<K>(key), std::forward<T>(val) });
    }

    mapped_type& at(const key_type& key) {
        auto itr = this->Base::find(key);
        if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
        return itr->second;
    };

    const mapped_type& at(const key_type & key) const {
        auto itr = this->Base::find(key);
        if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
        return itr->second;
    };
};


template<class Key, class T, class Hash = void>
struct cc_hash_table : hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>> {
    using hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>>::hash_table;
};

template<class Key, class T>
struct cc_hash_table<Key, T, void> : hash_table<__gnu_pbds::cc_hash_table<Key, T>> {
    using hash_table<__gnu_pbds::cc_hash_table<Key, T>>::hash_table;
};


template<class Key, class T, class Hash = void>
struct gp_hash_table : hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>> {
    using hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>>::hash_table;
};

template<class Key, class T>
struct gp_hash_table<Key, T, void> : hash_table<__gnu_pbds::gp_hash_table<Key, T>> {
    using hash_table<__gnu_pbds::gp_hash_table<Key, T>>::hash_table;
};


} // namespace gnu

} // namespace uni

#line 2 "adaptor/gnu/hash_table.hpp"


#include <functional>
#include <stdexcept>

#include <ext/pb_ds/assoc_container.hpp>


#line 2 "internal/dev_env.hpp"


#ifdef LOCAL_JUDGE
    inline constexpr bool DEV_ENV = true;
    inline constexpr bool NO_EXCEPT = false;
#else
    inline constexpr bool DEV_ENV = false;
    inline constexpr bool NO_EXCEPT = true;
#endif // LOCAL_JUDGE


#if __cplusplus >= 202100L
    #define CPP20 true
    #define CPP23 true
#elif __cplusplus >= 202002L
    #define CPP20 true
    #define CPP23 false
#else
    #define CPP20 false
    #define CPP23 false
#endif
#line 11 "adaptor/gnu/hash_table.hpp"



namespace uni {

namespace gnu {


template<class Base>
struct hash_table : Base {
    using key_type = typename Base::key_type;
    using value_type = typename Base::value_type;
    using mapped_type = typename Base::mapped_type;

    inline bool contains(const key_type& key) const noexcept(NO_EXCEPT) {
        return this->Base::find(key) != this->Base::end();
    }

    template<class K, class T>
    inline decltype(auto) emplace(K&& key, T&& val) noexcept(NO_EXCEPT) {
        return this->Base::insert({ std::forward<K>(key), std::forward<T>(val) });
    }

    mapped_type& at(const key_type& key) {
        auto itr = this->Base::find(key);
        if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
        return itr->second;
    };

    const mapped_type& at(const key_type & key) const {
        auto itr = this->Base::find(key);
        if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
        return itr->second;
    };
};


template<class Key, class T, class Hash = void>
struct cc_hash_table : hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>> {
    using hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>>::hash_table;
};

template<class Key, class T>
struct cc_hash_table<Key, T, void> : hash_table<__gnu_pbds::cc_hash_table<Key, T>> {
    using hash_table<__gnu_pbds::cc_hash_table<Key, T>>::hash_table;
};


template<class Key, class T, class Hash = void>
struct gp_hash_table : hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>> {
    using hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>>::hash_table;
};

template<class Key, class T>
struct gp_hash_table<Key, T, void> : hash_table<__gnu_pbds::gp_hash_table<Key, T>> {
    using hash_table<__gnu_pbds::gp_hash_table<Key, T>>::hash_table;
};


} // namespace gnu

} // namespace uni

Back to top page