Automatisieren der Erstellung von Objekten mithilfe einer Pipeline

Hallo Habr!

Ich bin kein sehr berühmter Experte, aber ich interessiere mich sehr für den Prozess der Datenverarbeitung sowie für das Schreiben von Code, um genau diese Daten zu verarbeiten. Beim Schreiben verschiedener Methoden zur Verarbeitung dieser Daten kam mir die Idee, Teilautomatisierung, ähm, Verarbeitungsmethoden zu schreiben.

Einführung

Angenommen, wir verfügen über eine Reihe von Tools (Entitäten) zum Verarbeiten eines Datenstroms oder zum Erstellen anderer komplexer Entitäten sowie über ständig wechselnde Bedingungen für die Reihenfolge der Zusammensetzung dieser Entitäten, um den Verarbeitungsalgorithmus zu reproduzieren.

Am Beispiel von Fahrzeugen

Wir haben eine Reihe von atomaren Komponenten:

	class EngineA;
	class EngineB;

	class WingsA;
	class WingsB;

	class FrameA;
	class FrameB;

	class WheelsA;
	class WheelsB;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

usw.

Wenn wir ein Auto brauchen, geben wir einfach die Fahrzeugklasse an, die die gewünschte Karosserie, Räder, Motor usw. hat. Ebenfalls mit einem Boot, würden wir erklären eine Bootsklasse , und schnell die Aggregation der benötigten Teile des Bootes skizzieren.

Wenn wir ein Boot, ein Auto und sogar ein Flugzeug benötigen, können wir das Fabrikmuster verwenden, aber was tun, wenn wir Autos, Boote, Flugzeuge benötigen und wir nicht im Voraus wissen, wie viele, wann und in welcher Reihenfolge .

, Car, Boat, Plane ITransport. 2 , 5 - . , , . -

, !

, ITransport

class ITransport
{
	public:

	virtual void move() = 0; 
};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Car, Boat, Plane.

class Car final : public virtual ITransport
{
public:

	Car() = default; 
	~Car() = default;

	void move() override
	{
		std::cout << "Car is move" << std::endl;
		// do something with parts
	}
      
 private:
      
    std::unique_ptr < IFrame >	_frame; 
    std::unique_ptr < IWheels >	_wheels; 
		std::unique_ptr < IEngine > _engine;
};


class Boat final : public virtual ITransport
{
public:

	Boat() = default; 
	~Boat() = default;

	void move() override
	{
		std::cout << "Boat is move" << std::endl;
		// do something with parts
	}
      
private:

	std::unique_ptr < IFrame >	_frame; 
	std::unique_ptr < IEngine>  _engine;
};

class Plane final : public virtual ITransport
{
public:

	Plane() = default; 
	~Plane() = default;

	void move() override
	{
		std::cout << "Plane is move" << std::endl;
		// do something with parts
	}

private:

	std::unique_ptr < IFrame > _frame;
	std::unique_ptr < IEngine> _engine;
	std::unique_ptr < IWings > _wings;
};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

2 , , 3 , .

, . .

enum class VehTypes
{
	Car,
	Boat,
	Plane
};
	 
static std::map < std::string, VehTypes > VehCast{
	{"Car", VehTypes::Car},
	{"Boat", VehTypes::Boat},
	{"Plane", VehTypes::Plane}
};

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .

class Conveyor final
{
		
public:
			 
	using _TyParameters = std::map < std::string, std::string >; 
	using _TyStorage = std::vector < _TyParameters >;

	Conveyor(const _TyStorage& blueprints)
		: _blueprints(blueprints) { }

	~Conveyor() = default;

	std::vector < Vehicles::ITransport* > vehicles()
	{
		std::vector < Vehicles::ITransport* > result;

		for (auto&& blueprint : _blueprints)
		{

			switch (VehCast[blueprint["type"]])
			{
				case VehTypes::Car: result.emplace_back(new Vehicles::Car());
				break;

				case VehTypes::Boat: result.emplace_back(new Vehicles::Boat());
				break;

				case VehTypes::Plane: result.emplace_back(new Vehicles::Plane());
				break;
			}
		}

		return result;
	}
			 
private: 

	_TyStorage _blueprints;
};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .

:

• -

  
  
  
  
  

• - , .

  
  
  
  
  

using _TyParameters = std::map < std::string, std::string >; 
using _TyStorage = std::vector < _TyParameters >;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, ( ).

, - , .

( ) .

.

.

Conveyor::_TyStorage blueprints
{
  {
    {"type", "Car"}, {"engineType", "EngineA"}, {"wheelsType", "WheelsB"}, etc..
  },		
  {
    {"type", "Car"},  
  },		
  {
    {"type", "Boat"},  
  },		
  {
    {"type", "Plane"},  
  },		
  {
    {"type", "Plane"},  
  },		
  {
    {"type", "Plane"}
  },		
  {
    {"type", "Boat"}
  },
};

Conveyor conveyor(blueprints);

for (auto&& transport : conveyor.vehicles())
{
	transport->move();
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , .

, , / .

Von den Schwachstellen dieses Ansatzes zum Erstellen von Objekten kann ich die Notwendigkeit feststellen, jedes Mal neue Typen zum Wörterbuch hinzuzufügen und ständig den Interpreter für neue Textparameter hinzuzufügen, wenn Sie ständig neue atomare Komponenten hinzufügen.