boost Variant

//line.h
#ifndef LINE_H
#define LINE_H
#include "Shape.h"
#include "Point.h"
#include <string>
#include <iostream>
using namespace std;
class Line : public Shape
{
     private:
      Point start; 
      string discrib;
      Point end;
 
   public:
      //constructors and destructor
      Line();
      Line(string x, Point P_start, Point P_end);
      Line(Line& line); // line copy constructor
      ~Line();
        
      //getters and setters
      void SetStart ( Point SomePoint);
      void SetEnd ( Point SomePoint);
      Point GetStart() ;
      Point GetEnd() ;
 
      Line operator = ( Line& l);
     // friend ostream& operator << (ostream& os , const Line& l);
 
      //other useful methods
      void ToString(); 
};
 
#endif
 
//point.h
#ifndef POINT_H 
#define POINT_H
#include "Shape.h"
#include <iostream>
#include <string>
using namespace std;
class Point : public Shape
 
{
    private:
double Xcoord;
double Ycoord;
 
    public:
Point();
Point (double xNew, double yNew);
Point( Point& point); // copy constructor for Point
~Point();
      
void X( double Value);
void Y( double Value);
double X() ;
double Y() ;
 
Point operator = ( Point& p);
friend ostream& operator << (ostream& os ,  Point& p);
void ToString();
 
};
 
#endif 
 
// shape.h 
#ifndef Shape_h 
#define Shape_h
#include <iostream>
#include "stdlib.h"
#include "Shape.h"
using namespace std; 
class Shape
{
    protected: 
int m_id;  // Add a data member for an id number of type int.
    public: 
int id; 
int ID(); // return n_id data
Shape(); // initialises the id using a random number
Shape(const Shape &OtherShape); // copies the id member
Shape operator = (const Shape &OtherShape); // copies the id member
virtual void ToString() ; // returns the id as string e.g. “ID: 123”
};
#endif 
 
//line.cpp
#include <iostream>
//#include <math.h>
#include "line.h"
#include "Point.h"
#include "Shape.h"
#include <string>
using namespace std;
 
Line::Line(){}
 
Line::Line(string x, Point P_start, Point P_end)
    :discrib(x), start(P_start), end(P_end) {}
 
Line::Line( Line& line)
{
    start = line.start;
    end = line.end;
}
 
Line::~Line() {}
 
void Line::SetStart( Point SomePoint)
    {
   start = SomePoint;
    }
 
void Line::SetEnd ( Point SomePoint)
    {
  end = SomePoint;
    }
 
Point Line::GetStart() 
    {
   return start;
    }
 
Point Line::GetEnd() 
    {
   return end;
    }
 
Line Line::operator = ( Line& l)
     {
    if (this == &l)
    {
        return * this; 
    }
    /*member function from base class */
    m_id = l.m_id;
    /* data from derived class*/
    discrib = l.discrib;
    start = l.start;
    end = l.end;
    return *this ;
    } 
 
 
 
void Line::ToString()  // returns the line as string              
    {
    cout << "[[" << discrib << "," 
         << start << "," << end << "]]" << endl;
    }
 
 
//Point.cpp
#include <iostream>
#include "Point.h"
using namespace std;
 
Point::Point() {}
 
 Point::Point (double xNew, double yNew)
     : Xcoord(xNew), Ycoord(yNew) {}
 
Point::~Point() {} //Destructor
 
Point::Point( Point& point) // Point copy constructor
{
    Xcoord = point.Xcoord;
    Ycoord = point.Ycoord;
}
 
 
void Point::X( double Value) 
{//Assign X-coordinate the Value that is put into the main
    Xcoord = Value; 
}
 
void Point::Y( double Value) 
{//Assing Y-coordinate the Value that is put into the main
    Ycoord = Value;
}
 
double Point::X()  
{
return Xcoord;//Return X-coordinate
}
 
double Point::Y()  
{
return Ycoord;//Return Y-coordinate
}
 
 
void Point::ToString()
    {
cout << "( " << X() << "," 
     << Y() << " )";
    }
 
Point Point::operator = ( Point& p)
{
    if (this == &p)
    {
        return * this; 
    }   
 
m_id = p.m_id;// member function from base class    
Xcoord = p.Xcoord;// data from derived class
Ycoord = p.Ycoord;
return *this; 
} 
ostream& operator << (ostream& os ,  Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }
 
 
 
//Shape.cpp 
#include <iostream>
#include "Shape.h"
using namespace std; 
 
 
Shape::Shape() // initialises the id using a random number
    
    {
    m_id = rand();
    ///cout << "id of shape is: " << m_id << endl; 
    }
 
