sat-solver/set.hpp

#ifndef CLASS_SET
#define CLASS_SET

#include "avl.hpp"

template<typename T> class set
{
    private:
        struct avl_tree_t<T> tree;
    
    private:
        void helper()
        {
            ;
        }
        
        template <typename first, typename ...rest>
            void helper(first f, rest... r)
            {
                add(f);
                
                helper(r...);
            }
    
    public:
        set()
        {
            ;
        }
        
        set(const set& other)
        {
            update(other);
        }
        
    public:
        template <typename ...all>
            set(all... a)
            {
                helper(a...);
            }
        
        template <typename iterator_t>
            set(iterator_t a)
            {
                for (auto &x: a)
                {
                    add(x);
                }
            }
        
        bool add(T element)
        {
            return !!tree.insert(element);
        }
        
        bool discard(T element)
        {
            return tree.delete_item(element);
        }
        
        bool update(const set& other)
        {
            // ENTER;
            
            bool are_any_new = false;
            
            for (auto & element : other)
            {
                if (this->add(element))
                {
                    are_any_new = true;
                }
            }
            
            // EXIT;
            return are_any_new;
        }
        
        bool has(const T& element) const
        {
            return !!tree.search(element);
        }
        
        operator bool() const
        {
            return !!tree.head;
        }
        
        bool is_nonempty() const
        {
            return !!tree.head;
        }
        
        int operator <=> (const set& other) const
        {
            // ENTER;
            
            int cmp = 0;
            
            auto node_a = this->tree.head, node_b = other.tree.head;
            
            for (; !cmp && node_a && node_b;
                node_a = node_a->next, node_b = node_b->next)
            {
                auto c = node_a->item <=> node_b->item;
                
                if (c > 0)
                    cmp = 1;
                else if (c < 0)
                    cmp = -1;
            }
            
            if (!cmp)
            {
                if (node_a)
                {
                    cmp = +1;
                }
                else if (node_b)
                {
                    cmp = -1;
                }
            }
            
            // dpvi(cmp);
            
            // EXIT;
            return cmp;
        }
        
        T min() const
        {
            assert(tree.head);
            
            return tree.head->item;
        }
        
        bool operator == (const set& other) const
        {
            return ((*this) <=> (other)) == 0;
        }
        
        avl_tree_t<T>::iterable begin() const
        {
            return tree.begin();
        }
        
        avl_tree_t<T>::iterable end() const
        {
            return tree.end();
        }
        
        ~set()
        {
            ;
        }
};


















#endif