SetupOLD.cpp
No OneTemporary
Actions

Size

12 KB

Referenced Files

None

Subscribers

None

SetupOLD.cpp
View Options

	#include "SetupOLD.h"
	#include "rlutil.h"

	using namespace rlutil;

	SetupOLD::SetupOLD() {

	}



	void SetupOLD::printMountingProcessImpossible() {
	setColor(LIGHTRED);
	printf(" > Process of Mounting is impossible\n");
	setColor(GREY);
	}

	void SetupOLD::printAgentGotMounted(Agent* masterAgent, Agent* slaveAgent) {
	printf(" > Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", slaveAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u) ", slaveAgent->getId());
	setColor(LIGHTGREEN);
	printf("mounted ");
	setColor(GREY);
	printf("in Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", masterAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", masterAgent->getId());
	}

	void SetupOLD::printAgentCouldntGetMounted(Agent* masterAgent, Agent* slaveAgent) {
	setColor(LIGHTRED);
	printf(" > Agent %s (%03u) couldn't get mounted in Agent %s (%03u)\n", slaveAgent->getName().c_str(), slaveAgent->getId(), masterAgent->getName().c_str(), masterAgent->getId());
	setColor(GREY);
	}

	void SetupOLD::printHistoryModuleGotMounted(Agent* agent, HistoryModule* historyModule) {
	printf(" > History Module ");
	setColor(LIGHTCYAN);
	printf("%s ", historyModule->getName().c_str());
	setColor(GREY);
	printf("(%03u) ", historyModule->getId());
	setColor(LIGHTGREEN);
	printf("mounted ");
	setColor(GREY);
	printf("in Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", agent->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", agent->getId());
	}

	void SetupOLD::printHistoryModuleCouldntGetMounted(Agent* agent, HistoryModule* historyModule) {
	setColor(LIGHTRED);
	printf(" > History Module %s (%03u) couldn't get mounted in Agent %s (%03u)\n", historyModule->getName().c_str(), historyModule->getId(), agent->getName().c_str(), agent->getId());
	setColor(GREY);
	}

	void SetupOLD::printSensorGotMounted(Agent* agent, Sensor* sensor) {
	printf(" > Sensor ");
	setColor(LIGHTCYAN);
	printf("%s ", sensor->getName().c_str());
	setColor(GREY);
	printf("(%03u) ", sensor->getId());
	setColor(LIGHTGREEN);
	printf("mounted ");
	setColor(GREY);
	printf("in Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", agent->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", agent->getId());
	}

	void SetupOLD::printSensorCouldntGetMounted(Agent* agent, Sensor* sensor) {
	setColor(LIGHTRED);
	printf(" > Agent %s (%03u) couldn't get mounted in Agent %s (%03u)\n", sensor->getName().c_str(), sensor->getId(), agent->getName().c_str(), agent->getId());
	setColor(GREY);
	}


	void SetupOLD::printStabilityModuleGotMounted(Agent* agent, StabilityModule* stabilityModule) {
	printf(" > Stability Module ");
	setColor(LIGHTCYAN);
	printf("%s ", stabilityModule->getName().c_str());
	setColor(GREY);
	printf("(%03u) ", stabilityModule->getId());
	setColor(LIGHTGREEN);
	printf("mounted ");
	setColor(GREY);
	printf("in Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", agent->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", agent->getId());
	}

	void SetupOLD::printStabilityModuleCouldntGetMounted(Agent* agent, StabilityModule* stabilityModule) {
	setColor(LIGHTRED);
	printf(" > Stability Module %s (%03u) couldn't get mounted in Agent %s (%03u)\n", stabilityModule->getName().c_str(), stabilityModule->getId(), agent->getName().c_str(), agent->getId());
	setColor(GREY);
	}


	void SetupOLD::printConnectionEstablished(Agent* hostAgent, HistoryModule* historyModule, Agent* slaveAgent) {
	printf(" > Inside of Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", hostAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u): ", hostAgent->getId());
	printf("History Module ");
	setColor(LIGHTCYAN);
	printf("%s ", historyModule->getName().c_str());
	setColor(GREY);
	printf("(%03u) is ", historyModule->getId());
	setColor(LIGHTGREEN);
	printf("connected ");
	setColor(GREY);
	printf("with Input of Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", slaveAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", slaveAgent->getId());
	}

	void SetupOLD::printConnectionEstablished(Agent* hostAgent, StabilityModule* stabilityModule, HistoryModule* historyModule, Agent* slaveAgent) {
	printf(" > Inside of Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", hostAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u): ", hostAgent->getId());
	printf("Stability Module ");
	setColor(LIGHTCYAN);
	printf("%s ", stabilityModule->getName().c_str());
	setColor(GREY);
	printf("(%03u) is ", stabilityModule->getId());
	setColor(LIGHTGREEN);
	printf("connected ");
	setColor(GREY);
	printf("with Input of Agent ");
	setColor(LIGHTCYAN);
	printf("%s ", slaveAgent->getName().c_str());
	setColor(GREY);
	printf("(%03u) and ", slaveAgent->getId());
	printf("with History Module ");
	setColor(LIGHTCYAN);
	printf("%s ", historyModule->getName().c_str());
	setColor(GREY);
	printf("(%03u)\n", historyModule->getId());
	}

	void SetupOLD::printConnectionIsImpossible() {
	setColor(LIGHTRED);
	printf(" > Process of Connecting is impossible\n");
	setColor(GREY);
	}



	void SetupOLD::mountAgentInAgent(Agent* masterAgent, Agent* slaveAgent, Channel* channel) {
	if (masterAgent && slaveAgent && channel) {
	//note: next line is because one slaveAgent can only be mounted once
	if (!agentIsRegistered(slaveAgent) \|\| !getRegisteredAgent(slaveAgent)->masterAgentIsSet()) {

	SetupAgent* setupSlaveAgent = NULL;

	if (agentIsRegistered(slaveAgent)) {
	setupSlaveAgent = getRegisteredAgent(slaveAgent);
	}
	else {
	setupSlaveAgent = registerAgent(slaveAgent);
	}

	SetupAgent* setupMasterAgent = NULL;

	if (agentIsRegistered(masterAgent)) {
	setupMasterAgent = getRegisteredAgent(masterAgent);
	}
	else {
	setupMasterAgent = registerAgent(masterAgent);
	}

	if (setupMasterAgent->mountAgent(slaveAgent, channel)) {
	if (setupSlaveAgent->setMasterAgent(masterAgent, channel)) {
	printAgentGotMounted(masterAgent, slaveAgent);
	}
	else {
	//TODO: unmount in real and in setup object
	}
	}
	}
	}
	}

	SetupAgent* SetupOLD::registerAgent(Agent* agent) {
	SetupAgent* setupAgent = new SetupAgent(agent);
	try {
	vSetupAgents.push_back(setupAgent);
	return setupAgent;
	}
	catch (bad_alloc& error) {
	delete setupAgent;
	}
	return NULL;
	}

	bool SetupOLD::agentIsRegistered(Agent* agent) {
	for (auto &registeredAgent : vSetupAgents)
	if (registeredAgent->getAgent() == agent)
	return true;
	return false;
	}

	SetupAgent* SetupOLD::getRegisteredAgent(Agent* agent) {
	for (auto &registeredAgent : vSetupAgents)
	if (registeredAgent->getAgent() == agent) {
	printf("DADRINN\n\n");
	return registeredAgent;
	}

	return NULL;
	}



	void SetupOLD::mountSensorInAgent(Agent* agent, Sensor* sensor, Channel* channel) {
	if (agent && sensor && channel) {
	//note: next line is because one sensor can only be mounted once
	if (!SensorIsRegistered(sensor)) {
	SetupSensor* setupSensor = registerSensor(sensor);
	SetupAgent* setupAgent = NULL;

	if (agentIsRegistered(agent)) {
	setupAgent = getRegisteredAgent(agent);
	}
	else {
	setupAgent = registerAgent(agent);
	}


	if (setupAgent->mountSensor(sensor, channel)) {
	if (setupSensor->setMasterAgent(agent, channel)) {
	printSensorGotMounted(agent, sensor);
	}
	else {
	//TODO: unmount in real and in setup object
	}
	}
	}
	}
	}

	SetupSensor* SetupOLD::registerSensor(Sensor* sensor) {
	SetupSensor* setupSensor = new SetupSensor(sensor);
	try {
	vSetupSensors.push_back(setupSensor);
	return setupSensor;
	}
	catch (bad_alloc& error) {
	delete setupSensor;
	}
	return NULL;
	}

	bool SetupOLD::SensorIsRegistered(Sensor* sensor) {
	for (auto &registeredSensor : vSetupSensors)
	if (registeredSensor->getSensor() == sensor)
	return true;
	return false;
	}

	SetupSensor* SetupOLD::getRegisteredSensor(Sensor* sensor) {
	for (auto &registeredSensor : vSetupSensors)
	if (registeredSensor->getSensor() == sensor)
	return registeredSensor;
	return NULL;
	}



	void SetupOLD::mountHistoryModuleInAgent(Agent* agent, HistoryModule* historyModule) {
	if (agent && historyModule) {
	//NOTE: next line is because a history module can only be mounted once
	if (!historyModuleIsRegistered(historyModule)) {
	SetupMountedHistoryModule* setupMountedHistoryModule = registerHistoryModule(historyModule);
	SetupAgent* setupAgent = NULL;

	if (agentIsRegistered(agent)) {
	setupAgent = getRegisteredAgent(agent);
	}
	else {
	setupAgent = registerAgent(agent);
	}

	if (setupAgent->mountHistoryModule(setupMountedHistoryModule)) {
	printHistoryModuleGotMounted(agent, historyModule);
	return;
	}
	}
	printHistoryModuleCouldntGetMounted(agent, historyModule);
	return;
	}
	printMountingProcessImpossible();
	}

	SetupMountedHistoryModule* SetupOLD::registerHistoryModule(HistoryModule* historyModule) {
	SetupMountedHistoryModule* setupMountedHistoryModule = new SetupMountedHistoryModule(historyModule);
	try {
	vSetupHistoryModules.push_back(setupMountedHistoryModule);
	return setupMountedHistoryModule;
	}
	catch (bad_alloc& error) {
	delete setupMountedHistoryModule;
	}
	return NULL;
	}

	bool SetupOLD::historyModuleIsRegistered(HistoryModule* historyModule) {
	for (auto &registeredHistoryModule : vSetupHistoryModules)
	if (registeredHistoryModule->getHistoryModule() == historyModule)
	return true;
	return false;
	}

	SetupMountedHistoryModule* SetupOLD::getRegisteredHistoryModule(HistoryModule* historyModule) {
	for (auto &registeredHistoryModule : vSetupHistoryModules)
	if (registeredHistoryModule->getHistoryModule() == historyModule)
	return registeredHistoryModule;
	return NULL;
	}


	//TODO: it is the same as the mountHistoryModule function -> template
	void SetupOLD::mountStabilityModules(Agent* agent, StabilityModule* stabilityModule) {
	if(agent && stabilityModule) {
	//NOTE: next line is because a history module can only be mounted once
	if (!stabilityModuleIsRegistered(stabilityModule)) {
	SetupStabilityModule* setupStabilityModule = registerStabilityModule(stabilityModule);
	SetupAgent* setupAgent = NULL;

	if (agentIsRegistered(agent)) {
	setupAgent = getRegisteredAgent(agent);
	}
	else {
	setupAgent = registerAgent(agent);
	}

	if (setupAgent->mountStabilityModule(setupStabilityModule)) {
	printStabilityModuleGotMounted(agent, stabilityModule);
	return;
	}
	}
	printStabilityModuleCouldntGetMounted(agent, stabilityModule);
	return;
	}
	printMountingProcessImpossible();
	}

	SetupStabilityModule* SetupOLD::registerStabilityModule(StabilityModule* stabilityModule) {
	SetupStabilityModule* setupStabilityModule = new SetupStabilityModule(stabilityModule);
	try {
	vSetupStabilityModules.push_back(setupStabilityModule);
	return setupStabilityModule;
	}
	catch (bad_alloc& error) {
	delete setupStabilityModule;
	}
	return NULL;
	}

	bool SetupOLD::stabilityModuleIsRegistered(StabilityModule* stabilityModule) {
	for (auto &registeredStabilityModule : vSetupStabilityModules)
	if (registeredStabilityModule->getStabilityModule() == stabilityModule)
	return true;
	return false;
	}

	SetupStabilityModule* SetupOLD::getRegisteredStabilityModule(StabilityModule* stabilityModule) {
	for (auto &registeredStabilityModule : vSetupStabilityModules)
	if (registeredStabilityModule->getStabilityModule() == stabilityModule)
	return registeredStabilityModule;
	return NULL;
	}



	void SetupOLD::connect(HistoryModule* historyModule, Agent* slaveAgent) {
	if (historyModule && slaveAgent) {
	if (historyModuleIsRegistered(historyModule) && agentIsRegistered(slaveAgent)) {

	SetupMountedHistoryModule* registeredHistoryModule = getRegisteredHistoryModule(historyModule);
	Agent* hostAgent = registeredHistoryModule->getHostAgent();

	printf("das is interessant\n");
	SetupAgent* mountedAgent = getRegisteredAgent(slaveAgent);

	if (hostAgent == mountedAgent->getMasterAgent()) {
	//next line connect for real
	if (historyModule->setObservationPointer(mountedAgent->getAgentSlot()->getObservationPointer())) {
	printConnectionEstablished(hostAgent, historyModule, slaveAgent);
	return;
	}
	}
	}
	}
	printConnectionIsImpossible();
	}

	void SetupOLD::connect(HistoryModule* historyModule, Sensor* sensor) {
	printConnectionIsImpossible();
	}

	void SetupOLD::connect(StabilityModule* stabilityModule, Agent* slaveAgent, HistoryModule* historyModule) {
	if (stabilityModule && slaveAgent && historyModule) {
	if (stabilityModuleIsRegistered(stabilityModule) && agentIsRegistered(slaveAgent) && historyModuleIsRegistered(historyModule)) {


	SetupStabilityModule* registeredStabilityModule = getRegisteredStabilityModule(stabilityModule);
	Agent* hostAgent = registeredStabilityModule->getHostAgent();
	SetupMountedHistoryModule* registeredHistoryModule = getRegisteredHistoryModule(historyModule);
	SetupAgent* mountedAgent = getRegisteredAgent(slaveAgent);
	if (hostAgent == registeredHistoryModule->getHostAgent() && hostAgent == mountedAgent->getMasterAgent()) {
	//next line connect for real
	if (stabilityModule->setObservationPointer(mountedAgent->getAgentSlot()->getObservationPointer(), historyModule->getObservationPointer())) {
	printConnectionEstablished(hostAgent, stabilityModule, historyModule, slaveAgent);
	return;
	}
	}
	}
	}
	printConnectionIsImpossible();
	}

File Metadata

Mime Type: text/x-c
Expires: Sun, Mar 1, 10:18 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 287691
Default Alt Text: SetupOLD.cpp (12 KB)

SetupOLD.cppNo OneTemporaryActions

SetupOLD.cppView Options

File Metadata

Event Timeline

SetupOLD.cpp
No OneTemporary
Actions

SetupOLD.cpp
View Options