int Shape::ID() // retrieve the id of the shape
    {
    return m_id; 
    }
    
void Shape::ToString() // returns the id as string              
{
    // cout << "ID: "<< ID(); 
}
 
Shape::Shape(const Shape &OtherShape)
    {//copy constructor that copies the id member
        id = OtherShape.m_id;
    }
    
Shape Shape::operator = (const Shape& OtherShape)
    {//assignment operator that copies the id member
    
    if (this == &OtherShape)
        {
            return *this;
        }
    m_id = OtherShape.m_id;
    return *this; 
    }
 
 
 
//main.cpp
//Variant
 
#include "Point.h"//header file declaration of class Point
#include "Line.h"//header file declaration of class Line
//#include "Circle.h"//header file declaration of class Circle
#include "Shape.h"//header file declaration of class Shape
#include <boost/variant.hpp>//includes boost class for variant
#include <iostream>// C++ style I/O using operator overloading
#include <ostream>
using namespace std;// The C++ logical collection of functions
 
 
//defines a shape type that can be of the form Point, Line or Circle
typedef boost::variant<Point, Line/*, Circle*/> ShapeType;
 
//function that returns a variant with the specified shape
 
ShapeType shape_type(){
int type;//selector variable
cout<<"Please enter 1 for shape of Point type"<<endl;
cout<<"Please enter 2 for shape of Line type"<<endl;
//cout<<"Please enter 3 for shape of Circle type"<<endl;
cin>>type;
 
//assigns the user given type to the variant
if(type==1){//creates a point and returns it
return Point();
}
else if(type==2){//creates a line and returns it
return Line();
}
/*else if(type==3){//creates a circle and returns it
return Circle();
}*/
}
 
//Visitor class
class VisitorClass: public boost::static_visitor<void>{
private:
double m_dx;//x delta to move
double m_dy;//y delta to move
public:
//==================================================================================================
//modifiers
//==================================================================================================
//function that Visits a point and moves its X,Y values
VisitorClass(double xval,double yval):m_dx(xval),m_dy(yval){
}
 
void operator()(Point& p) const{
//modifies the values of the point according to the user given inputs
p.X(p.X()+m_dx);
p.Y(p.Y()+m_dy);
}
 
//function that Visits a Line and moves its X,Y values of the starting and ending points
void operator()(Line& l) const{
//modifies the values of the starting point according to the user given inputs
//l.p1().X(l.p1().X()+m_dx);
//l.p1().Y(l.p1().Y()+m_dy);
l.GetStart().X(l.GetStart().X()+m_dx);
l.GetStart().Y(l.GetStart().Y()+m_dx);
 
 
 
//modifies the values of the ending point according to the user given inputs (scaled by 2)
//l.p2().X(l.p2().X()+m_dx*2);
//l.p2().Y(l.p2().Y()+m_dy*2);
l.GetEnd().X(l.GetEnd().X()+m_dx*2);
l.GetEnd().Y(l.GetEnd().Y()+m_dy*2);
}
 
//function that Visits a Circle and moves its X,Y values of its center
/*void operator()(Circle& c) const{
//modifies the values of the center point with the user given values
c.centerPoint().X((c.centerPoint().X()+m_dx));
c.centerPoint().Y((c.centerPoint().Y()+m_dy));
c.radius(m_dx+m_dy);
}*/
};
 
int main(){
 
//========================================================================================================================
// usage of variant data container
//========================================================================================================================
 
//Assigns a shape type via shape_type function
ShapeType figure=shape_type();
 
//prints the type of the figure given by the user
const std::type_info &ti=figure.type();//captures the type
cout<<"The created figure type is an object of the "<<ti.name()<<endl;//calls its names and prints it
cout<<figure;//the user assignation is sent to the cout using the overloaded << operator in each shape class
 
Line l("MyLine",Point(3,4),Point(6,8));//creates a Line
try{
boost::get<Line>(figure)=l;//assigns Line l to the figure variant
}
catch(boost::bad_get e){
std::cout << "***********************bad get error**************************" <<std::endl;
}
 
boost::apply_visitor(VisitorClass(9,12),figure);//shifts the figure according to a user given values
cout<<figure;//the user assignation is sent to the cout.
return 0;
}

ostream& operator << (const ostream& os ,const  Point& p)
    {
        os [COLOR="Red"]<<[/COLOR] "[" << p.X() << "," << p.Y() << "]";
        return  [COLOR="red"]os [/COLOR]; 
    }

