fabricadefig2.cpp

descriere descriere descriere

#pragma warning(disable:4786)
#pragma warning(disable:4083)
#include <iostream>
#include <fstream>
#include <map>
#include <list>

using namespace std;

class Figura 
{
public:
	Figura()
	{ 
	//	std::cout << "Figura();\n";
	}
	virtual void citeste(std::ifstream&) =0;
	virtual void Afis(std::ofstream&) =0;
};


class FabricaDeFigBaza
{

public:

    typedef Figura* (*DelegatCreareFig)();
    
	FabricaDeFigBaza() {  }
    
	bool inregistreazaFig(int figId, DelegatCreareFig fctCreare);   // intoarce "true" daca inregistrarea este OK
    
	bool elimina(int figId);										// intoarce 'true' daca figura a fost inregistrata inainte
   
	Figura* creeazaFig(int figId);

private:

    typedef std::map<int, DelegatCreareFig> DelegatMap;
    DelegatMap delegati_;
};

bool FabricaDeFigBaza::inregistreazaFig(int figId,
     DelegatCreareFig fctCreare)
{
    return delegati_.insert(
         DelegatMap::value_type(figId, fctCreare)).second;
}

bool FabricaDeFigBaza::elimina(int figId)
{
    return delegati_.erase(figId) == 1;
            
}

Figura* FabricaDeFigBaza::creeazaFig(int figId)
{
    DelegatMap::const_iterator i = delegati_.find(figId);
    if (i == delegati_.end())
    {
        // nu a gasit
        throw "ID de figura necunoscut\n";
    }
    // invoca functia de creare
    return (i->second)();
}

//
// fabrica cu o singura instanta
//

class FabricaDeFig : public FabricaDeFigBaza
{
public:
  static FabricaDeFig& Instanta() {return fabricaFig;}
private:
  static FabricaDeFig fabricaFig;
  FabricaDeFig() { }
  void operator=(FabricaDeFig&);
  FabricaDeFig(const FabricaDeFig&);
};

FabricaDeFig FabricaDeFig::fabricaFig;

//
// containerul de figuri
//

class ContainerFig
{
private:
	std::list<Figura *> cntnr;
public:
	ContainerFig() {}
	~ContainerFig() {}
	void incarca(std::ifstream&);
	void ScrieFisier(std::ofstream&);
};

void ContainerFig::incarca(std::ifstream& inp)
{
    int figId;
	// citeste tipul figurii
	inp >> figId;
    while (inp)
    {
        //creeaza un obiect vid
		Figura* pfig = FabricaDeFig::Instanta().creeazaFig(figId);
		// incarca obiectul
        pfig->citeste(inp);
		cntnr.push_back(pfig);
		
		// citeste tipul noii figuri
		inp >> figId;
    }
}

void ContainerFig::ScrieFisier(std::ofstream& out)
{
	int figId;
	Figura* pfig ;//= FabricaDeFig::Instanta().creeazaFig(1);
	while (!cntnr.empty())
	{
		pfig = cntnr.front();
		cntnr.pop_front();
		pfig->Afis(out);
	}


}

class Cerc : public Figura
{
private :
	double x,y,r;
	int ID;
public:
	Cerc()
	{
		std::cout << "Cerc\n";
		ID=1;
	}
	virtual void citeste(std::ifstream& is) 
	{
		is >> x >> y >> r;
	}
	
	virtual void Afis(std::ofstream& is) 
	{
		is << ID << endl;
		is << x <<" " << y<<" " << r<< endl;
	}
};

namespace
{
    Figura* creeazaCerc()
    {
        return new Cerc;
    }
    // Id-ul pentru segment
    const int CERCID = 1;
    // inregistreaza
    const bool registeredCERC =
        FabricaDeFig::Instanta().inregistreazaFig(CERCID, creeazaCerc);
};

class Patrat : public Figura
{
private:
	double x,y,l;
	int ID;
public:
	Patrat()
	{
		std::cout << "Patrat \n";
		ID=2;
	}
	virtual void citeste(std::ifstream& is) 
	{
		is >> x >> y >> l;
	}
	virtual void Afis(std::ofstream& is) 
	{
		is << ID << endl;
		is << x <<" " << y<<" "  << l<< endl;
	}
};


// implementarea modulului pentru Segment
// creeaza un spatiu anonim pentru a face functia invizibila 
// pentru alte module

namespace
{
    Figura* creeazaPatrat()
    {
        return new Patrat;
    }
    // Id-ul pentru segment
    const int PATRATID = 2;
    // inregistreaza
    const bool registeredPATRAT =
        FabricaDeFig::Instanta().inregistreazaFig(PATRATID, creeazaPatrat);
}

class Triunghi : public Figura
{
private :
	double x1,x2,x3,y1,y2,y3;
	int ID;
public:
	Triunghi()
	{
		std::cout << "Triunghi \n";
		ID=3;
	}
	virtual void citeste(std::ifstream& is) 
	{
		is >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
	}
	
	virtual void Afis(std::ofstream& is) 
	{
		is << ID << endl;
		is << x1 <<" " << y1<<" "  << x2<<" "  << y2<<" "  << x3<<" "  << y3<<" " << endl;
	}

};


// implementarea modulului pentru Segment
// creeaza un spatiu anonim pentru a face functia invizibila 
// pentru alte module

namespace
{
    Figura* creeazaTriunghi()
    {
        return new Triunghi;
    }
    // Id-ul pentru segment
    const int TRID = 3;
    // inregistreaza
    const bool registeredTR =
        FabricaDeFig::Instanta().inregistreazaFig(TRID, creeazaTriunghi);
}

void main()
{
		ContainerFig  cf;
	try {
		std::ifstream inp("inp.dat");
		cf.incarca(inp);
		inp.close();
		//return 0;
	}
	catch (char* msg)
	{
		std::cout << msg;
	}
	std::ofstream out("out.dat");
	cf.ScrieFisier(out);
	out.close();
	
}