How can I split "Segment" to two "Segments"? c++ - c++

Question

given the following classes:
#include <vector>
using std::vector;
enum TypeSeg {
OPEN, CLOSE, CLOSE_LEFT, CLOSE_RIGHT
};
template<class T>
class Segment {
T left;
T right;
TypeSeg typeS;
public:
Segment(T left, T right, TypeSeg typeS) :
left(left), right(right), typeS(typeS) {
}
//.....
};
template<class T>
class SegCollection {
vector<Segment<T>> segments;
public:
//.....
};
So that Segment describes segment ?left, right? while:
if typeS==OPEN so : (left,right).
if typeS==CLOSE so : [left,right].
if typeS==CLOSE_LEFT so : [left,right).
if typeS==CLOSE_RIGHTso : (left,right].
and SegCollection describes collection of segments so that:
The SegCollection no contains two same segments , and no contains two segments with intersect (it will contain the union of them instead) and even no contains two segments like that: [1,4) and [4,5) (for example) , but, it will contain [1,5).
How can I implement operator-() for SegCollection that delete segment from SegCollection so that: this segment not must be in SegCollection, but, all the points (from all the segments in SegCollection) that exists in SegCollection and in the deleted segment will be removed from the segments that exists in SegCollection.
For example: given: [1,7] , [9,12] , if we will remove (2,5) , so we will get: [1,2] , [5,7] , [9,12].
I don't know (I thought about it some hours..) how can I treat in the case that I need to split segment following remove of segment (like [1,7] in the example , that changed to [1,2] , [5,7])?
Note: Segment is a template-class because that it's can be from (int, int) , (float,float) e.g.

Answer 1

This tip may help.
template<typename T>
class SegCollection {
vector<Segment<T>> segments;
public:
void push_back(Segment<T> seg)
{
segments.push_back(seg);
}
const SegCollection& operator-(const Segment<T> seg)
{
// implement some rules that recognize field
// TypeSeg and depending on it, changing segments' content
// ...
return *this;
}
}
Below find the very short application of your assumptions. I have changed class to struct due to the access reasons (you could leave class but you need to provide with some getters in order to have access to the private members)
#include <vector>
#include <algorithm>
using std::vector;
enum TypeSeg {
OPEN, CLOSE, CLOSE_LEFT, CLOSE_RIGHT
};
template<typename T>
struct Segment {
T left;
T right;
TypeSeg typeS;
Segment(T left, T right, TypeSeg typeS) :
left(left), right(right), typeS(typeS) {
};
};
template<typename T>
struct SegCollection {
vector<Segment<T>> segments;
void push_back(Segment<T> seg)
{
segments.push_back(seg);
}
const SegCollection& operator-(const Segment<T> seg)
{
//Find segment that could be divided
auto it = std::find_if(segments.begin(), segments.end(),
[&seg](auto i){
if (i.left <= seg.left)
if (seg.right <= i.right)
return true;
return false;
});
//If not found, return *this
if (it == segments.end())
{
std::cout << "Cannot do this, Bro." << std::endl;
return *this;
}
//Set boundaries for new segments
int new_right = it->left + seg.left - it->left;
int new_left = seg.right;
// Here you have to apply other conditions
// I have used only one case - as you have mentioned in your post
if (seg.typeS == OPEN)
{
Segment<T> seg_first(it->left, new_right, CLOSE);
Segment<T> seg_second(new_left, it->right, CLOSE);
*it = seg_second;
this->segments.insert(it, seg_first);
}
return *this;
}
};