PhysicalDevice/Machine/MachineryECOM/Trunk/DIOS.Dev.Machinery.Common/DIOS.Dev.Machinery.BaseComponent/MechnicalComponentFactory.cpp

#include "stdafx.h"
#include "MechnicalComponentFactory.h"
#include "DetectorHeightController.h"
#include "TubeAngleController.h"
#include "TubeHeightController.h"
#include "SensorADController.h"
#include "SensorEncoderController.h"
#include "ConfigureController.h"
#include "ExposureController.h"
#include "LandmarkController.h"
#include "CollimatorController.h"
#include "TubeCircularController.h"
#include "TubeSwingController.h"
#include "SensorEncoderCArmYiDongController.h"
#include "FluoroSwitchController.h"
#include "TubeLineMotionSwitchController.h"
#include "TubeHorizontalController.h"

using namespace DIOS::Dev::Detail::MachineryECOM;

MechnicalComponentFactory *MechnicalComponentFactory::m_instance = nullptr;

MechnicalComponentFactory::MechnicalComponentFactory()
{
}


MechnicalComponentFactory::~MechnicalComponentFactory()
{
}

IMechnicalComponentFactory *MechnicalComponentFactory::Instance()
{
	if (m_instance == nullptr)
	{
		m_instance = new MechnicalComponentFactory();
	}

	return m_instance;
}

IComponentController *MechnicalComponentFactory::CreateController(COMPONENT_CONTROLLER_TYPE type, const std::string &name)
{
	IComponentController *controller = nullptr;
	switch (type)
	{
	case COMPONENT_CONTROLLER_TOMO_DETECTORHEIGHT:
		controller = CreateDetectorHeightController(name);
		break;
	case COMPONENT_CONTROLLER_TOMO_TUBEANGLE:
		controller = CreateTubeAngleController(name);
			break;
	case COMPONENT_CONTROLLER_TOMO_TUBEHEIGHT:
		controller = CreateTubeHeightController(name);
			break;
	case COMPONENT_CONTROLLER_AD:
		controller = CreateSensorADController(name);
			break;
	case COMPONENT_CONTROLLER_ENCODER:
		controller = CreateSensorEncoderController(name);
			break;
	case COMPONENT_CONTROLLER_LANDMARK:
		controller = CreateLandmarkController(name);
			break;
	case COMPONENT_CONTROLLER_EXPOSURE:
		controller = CreateExposureController(name);
			break;
	case COMPONENT_CONTROLLER_COLLIMATOR:
		controller = CreateCollimatorController(name);
			break;
	case COMPONENT_CONTROLLER_CARM_TUBECIRCULAR:
		controller = CreateCArmTubeCircularController(name);
		break;
	case COMPONENT_CONTROLLER_CARM_TUBESWING:
		controller = CreateCArmTubeSwingController(name);
		break;
	case COMPONENT_CONTROLLER_FLUOROSWITCH:
		controller = CreateFluoroSwitchController(name);
		break;
	case COMPONENT_CONTROLLER_TOMO_TUBEHORIZONTAL:
		controller = CreateTubeHorizontalController(name);
		break;
	case COMPONENT_CONTROLLER_TUBE_LINE_MOTION_SWITCH:
		controller = CreateTubeLineSwitchController(name);
		break;
	default:
		break;
	}

	return controller;
}

