Position_list.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGPosition_list_HH_
#define _MGPosition_list_HH_

#include <list>
#include "mg/Position.h"

//Forward class declaration.
class MGBox;
class MGCurve;
class MGFSurface;
class MGIfstream;
class MGOfstream;
class MGSSisect;


class MG_DLL_DECLR MGPosition_list{

public:

typedef std::list<MGPosition> container_type;

typedef container_type::iterator iterator;
typedef container_type::const_iterator const_iterator;


MGPosition_list(){;};

MGPosition_list(const MGPosition& P): m_Plist(1,P){;};

MGPosition_list(
    const MGPosition_list& list,
    int start1, 
    int start2
);


~MGPosition_list(){;};


MG_DLL_DECLR friend std::ostream& operator << (std::ostream&, const MGPosition_list& );



bool append(const MGPosition& pos);
void push_back(const MGPosition& pos){m_Plist.push_back(pos);};

bool append(
    const MGCurve& crv1,
    const MGCurve& crv2,
    const MGPosition& p
);

void append(
    const MGCurve& crv1,
    const MGCurve& crv2,
    const MGPosition_list& list
);

bool append(
    const MGFSurface& srf,
    const MGPosition& uv
);

void append(
    const MGFSurface& srf,
    const MGPosition_list& list
);

bool append(
    const MGCurve& crv,
    const MGFSurface& srf,
    const MGPosition& tuv
);

bool append(
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGPosition& uvuv
){ return add(true,srf1,srf2,uvuv);}

void append(
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGPosition_list& list
);

iterator begin(){return m_Plist.begin();}
const_iterator begin() const{return m_Plist.begin();}

void clear(){m_Plist.clear();}

iterator end(){return m_Plist.end();}
const_iterator end() const{return m_Plist.end();}

int entries() const{return int(m_Plist.size());};
int size() const{return int(m_Plist.size());};

iterator erase(iterator i){return m_Plist.erase(i);}

const MGPosition& first() const{return m_Plist.front();};
const MGPosition& front() const{return m_Plist.front();};
MGPosition& first(){return m_Plist.front();};
MGPosition& front(){return m_Plist.front();};

bool in(const MGBox& box, const_iterator& id, int n=0) const;
bool in(const MGBox& box, iterator& id, int n=0);

void insertAt(iterator i, const MGPosition& pos)
{m_Plist.insert(i, pos);};

bool isEmpty() const{return m_Plist.empty();};
bool empty() const{return m_Plist.empty();};

const MGPosition& last() const{return m_Plist.back();};
const MGPosition& back() const{return m_Plist.back();};
MGPosition& last(){return m_Plist.back();};
MGPosition& back(){return m_Plist.back();};

void pop_back(){m_Plist.pop_back();}

void pop_front(){m_Plist.pop_front();}

void prepend(const MGPosition& pos){m_Plist.push_front(pos);};
void push_front(const MGPosition& pos){m_Plist.push_front(pos);};

bool prepend(
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGPosition& uvuv
){ return add(false,srf1,srf2,uvuv);};

int remove(
    double error,       
    const MGPosition& P,
    int n=0         
);

int remove(
    const MGFSurface& srf,
    const MGPosition& uv
);

int remove(
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGPosition& uvuv
);

int remove_uvuv(
    const MGFSurface& srf1,
    const MGFSurface& srf2
);

MGPosition removeAt(iterator i);

MGPosition removeFirst();

MGPosition removeLast();

int removeOn(
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGSSisect& ssi
);

void reverse_order();

void sort_uv_space(int id);

private:
    container_type m_Plist;

int dump_size() const;

int dump(MGOfstream& ) const;

int restore(MGIfstream& );

bool add(
    bool append,            
    const MGFSurface& srf1,
    const MGFSurface& srf2,
    const MGPosition& uvuv
);

};
 // end of IsectContainer group
#endif