SlaveAgentHandlerOfAgent.cpp
No OneTemporary
Actions

Size

7 KB

Referenced Files

None

Subscribers

None

SlaveAgentHandlerOfAgent.cpp
View Options

	#include "SlaveAgentHandlerOfAgent.h"

	#include "instruction_set_architecture.h"
	#include <stdio.h>
	#include "printError.h"


	#include <algorithm>

	#define MAXNUMOF_MOUNTEDSENSORS 100

	using namespace std;

	SlaveAgentHandlerOfAgent :: SlaveAgentHandlerOfAgent() {
	initSlaveAgentHandler();
	}

	void SlaveAgentHandlerOfAgent :: initSlaveAgentHandler() {
	maxNumOfMountedSlaveAgents = MAXNUMOF_MOUNTEDSENSORS;
	}

	bool SlaveAgentHandlerOfAgent :: mount_slaveAgentIntoSlaveAgentSlot(Channel* inputPort) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = new SlaveAgentSlotOfAgent();
	if(slaveAgentSlotOfAgent != NULL) {
	if(slaveAgentSlotOfAgent->set_comPort(inputPort)) {
	if(vMountedSlaveAgents.size() < maxNumOfMountedSlaveAgents) {
	try {
	vMountedSlaveAgents.push_back(slaveAgentSlotOfAgent);
	}
	catch(bad_alloc& error) {
	printError("bad_alloc caught: ", error.what());
	delete slaveAgentSlotOfAgent;
	return false;
	}
	}
	else {
	printError("Max number of mounted slaveAgents is already reached!");
	delete slaveAgentSlotOfAgent;
	return false;
	}
	return true;
	}
	else {
	printError("Input port is no set!");
	vMountedSlaveAgents.pop_back(); //TODO: check if it is right?!?!
	delete slaveAgentSlotOfAgent;
	return false;
	}
	}
	else {
	printError("Couldn't create SlaveAgentSlot!");
	return false;
	}
	}

	//TODO: what to do when 2 slaveAgentSlots have the same inputPort??!!
	SlaveAgentSlotOfAgent* SlaveAgentHandlerOfAgent :: get_slaveAgentSlotAddress(Channel* inputPort) {
	for(auto &slaveAgentSlot : vMountedSlaveAgents) {
	if(slaveAgentSlot->get_comPort() == inputPort) {
	return slaveAgentSlot;
	}
	}
	return NULL;
	}

	//TODO: what to do when 2 slaveAgentSlots have the same inputPort??!!
	//TODO: case if slot with comPort is not in this vector
	unsigned int SlaveAgentHandlerOfAgent :: get_slaveAgentSlotNumber(Channel* inputPort) {
	unsigned int slotNumber = 0;
	for(auto &slaveAgentSlot : vMountedSlaveAgents) {
	if(slaveAgentSlot->get_comPort() == inputPort) {
	return slotNumber;
	}
	slotNumber++;
	}
	return NULL;
	}

	//TODO: what to do when 2 slaveAgentSlots have the same historyModule??!!
	SlaveAgentSlotOfAgent* SlaveAgentHandlerOfAgent :: get_slaveAgentSlotAddress(HistoryModule* historyModule) {
	for(auto &slaveAgentSlot : vMountedSlaveAgents) {
	if(slaveAgentSlot->get_historyModule() == historyModule) {
	return slaveAgentSlot;
	}
	}
	return NULL;
	}

	//TODO: what to do when 2 slaveAgentSlots have the same confidenceModule??!!
	SlaveAgentSlotOfAgent* SlaveAgentHandlerOfAgent :: get_slaveAgentSlotAddress(ConfidenceModule* confidenceModule) {
	for(auto &slaveAgentSlot : vMountedSlaveAgents) {
	if(slaveAgentSlot->get_confidenceModule() == confidenceModule) {
	return slaveAgentSlot;
	}
	}
	return NULL;
	}

	bool SlaveAgentHandlerOfAgent :: demount_slaveAgentIntoSlaveAgentSlot(Channel* inputPort) {
	vMountedSlaveAgents.erase(vMountedSlaveAgents.begin() + get_slaveAgentSlotNumber(inputPort));
	return false;
	}

	//TODO: do it also for integer variables
	bool SlaveAgentHandlerOfAgent :: read_slaveAgentValue(SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent) {
	if(slaveAgentSlotOfAgent != NULL) {
	Channel* channel = slaveAgentSlotOfAgent->get_comPort();
	if(channel != NULL) {
	int msg;
	if(channel->get_MsgUp(&msg)) {
	if(msg == ISA_SensoryData) {
	//printf("got msg: \n");
	float inputValue;
	if(channel->get_MsgUp(&inputValue)) {
	slaveAgentSlotOfAgent->setSlaveAgentValue(inputValue);
	//printf("got value: %f\n", inputValue);
	return true;
	}
	}
	}
	}
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent :: read_allSlaveAgentValues() {
	bool flag_readSlaveAgent = true;
	for(auto &slaveAgentSlot : vMountedSlaveAgents) {
	if(!read_slaveAgentValue(slaveAgentSlot)) {
	flag_readSlaveAgent = false;
	}
	}

	printf("\n");

	return flag_readSlaveAgent;
	}

	bool SlaveAgentHandlerOfAgent :: attach_historyModule(Channel* inputPort, HistoryModule* historyModule) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	if(slaveAgentSlotOfAgent != NULL) {
	return slaveAgentSlotOfAgent->set_historyModule(historyModule);
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent :: detach_historyModule(SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent) {
	if(slaveAgentSlotOfAgent != NULL) {
	return slaveAgentSlotOfAgent->del_historyModule();
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent :: detach_historyModule(Channel* inputPort) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	return detach_historyModule(slaveAgentSlotOfAgent);
	}

	bool SlaveAgentHandlerOfAgent :: detach_historyModule(HistoryModule* historyModule) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(historyModule);
	return detach_historyModule(slaveAgentSlotOfAgent);
	}

	HistoryModule* SlaveAgentHandlerOfAgent :: get_historyModuleOfSlaveAgentSlot(Channel* inputPort) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	return slaveAgentSlotOfAgent->get_historyModule();
	}

	bool SlaveAgentHandlerOfAgent :: attach_confidenceModule(Channel* inputPort, ConfidenceModule* confidenceModule) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	if(slaveAgentSlotOfAgent != NULL) {
	return slaveAgentSlotOfAgent->set_confidenceModule(confidenceModule);
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent :: detach_confidenceModule(SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent) {
	if(slaveAgentSlotOfAgent != NULL) {
	return slaveAgentSlotOfAgent->del_confidenceModule();
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent :: detach_confidenceModule(Channel* inputPort) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	return detach_confidenceModule(slaveAgentSlotOfAgent);
	}

	bool SlaveAgentHandlerOfAgent :: detach_confidenceModule(ConfidenceModule* confidenceModule) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(confidenceModule);
	return detach_confidenceModule(slaveAgentSlotOfAgent);
	}

	ConfidenceModule* SlaveAgentHandlerOfAgent :: get_confidenceModuleOfSlaveAgentSlot(Channel* inputPort) {
	SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent = get_slaveAgentSlotAddress(inputPort);
	return slaveAgentSlotOfAgent->get_confidenceModule();
	}

	vector<SlaveAgentSlotOfAgent> SlaveAgentHandlerOfAgent :: get_vMountedSlaveAgents() {
	return &vMountedSlaveAgents;
	}

	bool SlaveAgentHandlerOfAgent::saveValueInHistory(SlaveAgentSlotOfAgent* slaveAgentSlotOfAgent) {
	if (slaveAgentSlotOfAgent != NULL) {
	//TODO: change this hardcoded value //Zeitfenster Sliding Window!!!!
	while (slaveAgentSlotOfAgent->getHistoryLength() >= 10) {
	slaveAgentSlotOfAgent->deleteOldestHistoryEntry();
	}

	//JUST FOR TESTING
	//slaveAgentSlotOfAgent->printHistory();

	return slaveAgentSlotOfAgent->saveValueInHistory();
	}
	return false;
	}

	bool SlaveAgentHandlerOfAgent::saveAllValuesInHistory() {
	bool flagSavingSuccesful = true;
	for (auto &slaveAgentSlot : vMountedSlaveAgents) {
	if (!saveValueInHistory(slaveAgentSlot)) {
	flagSavingSuccesful = false;
	}
	}
	return flagSavingSuccesful;
	}

File Metadata

Mime Type: text/x-c++
Expires: Sat, Aug 29, 5:22 PM (7 h, 23 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 374614
Default Alt Text: SlaveAgentHandlerOfAgent.cpp (7 KB)

SlaveAgentHandlerOfAgent.cppNo OneTemporaryActions

SlaveAgentHandlerOfAgent.cppView Options

File Metadata

Event Timeline

SlaveAgentHandlerOfAgent.cpp
No OneTemporary
Actions

SlaveAgentHandlerOfAgent.cpp
View Options