ostream& operator << ( ostream& os , const Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }
 
 
 
double Point::X()  const
{
return Xcoord;//Return X-coordinate
}
 
double Point::Y()  const
{
return Ycoord;//Return Y-coordinate
}

ostream& operator << ( ostream& os , const Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }

//line.h
#ifndef LINE_H
#define LINE_H
#include "Shape.h"
#include "Point.h"
#include <string>
#include <iostream>
using namespace std;
class Line : public Shape
{
     private:
      Point start; 
      Point end;
 
   public:
      //constructors and destructor
      Line();
      Line(Point P_start, Point P_end);
      Line(const Line& line) ; // line copy constructor
      ~Line();
        
      //getters and setters
      void SetStart ( Point SomePoint);
      void SetEnd ( Point SomePoint);
      Point GetStart() const ;
      Point GetEnd() const;
 
      Line operator = (const Line& l) ; // 
     friend ostream& operator << (ostream& os , const Line& l);
 
      //other useful methods
      void ToString(); 
};
 
#endif
 
//point.h
#ifndef POINT_H 
#define POINT_H
#include "Shape.h"
#include <iostream>
#include <string>
using namespace std;
class Point : public Shape
 
{
    private:
double Xcoord;
double Ycoord;
 
    public:
Point();
Point (double xNew, double yNew);
Point(const Point& point); // copy constructor for Point
~Point();
      
void X( double Value);
void Y( double Value);
double X() const ;
double Y() const ;
Point operator = (const Point& p); // for Point class
friend ostream& operator << ( ostream& os ,const  Point& p);
void ToString();
 
};
 
#endif 
 
// shape.h 
#ifndef Shape_h 
#define Shape_h
#include <iostream>
#include "stdlib.h"
#include "Shape.h"
using namespace std; 
class Shape
{
    protected: 
int m_id;  // Add a data member for an id number of type int.
    public: 
int id; 
int ID(); // return n_id data
Shape(); // initialises the id using a random number
Shape(const Shape &OtherShape); // copies the id member
Shape operator = (const Shape &OtherShape); // copies the id member
virtual void ToString() ; // returns the id as string e.g. “ID: 123”
};
#endif 
 
//line.cpp
#include <iostream>
//#include <math.h>
#include "line.h"
#include "Point.h"
#include "Shape.h"
#include <string>
using namespace std;
 
Line::Line(){}
 
Line::Line(Point P_start, Point P_end)
    : start(P_start), end(P_end) {}
 
Line::Line(const Line& line) 
{
    start = line.start;
    end = line.end;
}
 
Line Line::operator = (const Line& l) 
     {
    if (this == &l)
    {
        return * this; 
    }
    /*member function from base class */
    m_id = l.m_id;
    /* data from derived class*/
    start = l.start;
    end = l.end;
    return *this ;
    } 
 
Line::~Line() {}
 
void Line::SetStart( Point SomePoint)
    {
   start = SomePoint;
    }
 
void Line::SetEnd ( Point SomePoint)
    {
  end = SomePoint;
    }
 
Point Line::GetStart() const
    {
   return start;
    }
 
Point Line::GetEnd() const
    {
   return end;
    }
 
ostream& operator << ( ostream& os , const  Line& l)
    {
        os << "[" << l.GetStart() << "," << l.GetEnd() << "]";
        return os ; 
    }
 
 
 
void Line::ToString()  // returns the line as string              
    {
    cout << "[[" 
         << start << "," << end << "]]" << endl;
    }
 
 
//Point.cpp
#include <iostream>
#include "Point.h"
using namespace std;
 
Point::Point() {}
 
 Point::Point (double xNew, double yNew)
     : Xcoord(xNew), Ycoord(yNew) {}
 
Point::~Point() {} //Destructor
 
Point::Point(const Point& point) // Point copy constructor
{
    Xcoord = point.Xcoord;
    Ycoord = point.Ycoord;
}
 
 
void Point::X( double Value) 
{//Assign X-coordinate the Value that is put into the main
    Xcoord = Value; 
}
 
void Point::Y( double Value) 
{//Assing Y-coordinate the Value that is put into the main
    Ycoord = Value;
}
 
double Point::X()  const
{
return Xcoord;//Return X-coordinate
}
 
double Point::Y()  const
{
return Ycoord;//Return Y-coordinate
}
 
 
void Point::ToString()
    {
cout << "( " << X() << "," 
     << Y() << " )";
    }
 
