EmptySet.hpp

//
// Created by Hamza El-Kebir on 6/24/21.
//
 
#ifndef LODESTAR_EMPTYSET_HPP
#define LODESTAR_EMPTYSET_HPP
 
#include <type_traits>
#include <limits>
#include "SetExpression.hpp"
#include "SetUnion.hpp"
#include "SetComplement.hpp"
 
namespace ls {
    namespace primitives {
        namespace sets {
            class EmptySet : public SetExpression<EmptySet> {
            public:
                using Base = SetExpression<EmptySet>; 
                using type = EmptySet; 
 
                EmptySet() = default;
 
                template<typename TExpression>
                bool operator==(const SetExpression <TExpression> &expr) const
                {
                    return std::is_same<TExpression, type>::value || expr.isEmpty();
                }
 
                template<typename TExpression>
                bool operator!=(const SetExpression <TExpression> &expr) const
                {
                    return !operator==(expr);
                }
 
                template<typename TExpression>
                bool contains(const SetExpression <TExpression> &expr) const
                {
                    return std::is_same<type, TExpression>::value || expr.isEmpty();
                }
 
                template<typename TElementType>
                bool
                contains(const TElementType &el) const
                {
                    return std::is_same<type, TElementType>::value ||
                           std::is_same<SetExpression<type>, TElementType>::value;
                }
 
                template<typename TElementType>
                bool
                isSubset(const TElementType &el) const
                {
                    return true;
                }
 
                template<typename TExpression>
                bool isSuperset(const SetExpression <TExpression> &expr) const
                {
                    return std::is_same<type, TExpression>::value || expr.isEmpty();
                }
 
//                /**
//                 * @brief Checks if this expression is a superset of \c expr.
//                 *
//                 * @tparam TElementType Type of the other element.
//                 *
//                 * @param expr Element to check subsumption on.
//                 *
//                 * @return True if this \c el is an empty set object, false otherwise.
//                 */
//                template<typename TElementType>
//                bool
//                isSuperset(const TElementType &el) const
//                {
//                    return std::is_same<type, TElementType>::value || std::is_same<Base, TElementType>::value;
//                }
 
//                /**
//                 * @brief Computes the relative complement of this expression and \c el.
//                 *
//                 * @tparam TElementType Type of the other element.
//                 *
//                 * @param el Element to take relative complement with.
//                 *
//                 * @return Emtpy set.
//                 */
//                template<typename TElementType>
//                SetExpression <EmptySet>
//                relComplement(const TElementType &el) const
//                {
//                    return *this;
//                }
 
//                 * @brief Computes the relative complement of this expression and \c el.
//                 *
//                 * @tparam TElementType Type of the other element.
//                 *
//                 * @param el Element to take relative complement with.
//                 *
//                 * @return Emtpy set.
//                 */
//                template<typename TElementType>
//                SetExpression <EmptySet>
//                relComplement(const TElementType &el) const
//                {
//                    return *this;
//                }
 
                template<typename TExpression>
                SetComplement<type, TExpression> relComplement(const SetExpression<TExpression> &expr)
                {
                    return SetComplement<type, TExpression>(*this, *static_cast<const TExpression *>(&expr),
                                                            expr.isEmpty());
                }
 
                bool isEmpty() const
                {
                    return true;
                }
 
                template<typename TExpression>
                SetUnion <type, TExpression> unionize(const SetExpression <TExpression> &expr)
                {
                    return SetUnion<type, TExpression>(*this, *static_cast<const TExpression *>(&expr),
                                                       isEmpty() && expr.isEmpty());
                }
 
                template<typename TDerived>
                double sdf(Eigen::MatrixBase<TDerived> &p) const
                {
                    return std::numeric_limits<double>::infinity();
                }
            };
        }
    }
}
 
#endif //LODESTAR_EMPTYSET_HPP