Reference

| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/unordered_set.hpp>

    namespace boost {
      template<typename Value, typename Hash = boost::hash<Value>,
               typename Pred = std::equal_to<Value>,
               typename Alloc = std::allocator<Value> >
        class unordered_set;
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&,
                        unordered_set<Value, Hash, Pred, Alloc> const&);
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&,
                        unordered_set<Value, Hash, Pred, Alloc> const&);
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        void swap(unordered_set<Value, Hash, Pred, Alloc>&,
                  unordered_set<Value, Hash, Pred, Alloc>&);
      template<typename Value, typename Hash = boost::hash<Value>,
               typename Pred = std::equal_to<Value>,
               typename Alloc = std::allocator<Value> >
        class unordered_multiset;
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&,
                        unordered_multiset<Value, Hash, Pred, Alloc> const&);
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&,
                        unordered_multiset<Value, Hash, Pred, Alloc> const&);
      template<typename Value, typename Hash, typename Pred, typename Alloc>
        void swap(unordered_multiset<Value, Hash, Pred, Alloc>&,
                  unordered_multiset<Value, Hash, Pred, Alloc>&);
    }

### Header <boost/unordered_map.hpp>

    namespace boost {
      template<typename Key, typename Mapped, typename Hash = boost::hash<Key>,
               typename Pred = std::equal_to<Key>,
               typename Alloc = std::allocator<std::pair<Key const, Mapped>> >
        class unordered_map;
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&,
                        unordered_map<Key, Mapped, Hash, Pred, Alloc> const&);
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&,
                        unordered_map<Key, Mapped, Hash, Pred, Alloc> const&);
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        void swap(unordered_map<Key, Mapped, Hash, Pred, Alloc>&,
                  unordered_map<Key, Mapped, Hash, Pred, Alloc>&);
      template<typename Key, typename Mapped, typename Hash = boost::hash<Key>,
               typename Pred = std::equal_to<Key>,
               typename Alloc = std::allocator<std::pair<Key const, Mapped>> >
        class unordered_multimap;
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&,
                        unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&,
                        unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
      template<typename Key, typename Mapped, typename Hash, typename Pred,
               typename Alloc>
        void swap(unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&,
                  unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&);
    }