PointList.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <exception>
 
#include "Point.h"
#include "Line.h"
 
namespace Gorgon { namespace Geometry {
    
    template<class P_ = Pointf>
    class PointList {
    public:
        
        PointList() = default;
        
        PointList(std::vector<P_> points) : Points(std::move(points)) { }
        
        PointList(std::initializer_list<P_> points) : Points(std::move(points)) { }
        
        PointList(const PointList &) = delete;
        
        PointList(PointList &&other) {
            Swap(other);
        }
        
        PointList Duplicate() const {
            return {Points};
        }
        
        
        PointList &operator =(const PointList &) = delete;
        
        PointList &operator =(PointList &&right) {
            this->Destroy();
            
            Swap(right);
            
            return *this;
        }
        
        void Destroy() {
            std::vector<P_> n;
            
            using std::swap;
            
            swap(n, Points);
        }
        
        void Clear() {
            Points.clear();
        }
        
        auto GetSize() const {
            return Points.size();
        }
        
        auto begin() {
            return Points.begin();
        }
        
        auto end() {
            return Points.end();
        }
        
        auto begin() const {
            return Points.begin();
        }
        
        auto end() const {
            return Points.end();
        }
        
        auto rbegin() {
            return Points.rbegin();
        }
        
        auto rend() {
            return Points.rend();
        }
        
        auto rbegin() const {
            return Points.rbegin();
        }
        
        auto rend() const {
            return Points.rend();
        }
        
        P_ &operator [](std::size_t index) {
            return Points[index];
        }
        
        const P_ &operator [](std::size_t index) const {
            return Points[index];
        }
        
        P_ &Front() {
            return Points.front();
        }
        
        P_ &Back() {
            return Points.back();
        }
        
        const P_ &Front() const {
            return Points.front();
        }
        
        const P_ &Back() const {
            return Points.back();
        }
        
        P_ &Get(long index) {
            if(Points.size() == 0)
                throw std::out_of_range("List is empty");
            
            return Points[PositiveMod(index, (long)Points.size())];
        }
        
        const P_ &Get(long index) const {
            if(Points.size() == 0)
                throw std::out_of_range("List is empty");
            
            return Points[PositiveMod(index, (long)Points.size())];
        }
        
        Line<P_> GetLine(long index) const {
            if(Points.size() == 0)
                throw std::out_of_range("List is empty");
                        
            return {Points[PositiveMod(index, (long)Points.size())], Points[PositiveMod(index+1, (long)Points.size())]};
        }
        
        void Push(P_ point) {
            Points.push_back(point);
        }
        
        template<class ...T_>
        void Push(T_&&... params) {
            Points.emplace_back(std::forward<T_>(params)...);
        }
        
        void Pop() {
            Points.pop_back();
        }
        
        PointList operator +(const PointList &right) const {
            PointList ret;
            
            long ind = 0;
            for(const auto &p : *this) {
                ret.Push(p + right.Get(ind));
                
                ind++;
            }
            
            return ret;
        }
        
        PointList &operator +=(const PointList &right) {
            PointList ret;
            
            long ind = 0;
            for(auto &p : *this) {
                p += right.Get(ind);
                
                ind++;
            }
            
            return *this;
        }
        
        PointList operator -(const PointList &right) const {
            PointList ret;
            
            long ind = 0;
            for(const auto &p : *this) {
                ret.Push(p - right.Get(ind));
                
                ind++;
            }
            
            return ret;
        }
        
        PointList &operator -=(const PointList &right) {
            PointList ret;
            
            long ind = 0;
            for(auto &p : *this) {
                p -= right.Get(ind);
                
                ind++;
            }
            
            return *this;
        }
        
        template<class O_>
        PointList operator +(const O_ &right) const {
            PointList ret;
            
            for(const auto &p : *this) {
                ret.Push(p + right);
            }
            
            return ret;
        }
        
        template<class O_>
        PointList &operator +=(const O_ &right) {
            PointList ret;
            
            for(auto &p : *this) {
                p += right;
            }
            
            return *this;
        }
        
        template<class O_>
        PointList operator -(const O_ &right) const {
            PointList ret;
            
            for(const auto &p : *this) {
                ret.Push(p - right);
            }
            
            return ret;
        }
        
        template<class O_>
        PointList &operator -=(const O_ &right) {
            PointList ret;
            
            for(auto &p : *this) {
                p -= right;
            }
            
            return *this;
        }
        
        template<class O_>
        PointList operator *(const O_ &right) const {
            PointList ret;
            
            for(const auto &p : *this) {
                ret.Push(p * right);
            }
            
            return ret;
        }
        
        template<class O_>
        PointList &operator *=(const O_ &right) {
            PointList ret;
            
            for(auto &p : *this) {
                p *= right;
            }
            
            return *this;
        }
        
        template<class O_>
        PointList operator /(const O_ &right) const {
            PointList ret;
            
            for(const auto &p : *this) {
                ret.Push(p / right);
            }
            
            return ret;
        }
        
        template<class O_>
        PointList &operator /=(const O_ &right) {
            PointList ret;
            
            for(auto &p : *this) {
                p /= right;
            }
            
            return *this;
        }
        
        void Swap(PointList<P_> &right) {
            using std::swap;
            
            swap(this->Points, right.Points);
        }
        
        std::vector<P_> Points;
    };
 
    template<class P_>
    bool operator <(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points < right.Points;
    }
    
    template<class P_>
    bool operator >(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points > right.Points;
    }
    
    template<class P_>
    bool operator <=(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points <= right.Points;
    }
    
    template<class P_>
    bool operator >=(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points >= right.Points;
    }
    
    template<class P_>
    bool operator ==(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points == right.Points;
    }
    
    template<class P_>
    bool operator !=(PointList<P_> &left, const PointList<P_> &right) {
        return left.Points != right.Points;
    }
    
    template<class P_>
    void swap(PointList<P_> &left, PointList<P_> &right) {
        left.Swap(right);
    }
    
    //non-member operations: translate, scale, rotate, etc...
    
} }