hashset.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <unordered_set>
#include <initializer_list>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/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
 
#endif // PROMEKI_ENABLE_CORE