SetComplement.hpp

//
// Created by Hamza El-Kebir on 6/24/21.
//
 
#ifndef LODESTAR_SETCOMPLEMENT_HPP
#define LODESTAR_SETCOMPLEMENT_HPP
 
#include "SetExpression.hpp"
#include <type_traits>
#include <algorithm>
 
namespace ls {
    namespace primitives {
        namespace sets {
            template<typename TTypeLeft, typename TTypeRight>
            class SetComplement : public SetExpression<SetComplement<TTypeLeft, TTypeRight>> {
            public:
                using Base = SetExpression<SetComplement<TTypeLeft, TTypeRight>>; 
 
                using ltype = TTypeLeft; 
                using rtype = TTypeRight; 
                using type = SetComplement<TTypeLeft, TTypeRight>; 
 
                SetComplement(const TTypeLeft &left, const TTypeRight &right, bool empty = false) : left_(left),
                                                                                                    right_(right),
                                                                                                    empty_(empty)
                {
//                    if (std::is_same<TTypeLeft, TTypeRight>::value)
//                        Base::sEnum_ = static_cast<TTypeLeft const &>(left).getEnum();
//                    else
                    this->sEnum_ = SetEnum::Complement;
                }
 
                bool isEmpty() const
                {
                    return empty_;
                }
 
                template<typename TElementType>
                bool contains(const TElementType &el) const
                {
                    return left_.contains(el) && (!right_.contains(el));
                }
 
                template<typename TExpression>
                SetUnion <type, TExpression> unionize(const SetExpression <TExpression> &expr)
                {
                    return SetUnion<type, TExpression>(*this, *static_cast<const TExpression *>(&expr));
                }
 
                template<typename TDerived>
                double sdf(Eigen::MatrixBase<TDerived> &p) const
                {
                    if (isEmpty())
                        return std::numeric_limits<double>::infinity();
                    else
                        return -std::min(-left_.sdf(p), right_.sdf(p));
                }
 
//                template<typename TLeft, typename TRight>
//                SetUnion<TLeft, TRight> unionize(const TLeft &left, const TRight &right) const
//                {
//                    return SetUnion<TLeft, TRight>(left, right);
//                }
 
                const TTypeLeft &getLeft() const
                {
                    return left_;
                }
 
                const TTypeRight &getRight() const
                {
                    return right_;
                }
 
            protected:
                const TTypeLeft &left_; 
                const TTypeRight &right_; 
                bool empty_; 
            };
        }
    }
}
 
#endif //LODESTAR_SETCOMPLEMENT_HPP