Point Point::operator = (const Point& p)
{
    if (this == &p)
    {
        return * this; 
    }   
 
m_id = p.m_id;// member function from base class    
Xcoord = p.Xcoord;// data from derived class
Ycoord = p.Ycoord;
return *this; 
} 
 
 
 
 
ostream& operator << ( ostream& os , const  Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }
 
 
 
//Shape.cpp 
#include <iostream>
#include "Shape.h"
using namespace std; 
 
 
Shape::Shape() // initialises the id using a random number
    
    {
    m_id = rand();
    ///cout << "id of shape is: " << m_id << endl; 
    }
 
int Shape::ID() // retrieve the id of the shape
    {
    return m_id; 
    }
    
void Shape::ToString() // returns the id as string              
{
    // cout << "ID: "<< ID(); 
}
 
Shape::Shape(const Shape &OtherShape)
    {//copy constructor that copies the id member
        id = OtherShape.m_id;
    }
    
Shape Shape::operator = (const Shape& OtherShape)
    {//assignment operator that copies the id member
    
    if (this == &OtherShape)
        {
            return *this;
        }
    m_id = OtherShape.m_id;
    return *this; 
    }
 
 
 
//main.cpp
//Variant
 
#include "Point.h"//header file declaration of class Point
#include "Line.h"//header file declaration of class Line
//#include "Circle.h"//header file declaration of class Circle
#include "Shape.h"//header file declaration of class Shape
#include <boost/variant.hpp>//includes boost class for variant
#include <iostream>// C++ style I/O using operator overloading
#include <ostream>
using namespace std;// The C++ logical collection of functions
 
 
//defines a shape type that can be of the form Point, Line or Circle
typedef boost::variant<Point, Line/*, Circle*/> ShapeType;
 
//function that returns a variant with the specified shape
 
ShapeType shape_type(){
int type;//selector variable
cout<<"Please enter 1 for shape of Point type"<<endl;
cout<<"Please enter 2 for shape of Line type"<<endl;
//cout<<"Please enter 3 for shape of Circle type"<<endl;
cin>>type;
 
//assigns the user given type to the variant
if(type==1){//creates a point and returns it
return Point();
}
else if(type==2){//creates a line and returns it
return Line();
}
/*else if(type==3){//creates a circle and returns it
return Circle();
}*/
}
 
//Visitor class
class VisitorClass: public boost::static_visitor<void>{
private:
double m_dx;//x delta to move
double m_dy;//y delta to move
public:
//==================================================================================================
//modifiers
//==================================================================================================
//function that Visits a point and moves its X,Y values
VisitorClass(double xval,double yval):m_dx(xval),m_dy(yval){
}
 
void operator()(Point& p) const{
//modifies the values of the point according to the user given inputs
p.X(p.X()+m_dx);
p.Y(p.Y()+m_dy);
}
 
//function that Visits a Line and moves its X,Y values of the starting and ending points
void operator()(Line& l) const{
//modifies the values of the starting point according to the user given inputs
//l.p1().X(l.p1().X()+m_dx);
//l.p1().Y(l.p1().Y()+m_dy);
l.GetStart().X(l.GetStart().X()+m_dx);
l.GetStart().Y(l.GetStart().Y()+m_dx);
 
 
 
//modifies the values of the ending point according to the user given inputs (scaled by 2)
//l.p2().X(l.p2().X()+m_dx*2);
//l.p2().Y(l.p2().Y()+m_dy*2);
l.GetEnd().X(l.GetEnd().X()+m_dx*2);
l.GetEnd().Y(l.GetEnd().Y()+m_dy*2);
}
 
//function that Visits a Circle and moves its X,Y values of its center
/*void operator()(Circle& c) const{
//modifies the values of the center point with the user given values
c.centerPoint().X((c.centerPoint().X()+m_dx));
c.centerPoint().Y((c.centerPoint().Y()+m_dy));
c.radius(m_dx+m_dy);
}*/
};
 
