GelPositions.h

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

class MGGroup;
#include <algorithm>
#include <vector>
#include "mg/GelPosition.h"

class MGPickObjects;


class MG_DLL_DECLR MGGelPositions{
public:

    typedef std::vector<MGGelPosition> container_type;
    typedef container_type::reference              reference;
    typedef container_type::const_reference        const_reference;
    typedef container_type::iterator               iterator;
    typedef container_type::const_iterator         const_iterator;
    typedef container_type::size_type              size_type;
    typedef container_type::difference_type        difference_type;
    typedef container_type::value_type             value_type;
    typedef container_type::allocator_type         allocator_type;
    typedef allocator_type::pointer                pointer;
    typedef allocator_type::const_pointer          const_pointer;
    typedef container_type::reverse_iterator       reverse_iterator;
    typedef container_type::const_reverse_iterator const_reverse_iterator;


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


MGGelPositions(){;}

MGGelPositions(const MGGelPosition& gelp);

MGGelPositions(const MGPickObjects& gelp);

MGGelPositions(const MGGelPositions& obj2);



const_reference operator[](size_type i)const{return m_gelps[i];};
reference operator[](size_type i){return m_gelps[i];};

MGGelPositions& operator+=(const MGGelPositions& gelps){push_back(gelps);return *this;};
MGGelPositions& operator+=(const MGGelPosition& gelp){push_back(gelp);return *this;};
MGGelPositions& operator-=(const MGGelPositions& gelps){remove(gelps);return *this;};
MGGelPositions& operator-=(const MGGelPosition& gelp){remove(gelp);return *this;};
MGGelPositions& operator-=(const MGAbstractGels& types){remove(types);return *this;};
MGGelPositions& operator&=(const MGGelPositions& gelps){reset_with_common(gelps);return *this;};


void assign(const_iterator first, const_iterator last);

virtual const_reference back() const{return m_gelps.back();};
virtual reference back(){return m_gelps.back();};

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

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

bool empty() const{return m_gelps.empty();};

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

iterator erase(iterator x){return m_gelps.erase(x);};

iterator erase(iterator first, iterator last){return m_gelps.erase(first,last);};

void erase(int i){erase(begin()+i);};

iterator find(const MGGelPosition& gelp){return std::find(begin(),end(),gelp);};
const_iterator find(const MGGelPosition& gelp)const{return std::find(begin(),end(),gelp);};

//Test if there is a MGPickObject that includes input objin
//in this MGPickObjects' member. If input objin is MGShell,
//and a member is_shell_face(), test is performed to the shell.
//Returns true if objin is included in this MGPickObjects.
iterator includes(const MGObject* objin);

virtual const_reference front() const{return m_gelps.front();};
virtual reference front(){return m_gelps.front();};

iterator insert(iterator it, const MGGelPosition& x){return m_gelps.insert(it,x);};

container_type& object_vector(){return m_gelps;};
const container_type& object_vector()const{return m_gelps;};

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

void push_back(const MGGelPositions& gelps){
    m_gelps.insert(end(), gelps.begin(), gelps.end());
}
void push_back(const MGGelPosition& gelp);

const_reverse_iterator rbegin() const{return m_gelps.rbegin();};
reverse_iterator rbegin(){return m_gelps.rbegin();};

const_reverse_iterator rend() const{return m_gelps.rend();};
reverse_iterator rend(){return m_gelps.rend();};

void resize(size_type n){m_gelps.resize(n);};

void reserve(int n);

void remove(const MGGelPosition& gelp);

void remove(const MGAbstractGels& types);

void remove(const MGGelPositions& gelps);

void reset_with_common(const MGGelPositions& pobjs2);

void reset_with_symmetric_difference(MGGelPositions& pobjs2);

void reset(int i, const MGGelPosition& pobj);

MGGelPositions select(const MGAbstractGels& types)const;

MGGelPosition select_1st_curve()const;

void select_curves(MGGelPositions& curves)const;

MGGelPosition select_1st_fsurface()const;

void select_fsurfaces(MGGelPositions& surfaces)const;

size_type size() const{return m_gelps.size();};

bool symmetric(const MGGelPositions& gels2)const;

private:
    container_type m_gelps;

};
 // end of GelRelated group
#endif