set.h

Go to the documentation of this file.

 
#pragma once
 
#include <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 Set {
        PROMEKI_SHARED_FINAL(Set)
        public:
                using Ptr = SharedPtr<Set>;
 
                using Data = std::set<T>;
 
                using Iterator = typename Data::iterator;
 
                using ConstIterator = typename Data::const_iterator;
 
                using RevIterator = typename Data::reverse_iterator;
 
                using ConstRevIterator = typename Data::const_reverse_iterator;
 
                Set() = default;
 
                Set(const Set &other) : d(other.d) {}
 
                Set(Set &&other) noexcept : d(std::move(other.d)) {}
 
                Set(std::initializer_list<T> initList) : d(initList) {}
 
                ~Set() = default;
 
                Set &operator=(const Set &other) {
                        d = other.d;
                        return *this;
                }
 
                Set &operator=(Set &&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(); }
 
                RevIterator rbegin() noexcept { return d.rbegin(); }
 
                RevIterator revBegin() noexcept { return d.rbegin(); }
 
                ConstRevIterator crbegin() const noexcept { return d.crbegin(); }
 
                ConstRevIterator constRevBegin() const noexcept { return d.crbegin(); }
 
                RevIterator rend() noexcept { return d.rend(); }
 
                RevIterator revEnd() noexcept { return d.rend(); }
 
                ConstRevIterator crend() const noexcept { return d.crend(); }
 
                ConstRevIterator constRevEnd() const noexcept { return d.crend(); }
 
                // -- 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(); }
 
                Iterator find(const T &value) { return d.find(value); }
 
                ConstIterator find(const T &value) const { return d.find(value); }
 
                Iterator lowerBound(const T &value) { return d.lower_bound(value); }
 
                ConstIterator lowerBound(const T &value) const { return d.lower_bound(value); }
 
                Iterator upperBound(const T &value) { return d.upper_bound(value); }
 
                ConstIterator upperBound(const T &value) const { return d.upper_bound(value); }
 
                // -- Modifiers --
 
                std::pair<Iterator, bool> insert(const T &value) {
                        return d.insert(value);
                }
 
                std::pair<Iterator, bool> insert(T &&value) {
                        return d.insert(std::move(value));
                }
 
                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(Set &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                // -- Set Operations --
 
                Set unite(const Set &other) const {
                        Set ret = *this;
                        for(const auto &v : other.d) ret.d.insert(v);
                        return ret;
                }
 
                Set intersect(const Set &other) const {
                        Set ret;
                        for(const auto &v : d) {
                                if(other.contains(v)) ret.d.insert(v);
                        }
                        return ret;
                }
 
                Set subtract(const Set &other) const {
                        Set 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 Set &lhs, const Set &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const Set &lhs, const Set &rhs) { return lhs.d != rhs.d; }
 
        private:
                Data d;
};
 
PROMEKI_NAMESPACE_END