IComponentController *MechnicalComponentFactory::CreateDetectorHeightController(const std::string &name)
{
	if (m_detectorHeightControllers.find(name) == m_detectorHeightControllers.end())
	{
		IDetectorHeightController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == DetectorHeightController::CLASSID())
		{
			IDetectorHeightController *controller = new DetectorHeightController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_detectorHeightControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}
	return m_detectorHeightControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateTubeAngleController(const std::string &name)
{
	if (m_tubeAngleControllers.find(name) == m_tubeAngleControllers.end())
	{
		ITubeAngleController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeAngleController::CLASSID())
		{
			controller = new TubeAngleController();
		}
		if (controller)
		{
			controller->Initialize(name);
			m_tubeAngleControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_tubeAngleControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateTubeHeightController(const std::string &name)
{
	if (m_tubeHeightControllers.find(name) == m_tubeHeightControllers.end())
	{
		ITubeHeightController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeHeightController::CLASSID())
		{
			controller = new TubeHeightController();
		}
		
		if (controller)
		{
			controller->Initialize(name);
			m_tubeHeightControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}
	return m_tubeHeightControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateSensorADController(const std::string &name)
{
	if (m_sensorADControllers.find(name) == m_sensorADControllers.end())
	{
		ISensorADController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == SensorADController::CLASSID())
		{
			controller = new SensorADController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_sensorADControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}
	return m_sensorADControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateSensorEncoderController(const std::string &name)
{
	if (m_sensorEncoderControllers.find(name) == m_sensorEncoderControllers.end())
	{
		ISensorEncoderController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == SensorEncoderController::CLASSID())
		{
			controller = new SensorEncoderController();
		}
		else if (classid == SensorEncoderCArmYiDongController::CLASSID())
		{
			controller = new SensorEncoderCArmYiDongController();
		}
		
		if (controller)
		{
			controller->Initialize(name);
			m_sensorEncoderControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_sensorEncoderControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateExposureController(const std::string &name)
{
	if (m_exposureControllers.find(name) == m_exposureControllers.end())
	{
		IExposureController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == ExposureController::CLASSID())
		{
			controller = new ExposureController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_exposureControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_exposureControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateLandmarkController(const std::string &name)
{
	if (m_landmarkControllers.find(name) == m_landmarkControllers.end())
	{
		ILandmarkController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == LandmarkController::CLASSID())
		{
			controller = new LandmarkController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_landmarkControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_landmarkControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateCollimatorController(const std::string &name)
{
	if (m_collimatorControllers.find(name) == m_collimatorControllers.end())
	{
		ICollimatorController *controller = nullptr;
		
		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == CollimatorController::CLASSID())
		{
			controller = new CollimatorController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_collimatorControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_collimatorControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateCArmTubeCircularController(const std::string &name)
{
	if (m_tubeCircularControllers.find(name) == m_tubeCircularControllers.end())
	{
		IComponentController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeCircularController::CLASSID())
		{
			controller = new TubeCircularController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_tubeCircularControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_tubeCircularControllers[name];
}

IComponentController *MechnicalComponentFactory::CreateCArmTubeSwingController(const std::string &name)
{
	if (m_tubeSwingControllers.find(name) == m_tubeSwingControllers.end())
	{
		IComponentController *controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeSwingController::CLASSID())
		{
			controller = new TubeSwingController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_tubeSwingControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_tubeSwingControllers[name];
}

IComponentController* MechnicalComponentFactory::CreateFluoroSwitchController(const std::string& name)
{
	if (m_fluoroSwitchControllers.find(name) == m_fluoroSwitchControllers.end())
	{
		IOutputController* controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == FluoroSwitchController::CLASSID())
		{
			controller = new FluoroSwitchController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_fluoroSwitchControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_fluoroSwitchControllers[name];
}

IComponentController* MechnicalComponentFactory::CreateTubeLineSwitchController(const std::string& name)
{
	if (m_tubeLineSwitchControllers.find(name) == m_tubeLineSwitchControllers.end())
	{
		IOutputController* controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeLineMotionSwitchController::CLASSID())
		{
			controller = new TubeLineMotionSwitchController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_tubeLineSwitchControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}

	return m_tubeLineSwitchControllers[name];
}

IComponentController* MechnicalComponentFactory::CreateTubeHorizontalController(const std::string& name)
{
	if (m_tubeHorizontalControllers.find(name) == m_tubeHorizontalControllers.end())
	{
		TubeHorizontalController* controller = nullptr;

		auto classid = ConfigureController::GetControllerClassID(name);
		if (classid == TubeHorizontalController::CLASSID())
		{
			controller = new TubeHorizontalController();
		}

		if (controller)
		{
			controller->Initialize(name);
			m_tubeHorizontalControllers[name] = controller;
		}
		else
		{
			return nullptr;
		}
	}
	return m_tubeHorizontalControllers[name];
}