Automatizar la creación de objetos mediante una canalización

¡Hola, Habr!

No soy un experto muy famoso, pero estoy muy interesado en el proceso de procesamiento de datos, así como en escribir código para procesar estos mismos datos. En el proceso de escribir varios métodos para procesar estos mismos datos, tuve la idea de la automatización parcial, ejem, métodos de procesamiento de escritura.

Introducción

Supongamos que tenemos un conjunto de herramientas (entidades) para procesar algún tipo de flujo de datos, o construir otras entidades complejas, así como condiciones en constante cambio para que la secuencia de composición de estas entidades reproduzca el algoritmo de procesamiento.

Usando vehículos como ejemplo

Contamos con un conjunto de componentes atómicos:

	class EngineA;
	class EngineB;

	class WingsA;
	class WingsB;

	class FrameA;
	class FrameB;

	class WheelsA;
	class WheelsB;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

etc.

Si necesitamos un automóvil, simplemente declaramos la clase de automóvil , que tiene la carrocería, ruedas, motor, etc. deseados. Del mismo modo, con un barco, declararíamos una clase Barco y esbozaríamos rápidamente la agregación de las partes necesarias del barco.

Si necesitamos un bote, un automóvil e incluso un avión, podemos usar el patrón de fábrica, pero qué hacer si necesitamos autos, botes, aviones, y no sabemos de antemano cuántos, cuándo y en qué orden .

, 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();
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , .

, , / .

De los puntos débiles de este enfoque para construir objetos, puedo señalar la necesidad de agregar nuevos tipos al diccionario cada vez, así como agregar constantemente el intérprete de nuevos parámetros de texto si constantemente agrega nuevos componentes atómicos.