int main(){
 
//========================================================================================================================
// usage of variant data container
//========================================================================================================================
 
//Assigns a shape type via shape_type function
ShapeType figure=shape_type();
 
//prints the type of the figure given by the user
const std::type_info &ti=figure.type();//captures the type
cout<<"The created figure type is an object of the "<<ti.name()<<endl;//calls its names and prints it
cout<<figure;//the user assignation is sent to the cout using the overloaded << operator in each shape class
 
Line l(Point(3,4),Point(6,8));//creates a Line
try{
boost::get<Line>(figure)=l;//assigns Line l to the figure variant
}
catch(boost::bad_get e){
std::cout << "***********************bad get error**************************" <<std::endl;
}
 
boost::apply_visitor(VisitorClass(9,12),figure);//shifts the figure according to a user given values
cout<<figure;//the user assignation is sent to the cout.
return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
// shape.h 
class Shape
{
    protected: 
int m_id;  // Add a data member for an id number of type int.
    public: 
int id; 
int ID() const; // return n_id data
Shape(); // initialises the id using a random number
Shape(const Shape &OtherShape); // copies the id member
Shape& operator = (const Shape &OtherShape); // copies the id member
virtual void ToString() const ; // returns the id as string e.g. “ID: 123”
};
 
//point.h
class Point : public Shape
 
{
    private:
double Xcoord;
double Ycoord;
 
    public:
Point();
Point (double xNew, double yNew);
Point( const Point& point); // copy constructor for Point
~Point();
      
void X( double Value);
void Y( double Value);
double X() const;
double Y() const;
 
Point& operator = ( const Point& p);
friend ostream& operator << (ostream& os ,  const Point& p);
void ToString() const;
 
};
 
// line.h
class Line : public Shape
{
     private:
      Point start; 
      string discrib;
      Point end;
 
   public:
      //constructors and destructor
      Line();
      Line(const string& x, const Point& P_start, const Point& P_end);
      Line(const Line& line); // line copy constructor
      ~Line();
        
      //getters and setters
      void SetStart ( const Point& SomePoint);
      void SetEnd ( const Point& SomePoint);
      Point GetStart() const ;
      Point GetEnd() const ;
 
      Line& operator = ( const Line& l);
      friend ostream& operator << (ostream& os , const Line& l);
 
      //other useful methods
      void ToString() const; 
};
 
//line.cpp
Line::Line():start(Point(0, 0)), end(Point(0, 0)){}
 
Line::Line(const string& x, const Point& P_start, const Point& P_end)
    :discrib(x), start(P_start), end(P_end) {}
 
Line::Line( const Line& line)
{
    start = line.start;
    end = line.end;
}
 
Line::~Line() {}
 
void Line::SetStart( const Point& SomePoint)
    {
   start = SomePoint;
    }
 
void Line::SetEnd ( const Point& SomePoint)
    {
  end = SomePoint;
    }
 
Point Line::GetStart() const
    {
   return start;
    }
 
Point Line::GetEnd() const
    {
   return end;
    }
 
Line& Line::operator = ( const Line& l)
     {
    if (this == &l)
    {
        return * this; 
    }
    /*member function from base class */
    m_id = l.m_id;
    /* data from derived class*/
    discrib = l.discrib;
    start = l.start;
    end = l.end;
    return *this ;
    } 
 
 
 
void Line::ToString() const  // returns the line as string              
    {
    cout << "[[" << discrib << "," 
         << start << "," << end << "]]" << endl;
    }
 
 
ostream& operator << ( ostream& os , const  Line& l)
    {
        os << "[" << l.GetStart() << "," << l.GetEnd() << "]";
        return os ; 
    }
 
//Point.cpp
 
Point::Point() : Xcoord(0), Ycoord(0) {}
 
 Point::Point (double xNew, double yNew)
     : Xcoord(xNew), Ycoord(yNew) {}
 
Point::~Point() {} //Destructor
 
Point::Point( const Point& point) // Point copy constructor
{
    Xcoord = point.Xcoord;
    Ycoord = point.Ycoord;
}
 
 
void Point::X( double Value) 
{//Assign X-coordinate the Value that is put into the main
    Xcoord = Value; 
}
 
void Point::Y( double Value) 
{//Assing Y-coordinate the Value that is put into the main
    Ycoord = Value;
}
 
double Point::X()  const
{
return Xcoord;//Return X-coordinate
}
 
double Point::Y()  const
{
return Ycoord;//Return Y-coordinate
}
 
 
void Point::ToString() const
    {
cout << "( " << X() << "," 
     << Y() << " )";
    }
 
Point& Point::operator = ( const Point& p)
{
    if (this == &p)
    {
        return * this; 
    }   
 
m_id = p.m_id;// member function from base class    
Xcoord = p.Xcoord;// data from derived class
Ycoord = p.Ycoord;
return *this; 
}
 
ostream& operator << (ostream& os ,  const Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }
 
 
Shape::Shape() // initialises the id using a random number
    
    {
    m_id = rand();
    ///cout << "id of shape is: " << m_id << endl; 
    }
 
int Shape::ID() const // retrieve the id of the shape
    {
    return m_id; 
    }
    
void Shape::ToString() const // returns the id as string              
{
    // cout << "ID: "<< ID(); 
}
 
Shape::Shape(const Shape &OtherShape)
    {//copy constructor that copies the id member
        id = OtherShape.m_id;
    }
    
Shape& Shape::operator = (const Shape& OtherShape)
    {//assignment operator that copies the id member
    
    if (this == &OtherShape)
        {
            return *this;
        }
    m_id = OtherShape.m_id;
    return *this; 
    }
 
 
 
//main.cpp
//Variant
 
#include <boost/variant.hpp>//includes boost class for variant
#include <iostream>// C++ style I/O using operator overloading
 
 
//defines a shape type that can be of the form Point, Line or Circle
typedef boost::variant<Point, Line/*, Circle*/> ShapeType;
 
//function that returns a variant with the specified shape
 
ShapeType shape_type(){
int type;//selector variable
cout<<"Please enter 1 for shape of Point type"<<endl;
cout<<"Please enter 2 for shape of Line type"<<endl;
//cout<<"Please enter 3 for shape of Circle type"<<endl;
cin>>type;
 
//assigns the user given type to the variant
if(type==1){//creates a point and returns it
return Point();
}
else if(type==2){//creates a line and returns it
return Line();
}
/*else if(type==3){//creates a circle and returns it
return Circle();
}*/
}
 
//Visitor class
class VisitorClass: public boost::static_visitor<void>{
private:
double m_dx;//x delta to move
double m_dy;//y delta to move
public:
//==================================================================================================
//modifiers
//==================================================================================================
//function that Visits a point and moves its X,Y values
VisitorClass(double xval,double yval):m_dx(xval),m_dy(yval){
}
 
void operator()(Point& p) const{
//modifies the values of the point according to the user given inputs
p.X(p.X()+m_dx);
p.Y(p.Y()+m_dy);
}
 
//function that Visits a Line and moves its X,Y values of the starting and ending points
void operator()(Line& l) const{
//modifies the values of the starting point according to the user given inputs
//l.p1().X(l.p1().X()+m_dx);
//l.p1().Y(l.p1().Y()+m_dy);
l.GetStart().X(l.GetStart().X()+m_dx);
l.GetStart().Y(l.GetStart().Y()+m_dx);
 
 
 
//modifies the values of the ending point according to the user given inputs (scaled by 2)
//l.p2().X(l.p2().X()+m_dx*2);
//l.p2().Y(l.p2().Y()+m_dy*2);
l.GetEnd().X(l.GetEnd().X()+m_dx*2);
l.GetEnd().Y(l.GetEnd().Y()+m_dy*2);
}
 
//function that Visits a Circle and moves its X,Y values of its center
/*void operator()(Circle& c) const{
//modifies the values of the center point with the user given values
c.centerPoint().X((c.centerPoint().X()+m_dx));
c.centerPoint().Y((c.centerPoint().Y()+m_dy));
c.radius(m_dx+m_dy);
}*/
};
 
int main(){
 
//========================================================================================================================
// usage of variant data container
//========================================================================================================================
 
//Assigns a shape type via shape_type function
ShapeType figure=shape_type();
 
//prints the type of the figure given by the user
const std::type_info &ti=figure.type();//captures the type
cout<<"The created figure type is an object of the "<<ti.name()<<endl;//calls its names and prints it
cout<<figure;//the user assignation is sent to the cout using the overloaded << operator in each shape class
 
Line l("MyLine",Point(3,4),Point(6,8));//creates a Line
try{
boost::get<Line>(figure)=l;//assigns Line l to the figure variant
}
catch(boost::bad_get e){
std::cout << "***********************bad get error**************************" <<std::endl;
}
 
boost::apply_visitor(VisitorClass(9,12),figure);//shifts the figure according to a user given values
cout<<figure;//the user assignation is sent to the cout.
return 0;
}

// line.h
#ifndef LINE_H
#define LINE_H
#include "Shape.h"
#include "Point.h"
#include <ostream>
 
class Line : public Shape
{
     private:
      Point start; 
     // string discrib;
      Point end;
 
   public:
      //constructors and destructor
      Line();
      Line(  Point& P_start,  Point& P_end);
      Line(const Line& line); // line copy constructor
      ~Line();
        
      //getters and setters
      void SetStart (  Point& SomePoint);
      void SetEnd (  Point& SomePoint);
      Point GetStart() const ;
      Point GetEnd() const ;
 
      Line& operator = ( const Line& l);
      friend ostream& operator << (ostream& os , const Line& l);
 
      //other useful methods
      void ToString() const; 
};
 
#endif 
 
//point.h
#ifndef POINT_H
#define POINT_H
 
#include "Shape.h"
#include <ostream>
class Point : public Shape
 
{
    private:
double Xcoord;
double Ycoord;
 
    public:
Point();
Point (double xNew, double yNew);
Point( const Point& point); // copy constructor for Point
~Point();
      
void X( double Value);
void Y( double Value);
double X() const;
double Y() const;
 
Point& operator = ( const Point& p);
friend ostream& operator << (ostream& os ,  const Point& p);
void ToString() const;
 
};
 
#endif 
 
#ifndef Shape_h
#define Shape_h
#include <string>
#include <iostream>
using namespace std;
 
// shape.h 
class Shape
{
    protected: 
int m_id;  // Add a data member for an id number of type int.
    public: 
int id; 
int ID() const; // return n_id data
Shape(); // initialises the id using a random number
Shape(const Shape &OtherShape); // copies the id member
Shape& operator = (const Shape &OtherShape); // copies the id member
virtual void ToString() const ; // returns the id as string e.g. “ID: 123”
};
 
 
#endif 
 
//line.cpp
#include <iostream>
#include "line.h"
 
using namespace std;
Line::Line():start(Point(1, 2)), end(Point(3, 1)){}
 
Line::Line( Point& P_start,  Point& P_end)
    : start(P_start), end(P_end) {}
 
Line::Line( const Line& line)
{
    start = line.start;
    end = line.end;
}
 
Line::~Line() {}
 
void Line::SetStart(  Point& SomePoint)
    {
   start = SomePoint;
    }
 
void Line::SetEnd (  Point& SomePoint)
    {
  end = SomePoint;
    }
 
Point Line::GetStart() const
    {
   return start;
    }
 
Point Line::GetEnd() const
    {
   return end;
    }
 
Line& Line::operator = ( const Line& l)
     {
    if (this == &l)
    {
        return * this; 
    }
    /*member function from base class */
    m_id = l.m_id;
    /* data from derived class*/
   
    start = l.start;
    end = l.end;
    return *this ;
    } 
 
 
 
void Line::ToString() const  // returns the line as string              
    {
    cout << "[["  
         << start << "," << end << "]]" << endl;
    }
 
 
ostream& operator << ( ostream& os , const  Line& l)
    {
        os << "[" << l.GetStart() << "," << l.GetEnd() << "]";
        return os ; 
    }
 
//Point.cpp
 #include <iostream>
#include "Point.h"
 
using namespace std;
 
Point::Point() : Xcoord(0), Ycoord(0) {}
 
 Point::Point (double xNew, double yNew)
     : Xcoord(xNew), Ycoord(yNew) {}
 
Point::~Point() {} //Destructor
 
Point::Point( const Point& point) // Point copy constructor
{
    Xcoord = point.Xcoord;
    Ycoord = point.Ycoord;
}
 
 
void Point::X( double Value) 
{//Assign X-coordinate the Value that is put into the main
    Xcoord = Value; 
}
 
void Point::Y( double Value) 
{//Assing Y-coordinate the Value that is put into the main
    Ycoord = Value;
}
 
double Point::X()  const
{
return Xcoord;//Return X-coordinate
}
 
double Point::Y()  const
{
return Ycoord;//Return Y-coordinate
}
 
 
void Point::ToString() const
    {
cout << "( " << X() << "," 
     << Y() << " )";
    }
 
Point& Point::operator = ( const Point& p)
{
    if (this == &p)
    {
        return * this; 
    }   
 
m_id = p.m_id;// member function from base class    
Xcoord = p.Xcoord;// data from derived class
Ycoord = p.Ycoord;
return *this; 
}
 
ostream& operator << (ostream& os ,  const Point& p)
    {
        os << "[" << p.X() << "," << p.Y() << "]";
        return os ; 
    }
 
 
 
 
//Shape.cpp 
#include <iostream>
#include "Shape.h"
 
//using namespace std; 
 
 
 
Shape::Shape() // initialises the id using a random number
    
    {
    m_id = rand();
    ///cout << "id of shape is: " << m_id << endl; 
    }
 
int Shape::ID() const // retrieve the id of the shape
    {
    return m_id; 
    }
    
void Shape::ToString()  const// returns the id as string              
{
    // cout << "ID: "<< ID(); 
}
 
Shape::Shape(const Shape &OtherShape)
    {//copy constructor that copies the id member
        id = OtherShape.m_id;
    }
    
Shape& Shape::operator = (const Shape& OtherShape)
    {//assignment operator that copies the id member
    
    if (this == &OtherShape)
        {
            return *this;
        }
    m_id = OtherShape.m_id;
    return *this; 
    }
 
 
 
//main.cpp
 
#include "Point.h"                  //header file declaration of class Point
#include "Line.h"                   //header file declaration of class Line
//#include "Circle.h"               //header file declaration of class Circle
#include "Shape.h"                  //header file declaration of class Shape
#include <boost/variant.hpp>        //includes boost class for variant
#include <iostream>                 // C++ style I/O using operator overloading
#include <ostream>
using namespace std;                // The C++ logical collection of functions
 
 
//defines a shape type that can be of the form Point, Line or Circle
typedef boost::variant<Point, Line/*, Circle*/> ShapeType;
 
//function that returns a variant with the specified shape
 
ShapeType shape_type()
{
int type;//selector variable
cout<<"Please enter 1 for shape of Point type"<<endl;
cout<<"Please enter 2 for shape of Line type"<<endl;
//cout<<"Please enter 3 for shape of Circle type"<<endl;
cin>>type;
 
//assigns the user given type to the variant
    if(type==1)
        {                       //creates a point and returns it
        return Point();
        }
    else if(type==2)
        {               //creates a line and returns it
        return Line();
        }
/*else if(type==3){//creates a circle and returns it
return Circle();
}*/
}
 
//Visitor class
class VisitorClass: public boost::static_visitor<void>
{
private:
double m_dx;//x delta to move
double m_dy;//y delta to move
public:
//==================================================================================================
//modifiers
//==================================================================================================
//function that Visits a point and moves its X,Y values
    VisitorClass(double xval,double yval):m_dx(xval),m_dy(yval) {}
 
 
void operator()(Point& p) const 
{
//modifies the values of the point according to the user given inputs
p.X(p.X()+m_dx);
p.Y(p.Y()+m_dy);
}
 
//function that Visits a Line and moves its X,Y values of the starting and ending points
void operator()(Line& l) const 
{
//modifies the values of the starting point according to the user given inputs
//l.p1().X(l.p1().X()+m_dx);
//l.p1().Y(l.p1().Y()+m_dy);
//l.GetStart().X(l.GetStart().X()+m_dx);
//l.GetStart().Y(l.GetStart().Y()+m_dx);
l.GetStart().X(l.GetStart().X()+m_dx);
l.GetStart().Y(l.GetStart().Y()+m_dx);
 
 
 
//modifies the values of the ending point according to the user given inputs (scaled by 2)
//l.p2().X(l.p2().X()+m_dx*2);
//l.p2().Y(l.p2().Y()+m_dy*2);
l.GetEnd().X(l.GetEnd().X()+m_dx*2);
l.GetEnd().Y(l.GetEnd().Y()+m_dy*2);
}
 
//function that Visits a Circle and moves its X,Y values of its center
/*void operator()(Circle& c) const{
//modifies the values of the center point with the user given values
c.centerPoint().X((c.centerPoint().X()+m_dx));
c.centerPoint().Y((c.centerPoint().Y()+m_dy));
c.radius(m_dx+m_dy);
}*/
};
 
int main(){
 
//========================================================================================================================
// usage of variant data container
//========================================================================================================================
 Point p(11,1);
 Point p1(2,2);
 Point p2(3,3);
Line l(Point(3,4),Point(6,8));
//Assigns a shape type via shape_type function
ShapeType figure=shape_type();
 cout << "\n\n\t myLine" << l << "\n\n\t";
 
  try
{
 
 
switch (figure.which())
{
case 0: cout << "\n\n\tPoint"; break;
case 1: cout << "\n\n\tLine"; break;
default : cout << "invalide input" ; 
}
 
 
//the user assignation is sent to the cout using the overloaded << operator in each shape class
 
//creates a Line
 
    
boost::get<Point>(figure)=p;//assigns Line l to the figure variant
boost::get<Line>(figure)=l;//assigns Line l to the figure variant
}
catch(boost::bad_get e)
{
std::cout << "\n\n\t***********************bad get error**************************" <<std::endl;
}
 
 cout<<"\n\n\t BEFORE VISITOR "<< figure << "\n\n\t ";
boost::apply_visitor(VisitorClass(9,12),figure);//shifts the figure according to a user given values
cout<<"\n\n\t AFTER VISITOR "<<figure;//the user assignation is sent to the cout.
cout << "\n\n\t";
system ("pause");
return 0;
}