isects.h

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

#include "mg/Pvector.h"
#include "mg/isect.h"

//Forward class declaration.
class MGObject;
class MGCCisect_list;
class MGCSisect_list;
class MGSSisect_list;
class MGCFisect_vector;
class MGFFisect;
class MGHHisect;
class MGHHisect_vector;


class MG_DLL_DECLR MGisects{

public:

typedef MGPvector<MGisect>::iterator              iterator;
typedef MGPvector<MGisect>::const_iterator        const_iterator;
typedef MGPvector<MGisect>::reverse_iterator       reverse_iterator;
typedef MGPvector<MGisect>::const_reverse_iterator const_reverse_iterator;
typedef MGPvector<MGisect>::reference             reference;
typedef MGPvector<MGisect>::const_reference       const_reference;
typedef MGPvector<MGisect>::size_type             size_type;

MG_DLL_DECLR friend std::ostream& operator << (std::ostream& ostrm, const MGisects& is);


MGisects(
    const MGObject* obj1=0,
    const MGObject* obj2=0
);

MGisects(MGCCisect_list& ccis);

MGisects(MGCSisect_list& csis);

MGisects(MGSSisect_list& ssis);

MGisects(MGCFisect_vector& cfis);

MGisects(MGHHisect& hhi);

MGisects(MGHHisect_vector& hhis);

//Copy Constructor.
//MGisects(const MGisects& vector);

//~MGisects(){;};



const MGisect* operator[](int i)const{return m_is_vector[i];};
MGisect* operator[](int i){return m_is_vector[i];};



const MGisect* back() const{return m_is_vector.back();};
MGisect* back() {return m_is_vector.back();};

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

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

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

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

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

void exchange12();

const MGisect* front() const{return m_is_vector.front();};
MGisect* front(){return m_is_vector.front();};

void insertAt(iterator i, MGisect* isect){
    m_is_vector.insert(i, isect);
};

const MGObject* object1(int i)const;

const MGObject* object2(int i)const;

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

void push_back(MGisect* isect){m_is_vector.push_back(isect);};

void push_back(MGisects& isects);

int size() const{return int(m_is_vector.size());};

private:
    MGPvector<MGisect> m_is_vector;
    const MGObject* m_object1;
    const MGObject* m_object2;

};
 // end of IsectContainer group
#endif