hashset.h

Go to the documentation of this file.

 
#pragma once
 
#include <unordered_set>
#include <initializer_list>
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/list.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T>
class HashSet {
        PROMEKI_SHARED_FINAL(HashSet)
        public:
                using Ptr = SharedPtr<HashSet>;
 
                using Data = std::unordered_set<T>;
 
                using Value = T;
 
                using Iterator = typename Data::iterator;
 
                using ConstIterator = typename Data::const_iterator;
 
                HashSet() = default;
 
                HashSet(const HashSet &other) : d(other.d) {}
 
                HashSet(HashSet &&other) noexcept : d(std::move(other.d)) {}
 
                HashSet(std::initializer_list<T> initList) : d(initList) {}
 
                ~HashSet() = default;
 
                HashSet &operator=(const HashSet &other) {
                        d = other.d;
                        return *this;
                }
 
                HashSet &operator=(HashSet &&other) noexcept {
                        d = std::move(other.d);
                        return *this;
                }
 
                // -- Iterators --
 
                Iterator begin() noexcept { return d.begin(); }
 
                ConstIterator begin() const noexcept { return d.cbegin(); }
 
                ConstIterator cbegin() const noexcept { return d.cbegin(); }
 
                ConstIterator constBegin() const noexcept { return d.cbegin(); }
 
                Iterator end() noexcept { return d.end(); }
 
                ConstIterator end() const noexcept { return d.cend(); }
 
                ConstIterator cend() const noexcept { return d.cend(); }
 
                ConstIterator constEnd() const noexcept { return d.cend(); }
 
                // -- Capacity --
 
                bool isEmpty() const noexcept { return d.empty(); }
 
                size_t size() const noexcept { return d.size(); }
 
                // -- Lookup --
 
                bool contains(const T &value) const { return d.find(value) != d.end(); }
 
                // -- Modifiers --
 
                bool insert(const T &value) {
                        return d.insert(value).second;
                }
 
                bool insert(T &&value) {
                        return d.insert(std::move(value)).second;
                }
 
                bool remove(const T &value) {
                        return d.erase(value) > 0;
                }
 
                Iterator remove(Iterator pos) {
                        return d.erase(pos);
                }
 
                void clear() noexcept {
                        d.clear();
                        return;
                }
 
                void swap(HashSet &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                // -- Set Operations --
 
                HashSet unite(const HashSet &other) const {
                        HashSet ret = *this;
                        for(const auto &v : other.d) ret.d.insert(v);
                        return ret;
                }
 
                HashSet intersect(const HashSet &other) const {
                        HashSet ret;
                        for(const auto &v : d) {
                                if(other.contains(v)) ret.d.insert(v);
                        }
                        return ret;
                }
 
                HashSet subtract(const HashSet &other) const {
                        HashSet ret;
                        for(const auto &v : d) {
                                if(!other.contains(v)) ret.d.insert(v);
                        }
                        return ret;
                }
 
                // -- Convenience --
 
                List<T> toList() const {
                        List<T> ret;
                        ret.reserve(d.size());
                        for(const auto &v : d) ret.pushToBack(v);
                        return ret;
                }
 
                template <typename Func>
                void forEach(Func &&func) const {
                        for(const auto &v : d) func(v);
                        return;
                }
 
                // -- Comparison --
 
                friend bool operator==(const HashSet &lhs, const HashSet &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const HashSet &lhs, const HashSet &rhs) { return lhs.d != rhs.d; }
 
        private:
                Data d;
};
 
PROMEKI_NAMESPACE_END