SetUnion.hpp

//
// Created by Hamza El-Kebir on 6/21/21.
//
 
#ifndef LODESTAR_SETUNION_HPP
#define LODESTAR_SETUNION_HPP
 
#include "SetExpression.hpp"
#include <type_traits>
#include <algorithm>
 
namespace ls {
    namespace primitives {
        namespace sets {
            template<typename TTypeLeft, typename TTypeRight>
            class SetUnion : public SetExpression<SetUnion<TTypeLeft, TTypeRight>> {
            public:
                using Base = SetExpression<SetUnion<TTypeLeft, TTypeRight>>; 
 
                using ltype = TTypeLeft; 
                using rtype = TTypeRight; 
                using type = SetUnion<TTypeLeft, TTypeRight>; 
 
                SetUnion(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::Union;
                }
 
                bool isEmpty() const
                {
                    return empty_;
                }
 
                template<typename TElementType>
                bool contains(const TElementType &el) const
                {
                    return left_.contains(el) || right_.contains(el);
                }
 
                template<typename TOtherExpr>
                SetUnion<type, TOtherExpr> unionize(const SetExpression <TOtherExpr> &expr)
                {
                    return SetUnion<type, TOtherExpr>(*this, *static_cast<const TOtherExpr *>(&expr),
                                                      isEmpty() && expr.isEmpty());
                }
 
                template<typename Derived>
                double sdf(Eigen::MatrixBase<Derived> &p) const
                {
                    if (isEmpty())
                        return std::numeric_limits<double>::infinity();
                    else
                        return std::min(left_.sdf(p), right_.sdf(p));
                }
 
                const TTypeLeft &getLeft() const
                {
                    return left_;
                }
 
                const TTypeRight &getRight() const
                {
                    return right_;
                }
 
            protected:
                const TTypeLeft &left_; 
                const TTypeRight &right_; 
                bool empty_; 
            };
        }
    }
}
 
#endif //LODESTAR_SETUNION_HPP