XList.h

 
#ifndef ACTIVE_GEOMETRY_X_LIST
#define ACTIVE_GEOMETRY_X_LIST
 
#include "Active/Geometry/XPoint.h"
 
#include "Active/Container/List.h"
 
namespace active::geometry {
    
    class PolyEdge;
    
    class XList {
    public:
 
        // MARK: - Types
        
        typedef container::List<XPoint> base;
        typedef base::iterator iterator;
        typedef base::const_iterator const_iterator;
        typedef base::size_type size_type;
 
        // MARK: - Constructors
        
        XList(const XInfo& targetFilter = XInfo(), const XInfo& bladeFilter = XInfo());
 
        // MARK: - Functions (const)
        
        const_iterator begin() const { return m_intersect.begin(); }
        const_iterator end() const { return m_intersect.end(); }
        const XPoint* front() const { return m_intersect.front().get(); }
        const XPoint* back() const { return m_intersect.back().get(); }
        size_type size() const { return m_intersect.size(); }
        bool empty() const  { return m_intersect.empty(); }
        const XInfo& getFilter(XPoint::Role role) const { return m_filter[getPart(role)]; }
        bool withPos(XPoint::Role role, Position pos) const;
        bool isPos(XPoint::Role role) const;
        void setFilter(XPoint::Role role, const XInfo& filter) { m_filter[getPart(role)] = filter; }
 
        // MARK: - Functions (mutating)
        
        iterator begin() { return m_intersect.begin(); }
        iterator end() { return m_intersect.end(); }
        XPoint* front() { return m_intersect.front().get(); }
        XPoint* back() { return m_intersect.back().get(); }
        bool insert(XPoint&& pt);
        bool insert(XPoint::Unique&& pt);
        iterator erase(iterator iter) { return m_intersect.erase(iter); }
        auto release(iterator& iter) { return m_intersect.release(iter); }
        void clear() { m_intersect.clear(); }
        void removeDuplicates(double prec = math::eps);
        template <class Compare>
        void sort(Compare comp) { m_intersect.sort(comp); }
        void reverse() { m_intersect.reverse(); }
        void addPos(XPoint::Role role, Position pos);
        void setVertex(XPoint::Role role, vertOption vertexIndex) { m_filter[getPart(role)].vertexIndex = vertexIndex; }
        void setPart(XPoint::Role role, partOption partIndex) { m_filter[getPart(role)].partIndex = partIndex; }
        void swapFilters();
        
    private:
        XPoint::Role getPart(XPoint::Role role) const {
            return (m_isSwapped) ? ((role == XPoint::target) ? XPoint::blade : XPoint::target) : role;
        }
        
        base m_intersect;
        XInfo m_filter[2];
        bool m_isSwapped;
    };
    
    
        //Compare points on the basis of position in the x-y plane
    struct ComparePosition : public std::greater<XPoint::Unique> {
    public:
        ComparePosition(double prec = math::eps) { m_prec = prec; }
        ComparePosition(const ComparePosition& source) { m_prec = source.m_prec; }
        bool operator() (XPoint::Unique& pos1, XPoint::Unique& pos2) const
                { return (math::isLess(pos1->x, pos2->x, m_prec) ||
                        (math::isEqual(pos1->x, pos2->x, m_prec) && math::isLess(pos1->y, pos2->y, m_prec))); }
    private:
        double m_prec;
    };
    
    
        //Class to sort points along the length of a poly-edge
    struct AlongLengthOf {
    public:
        AlongLengthOf(const PolyEdge& edge);
        bool operator() (XPoint::Unique& pos1, XPoint::Unique& pos2) const;
        
    private:
            
        Point m_origin;
        double m_radius;
        bool m_isClockwise;
    };
    
}
 
#endif  //ACTIVE_GEOMETRY_X_LIST