Agent.cpp
No OneTemporary
Actions

Size

28 KB

Referenced Files

None

Subscribers

None

Agent.cpp
View Options

This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.

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

	//TODO: Move this include to ControlModule
	#include "instruction_set_architecture.h"

	/*
	#include "Evaluation.h"
	#include "instruction_set_architecture.h"
	*/

	#define PRINT_READING

	void Agent :: init_agent() {
	sensorHandlerOfAgent = NULL;
	slaveAgentHandlerOfAgent = NULL;
	masterAgentHandlerOfAgent = NULL;
	}

	Agent :: Agent() {
	set_name(NO_NAME);
	init_agent();
	}

	Agent :: Agent(char* name) {
	set_name(name);
	init_agent();

	}

	bool Agent :: set_sensorHandlerOfAgent() {
	sensorHandlerOfAgent = new SensorHandlerOfAgent();

	if(sensorHandlerOfAgent == NULL) {
	printError("Couldn't create Sensor Handler!");
	return false;
	}
	return true;
	}

	bool Agent :: del_sensorHandlerOfAgent() {
	if(sensorHandlerOfAgent != NULL) {
	//TODO: Unmount/delete all sensorSlots with everything inside (history module, confidence module, ...)
	delete sensorHandlerOfAgent;
	return true;
	}
	return false;
	}

	SensorHandlerOfAgent* Agent :: get_sensorHandlerOfAgent() {
	if(sensorHandlerOfAgent == NULL) {
	set_sensorHandlerOfAgent();
	}
	return sensorHandlerOfAgent;
	}

	bool Agent :: set_slaveAgentHandlerOfAgent() {
	slaveAgentHandlerOfAgent = new SlaveAgentHandlerOfAgent();

	if(slaveAgentHandlerOfAgent == NULL) {
	printError("Couldn't create Slave Agent Handler!");
	return false;
	}
	return true;
	}

	bool Agent :: del_slaveAgentHandlerOfAgent() {
	if(slaveAgentHandlerOfAgent != NULL) {
	//TODO: Unmount/delete all SlaveAgentSlots with everything inside (history module, confidence module, ...)
	delete slaveAgentHandlerOfAgent;
	return true;
	}
	return false;
	}

	SlaveAgentHandlerOfAgent* Agent :: get_slaveAgentHandlerOfAgent() {
	if(slaveAgentHandlerOfAgent == NULL) {
	set_slaveAgentHandlerOfAgent();
	}
	return slaveAgentHandlerOfAgent;
	}

	bool Agent :: set_masterAgentHandlerOfAgent() {
	masterAgentHandlerOfAgent = new MasterAgentHandlerOfAgent();

	if(masterAgentHandlerOfAgent == NULL) {
	printError("Couldn't create Master Agent Handler!");
	return false;
	}
	return true;
	}

	bool Agent :: del_masterAgentHandlerOfAgent() {
	if(masterAgentHandlerOfAgent != NULL) {
	//TODO: Unmount/delete (all) MasterAgentSlot(s) with everything inside
	delete masterAgentHandlerOfAgent;
	return true;
	}
	return false;
	}

	MasterAgentHandlerOfAgent* Agent :: get_masterAgentHandlerOfAgent() {
	if(masterAgentHandlerOfAgent == NULL) {
	set_masterAgentHandlerOfAgent();
	}
	return masterAgentHandlerOfAgent;
	}

	void Agent :: trigger() {

	//TODO: make control_module to set the method of operating for each agent individual

	//Job: Read all sensory data
	if(sensorHandlerOfAgent != NULL) {
	printf("%s->sensorHandler: ", name);
	sensorHandlerOfAgent->read_allSensorValues();
	}

	//Job: Read all slave agent data
	if(slaveAgentHandlerOfAgent != NULL) {
	printf("%s->slaveAgentHandler: ", name);
	slaveAgentHandlerOfAgent->read_allSlaveAgentValues();
	}

	//Job: Just pass the Sensory Data (without abstraction) to master
	if(masterAgentHandlerOfAgent != NULL) {
	if(sensorHandlerOfAgent != NULL) {
	vector<SensorSlotOfAgent> vSensoryData = sensorHandlerOfAgent->get_vMountedSensors();
	for(auto &sensorSlot : *vSensoryData) {
	//TODO: also for int
	float sensorValue;
	if(sensorSlot->get_sensorValue(&sensorValue)) {
	masterAgentHandlerOfAgent->pass_msgToSendBuffer(ISA_SensoryData);
	masterAgentHandlerOfAgent->pass_msgToSendBuffer(sensorValue);
	}
	}
	}
	masterAgentHandlerOfAgent->send_msgs();
	}







	/*
	read_all_mountedSensors();

	validate_confidence_of_all_mountedSensors();

	//TODO: save only when confident or save everytime? ...maybe safe confidence as meta data.
	save_all_mountedSensor_histories();

	read_all_slaveAgents();
	*/























	/* OLD
	//has to be done in an extra loop because every slave agent values are needed
	for(unsigned int sa_ix = 0; sa_ix<num_of_mounted_slaveagents; sa_ix++) {

	if(flag_ccv_module_exist[sa_ix]) {
	//flag_slaveagent_value_confident[sa_ix] = list_of_ccv_modules[sa_ix]->cross_validate(num_of_mounted_slaveagents, slaveagent_value, &flag_slaveagent_value_confident[0]);
	}
	}


	//bunch //TODO: auch für integer (slaveagents)
	if(flag_bunch_module_exist) {
	bunch_score_confidency = bunch_module->bunch(num_of_mounted_slaveagents, &slaveagent_value[0], &flag_slaveagent_value_confident[0], &bunched_score);
	//printf("flag_bunched_score_exist setzten - ");
	if(bunch_score_confidency > 0) {
	flag_bunched_score_exist = true;
	//printf("true\n");
	}
	else {
	flag_bunched_score_exist = false;
	//printf("false\n");
	}
	}






	//abstract data //TODO: auch für integer (slaveagents)
	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {
	if(flag_sensor_value_set[s_ix]) {
	if(flag_abstraction_exist[s_ix]) {
	if(list_of_abstractions[s_ix]->abstract(sensor_value[s_ix], &abstracted_sensor_score[s_ix])) {
	flag_abstracted_sensor_score_exist[s_ix] = true;
	}
	else {
	flag_abstracted_sensor_score_exist[s_ix] = false;
	}
	}
	}
	}

	//sending data / do specific task
	if(flag_masteragent_outputport_is_active) {
	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {

	if(flag_abstracted_sensor_score_exist[s_ix]) {


	if(flag_confidence_validator_exist[s_ix]) {
	if(flag_sensor_value_confident[s_ix]) {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID);
	}
	else {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_INVALID);
	}
	}
	else {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID);
	}



	//if(flag_sensor_value_confident \|\| flag_confidence_validator_exist == false) {
	// mounted_masteragent_outputport->set_msg((int)IS_SCORE_VALID);
	//}
	//else {
	// mounted_masteragent_outputport->set_msg((int)IS_SCORE_INVALID);
	//}

	mounted_masteragent_outputport->set_msg(abstracted_sensor_score[s_ix]);
	}
	}
	}
	*/
	}



	/*
	void Agent :: initialize_master_slot() {
	//TODO: also mast_is_active needed?
	flag_masteragent_is_mounted = UNMOUNTED;
	flag_masteragent_inputport_is_active = INACTIVE;
	flag_masteragent_outputport_is_active = INACTIVE;
	}

	void Agent :: initialize_slaveagent_slots() {
	num_of_mounted_slaveagents = 0;
	//number_of_active_mounted_subagents = 0; //TODO: do i need it??
	for(unsigned int sa_ix=0; sa_ix<MAX_NUM_OF_MOUNTED_SLAVEAGENTS; sa_ix++) {
	flag_slaveagent_is_mounted[sa_ix] = UNMOUNTED;
	flag_slaveagent_has_dedicated_position[sa_ix] = NO;
	flag_slaveagent_inputport_is_active[sa_ix] = INACTIVE;
	flag_slaveagent_outputport_is_active[sa_ix] = INACTIVE;

	//Slaveagent value
	flag_slaveagent_value_set[sa_ix] = false;
	flag_slaveagent_value_changed[sa_ix] = false;

	flag_slaveagent_value_confident[sa_ix] = false;

	flag_ccv_module_exist[sa_ix] = false;
	}
	}

	void Agent :: initialize_sensor_slots() {
	num_of_mounted_sensors = 0;
	//number_of_active_mounted_sensors = 0;
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	//sensors
	flag_sensor_is_mounted[s_ix] = UNMOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = INACTIVE;
	flag_sensor_inputport_is_active[s_ix] = INACTIVE;

	//Sensor value
	flag_sensor_value_set[s_ix] = false;
	flag_sensor_value_changed[s_ix] = false;

	//Sensor History
	flag_sensor_history_exist[s_ix] = false;

	//confedence
	flag_confidence_validator_exist[s_ix] = false;
	flag_sensor_value_confident[s_ix] = false;

	//abstraction
	flag_abstraction_exist[s_ix] = false;
	flag_abstracted_sensor_score_exist[s_ix] = false;
	}
	}

	void Agent :: initialize_bunch_module() {
	flag_bunch_module_exist = false;
	flag_bunched_score_exist = false;
	bunch_score_confidency = 0;
	}

	void Agent :: initialize_working_frequency(int* success_indicator) {
	if(set_working_frequency(working_frequency)) {
	*success_indicator = 0;
	}
	else {
	*success_indicator = 1;
	}
	}

	// ----- Standard Attributes -----
	Agent :: Agent() {
	set_name(NO_NAME);
	initialize_master_slot();
	initialize_slaveagent_slots();
	initialize_sensor_slots();
	initialize_bunch_module();
	}

	Agent :: Agent(char* name) {
	set_name(name);
	initialize_master_slot();
	initialize_slaveagent_slots();
	initialize_sensor_slots();
	initialize_bunch_module();
	}

	Agent :: Agent(unsigned int working_frequency, int* success_indicator) {
	set_name(NO_NAME);
	initialize_master_slot();
	initialize_slaveagent_slots();
	initialize_sensor_slots();
	initialize_bunch_module();
	initialize_working_frequency(success_indicator);
	}

	Agent :: Agent(char* name, unsigned int working_frequency, int* success_indicator) {
	set_name(name);
	initialize_master_slot();
	initialize_slaveagent_slots();
	initialize_sensor_slots();
	initialize_bunch_module();
	initialize_working_frequency(success_indicator);
	}

	bool Agent :: set_working_frequency(unsigned int working_frequency) {
	if(working_frequency <= MAX_WORK_FREQU) {
	this->working_frequency = working_frequency;
	return true;
	}
	this->working_frequency = 0;
	return false;
	}


	bool Agent :: read_mountedSensor(unsigned int s_ix) {

	bool flag_got_new_sensor_value;
	float temp_sensor_value;

	flag_got_new_sensor_value = mounted_sensor_inputport[s_ix]->get_msg_float(&temp_sensor_value);

	if(flag_got_new_sensor_value) {

	if(!flag_sensor_value_set[s_ix]) {
	flag_sensor_value_set[s_ix] = true;
	flag_sensor_value_changed[s_ix] = true;
	sensor_value[s_ix] = temp_sensor_value;
	}
	else {
	if(sensor_value[s_ix] == temp_sensor_value) {
	flag_sensor_value_changed[s_ix] = false;
	}
	else {
	flag_sensor_value_changed[s_ix] = true;
	sensor_value[s_ix] = temp_sensor_value;
	}
	}
	}
	else {
	flag_sensor_value_changed[s_ix] = false;
	}

	return flag_got_new_sensor_value;
	}


	void Agent :: read_all_mountedSensors() {

	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {
	read_mountedSensor(s_ix);
	printf("Agent %s got value: %f\n", name, sensor_value[s_ix]);
	}
	}

	bool Agent :: save_mountedSensor_history(unsigned int s_ix) {

	bool flag_data_saved = false;

	if(flag_sensor_value_set[s_ix] && flag_sensor_history_exist[s_ix]) {
	flag_data_saved = sensor_history[s_ix]->drop_data(sensor_value[s_ix]);
	}

	return flag_data_saved;
	}

	void Agent :: save_all_mountedSensor_histories() {

	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {
	save_mountedSensor_history(s_ix);

	//Next lines are only for print
	float temp_value;
	if(flag_sensor_history_exist[s_ix]) {
	if(sensor_history[s_ix]->get_latest_value(&temp_value))
	printf("History %s got value: %f\n", name, temp_value);
	else
	printf("History %s got no value.\n", name);
	}
	else {
	printf("History doesn't exist.\n");
	}
	}
	}

	//TODO: this function is untested - test it!
	bool Agent :: validate_confidence_of_mountedSensor(unsigned int s_ix) {

	if(flag_sensor_value_set[s_ix]) {

	if(flag_confidence_validator_exist[s_ix]) {
	//TODO: modify validate_confidence function in a way that there is parameter that says if actual sensor_value[s_ix] is already in history or not!
	flag_sensor_value_confident[s_ix] = list_of_confidence_validators[s_ix]->validate_confidence(sensor_value[s_ix], sensor_history[s_ix]);
	}
	else {
	//I have to believe it if I don't know
	flag_sensor_value_confident[s_ix] = true;
	}
	}

	return flag_sensor_value_confident[s_ix];
	}

	void Agent :: validate_confidence_of_all_mountedSensors() {
	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {
	validate_confidence_of_mountedSensor(s_ix);
	}
	}

	//TODO: test / modify!
	bool Agent :: read_slaveAgent(unsigned int sa_ix) {
	//TODO: instructions in own line (unsigned int) ?!
	//TODO: Class/Object Control Unit (with included instruction set)
	int instruction = ISA_NO_INSTRUCTION;
	int data = 0; //TODO: better value

	while(mounted_slaveagent_inputport[sa_ix]->is_there_a_msg_for_me_int()) {

	instruction = mounted_slaveagent_inputport[sa_ix]->get_msg_int(); //TODO: hier (vllt) auch die möglichkeit float (score) einzulesen!!

	if(instruction == ISA_SCORE_VALID \|\| instruction == ISA_SCORE_INVALID) {

	bool got_msg = mounted_slaveagent_inputport[sa_ix]->is_there_a_msg_for_me_int();

	if(got_msg) {
	data = mounted_slaveagent_inputport[sa_ix]->get_msg_int();

	if(slaveagent_value[sa_ix] != data) {
	flag_slaveagent_value_changed[sa_ix] = true;
	}
	slaveagent_value[sa_ix] = data;
	flag_slaveagent_value_set[sa_ix] = true;

	if(instruction == ISA_SCORE_VALID) {
	//if(id == 0)
	// printf("setze valid\n");
	flag_slaveagent_value_confident[sa_ix] = true;
	}
	else {
	//if(id == 0)
	// printf("setze invalid\n");
	flag_slaveagent_value_confident[sa_ix] = false;
	}
	}
	else {
	flag_slaveagent_value_set[sa_ix] = false;
	}
	} else {
	flag_slaveagent_value_set[sa_ix] = false;
	}
	}

	//TODO: do i need a return value?
	return false;
	}

	void Agent :: read_all_slaveAgents() {
	for(unsigned int sa_ix = 0; sa_ix<num_of_mounted_slaveagents; sa_ix++) {
	read_slaveAgent(sa_ix);
	}
	}



	// ----- Runtime Functions -----
	void Agent :: trigger() {

	//NOTE: I made readig, confidence, etc. in own loops/functions... because it may happen that confidence range changes and the sensor value is still the same but then valid or not

	read_all_mountedSensors();

	validate_confidence_of_all_mountedSensors();

	//TODO: save only when confident or save everytime? ...maybe safe confidence as meta data.
	save_all_mountedSensor_histories();

	read_all_slaveAgents();
























	/* OLD
	//has to be done in an extra loop because every slave agent values are needed
	for(unsigned int sa_ix = 0; sa_ix<num_of_mounted_slaveagents; sa_ix++) {

	if(flag_ccv_module_exist[sa_ix]) {
	//flag_slaveagent_value_confident[sa_ix] = list_of_ccv_modules[sa_ix]->cross_validate(num_of_mounted_slaveagents, slaveagent_value, &flag_slaveagent_value_confident[0]);
	}
	}


	//bunch //TODO: auch für integer (slaveagents)
	if(flag_bunch_module_exist) {
	bunch_score_confidency = bunch_module->bunch(num_of_mounted_slaveagents, &slaveagent_value[0], &flag_slaveagent_value_confident[0], &bunched_score);
	//printf("flag_bunched_score_exist setzten - ");
	if(bunch_score_confidency > 0) {
	flag_bunched_score_exist = true;
	//printf("true\n");
	}
	else {
	flag_bunched_score_exist = false;
	//printf("false\n");
	}
	}






	//abstract data //TODO: auch für integer (slaveagents)
	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {
	if(flag_sensor_value_set[s_ix]) {
	if(flag_abstraction_exist[s_ix]) {
	if(list_of_abstractions[s_ix]->abstract(sensor_value[s_ix], &abstracted_sensor_score[s_ix])) {
	flag_abstracted_sensor_score_exist[s_ix] = true;
	}
	else {
	flag_abstracted_sensor_score_exist[s_ix] = false;
	}
	}
	}
	}

	//sending data / do specific task
	if(flag_masteragent_outputport_is_active) {
	for(unsigned int s_ix = 0; s_ix<num_of_mounted_sensors; s_ix++) {

	if(flag_abstracted_sensor_score_exist[s_ix]) {


	if(flag_confidence_validator_exist[s_ix]) {
	if(flag_sensor_value_confident[s_ix]) {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID);
	}
	else {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_INVALID);
	}
	}
	else {
	mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID);
	}



	//if(flag_sensor_value_confident \|\| flag_confidence_validator_exist == false) {
	// mounted_masteragent_outputport->set_msg((int)IS_SCORE_VALID);
	//}
	//else {
	// mounted_masteragent_outputport->set_msg((int)IS_SCORE_INVALID);
	//}

	mounted_masteragent_outputport->set_msg(abstracted_sensor_score[s_ix]);
	}
	}
	}
	*/
	/*}


	//TODO: prevent possibility to mount yourself as subagent!
	//TODO: prevent possibility to mount sensor as subagent!
	bool Agent :: mount_slaveagent(Channel* inputport, Channel* outputport) {
	if(num_of_mounted_slaveagents < MAX_NUM_OF_MOUNTED_SLAVEAGENTS && (inputport != NULL \|\| outputport != NULL)) {
	for(unsigned int sa_ix=0; sa_ix<MAX_NUM_OF_MOUNTED_SLAVEAGENTS; sa_ix++) {
	if(flag_slaveagent_is_mounted[sa_ix] == UNMOUNTED) {
	flag_slaveagent_is_mounted[sa_ix] = MOUNTED;
	flag_slaveagent_has_dedicated_position[sa_ix] = NO;
	if(inputport != NULL) {
	mounted_slaveagent_inputport[sa_ix] = inputport;
	flag_slaveagent_inputport_is_active[sa_ix] = ACTIVE;
	}
	else {
	flag_slaveagent_inputport_is_active[sa_ix] = INACTIVE;
	}
	if(outputport != NULL) {
	mounted_slaveagent_outputport[sa_ix] = outputport;
	flag_slaveagent_outputport_is_active[sa_ix] = ACTIVE;
	}
	else {
	flag_slaveagent_outputport_is_active[sa_ix] = INACTIVE;
	}
	num_of_mounted_slaveagents++;
	//abstraction.set_num_of_slaveagents(num_of_mounted_slaveagents);
	return true;
	}
	}
	}
	return false;
	}


	//TODO: prevent possibility to mount yourself as subagent!
	//TODO: prevent possibility to mount sensor as subagent!
	bool Agent :: mount_slaveagent(Channel* inputport, Channel* outputport, unsigned int position) {
	if(position < MAX_NUM_OF_MOUNTED_SLAVEAGENTS) {
	if(flag_slaveagent_has_dedicated_position[position] == NO && (inputport != NULL \|\| outputport != NULL)) {
	if(flag_slaveagent_is_mounted[position] == MOUNTED) {
	if(num_of_mounted_slaveagents < MAX_NUM_OF_MOUNTED_SLAVEAGENTS) {
	for(unsigned int sa_ix=0; sa_ix<MAX_NUM_OF_MOUNTED_SLAVEAGENTS; sa_ix++) {
	if(flag_slaveagent_is_mounted[sa_ix] == UNMOUNTED) {
	flag_slaveagent_is_mounted[sa_ix] = flag_slaveagent_is_mounted[position];
	flag_slaveagent_has_dedicated_position[sa_ix] = flag_slaveagent_has_dedicated_position[position];
	flag_slaveagent_inputport_is_active[sa_ix] = flag_slaveagent_inputport_is_active[position];
	if(flag_slaveagent_inputport_is_active[position])
	mounted_slaveagent_inputport[sa_ix] = mounted_slaveagent_inputport[position];
	flag_slaveagent_outputport_is_active[sa_ix] = flag_slaveagent_outputport_is_active[position];
	if(flag_slaveagent_outputport_is_active[position])
	mounted_slaveagent_outputport[sa_ix] = mounted_slaveagent_outputport[position];
	break;
	}
	}
	}
	else {
	return false;
	}
	}

	flag_slaveagent_is_mounted[position] = MOUNTED;
	flag_slaveagent_has_dedicated_position[position] = YES;

	if(inputport != NULL) {
	mounted_slaveagent_inputport[position] = inputport;
	flag_slaveagent_inputport_is_active[position] = ACTIVE;
	}
	else {
	flag_slaveagent_inputport_is_active[position] = INACTIVE;
	}
	if(outputport != NULL) {
	mounted_slaveagent_outputport[position] = outputport;
	flag_slaveagent_outputport_is_active[position] = ACTIVE;
	}
	else {
	flag_slaveagent_outputport_is_active[position] = INACTIVE;
	}
	num_of_mounted_slaveagents++;
	//abstraction.set_num_of_slaveagents(num_of_mounted_slaveagents);
	return true;
	}
	}
	return false;
	}

	//TODO: soetwas wie ccv != NULL auch bei anderen mounting sachen amchen.. mit Confidence, Abstraction usw
	bool Agent :: mount_slaveagent(Channel* inputport, Channel* outputport, Cross_Confidence_Validator* ccv) {
	if(num_of_mounted_slaveagents < MAX_NUM_OF_MOUNTED_SLAVEAGENTS && (inputport != NULL \|\| outputport != NULL) && ccv != NULL) {
	for(unsigned int sa_ix=0; sa_ix<MAX_NUM_OF_MOUNTED_SLAVEAGENTS; sa_ix++) {
	if(flag_slaveagent_is_mounted[sa_ix] == UNMOUNTED) {
	flag_slaveagent_is_mounted[sa_ix] = MOUNTED;
	flag_slaveagent_has_dedicated_position[sa_ix] = NO;
	if(inputport != NULL) {
	mounted_slaveagent_inputport[sa_ix] = inputport;
	flag_slaveagent_inputport_is_active[sa_ix] = ACTIVE;
	}
	else {
	flag_slaveagent_inputport_is_active[sa_ix] = INACTIVE;
	}
	if(outputport != NULL) {
	mounted_slaveagent_outputport[sa_ix] = outputport;
	flag_slaveagent_outputport_is_active[sa_ix] = ACTIVE;
	}
	else {
	flag_slaveagent_outputport_is_active[sa_ix] = INACTIVE;
	}

	list_of_ccv_modules[sa_ix] = ccv;
	flag_ccv_module_exist[sa_ix] = true;
	//TODO: Fehlerbehandlung
	list_of_ccv_modules[sa_ix]->set_proband(sa_ix);

	num_of_mounted_slaveagents++;
	return true;
	}
	}
	}
	return false;
	}



	//TODO: prevent possibility to mount yourself as subagent!
	//TODO: prevent possibility to mount subagent as sensor!
	bool Agent :: mount_masteragent(Channel* inputport, Channel* outputport) {
	if(inputport != NULL \|\| outputport != NULL) {

	if(inputport != NULL) {
	mounted_masteragent_inputport = inputport;
	flag_masteragent_inputport_is_active = ACTIVE;
	}
	else {
	flag_masteragent_inputport_is_active = INACTIVE;
	}

	if(outputport != NULL) {
	mounted_masteragent_outputport = outputport;
	flag_masteragent_outputport_is_active = ACTIVE;
	}
	else {
	flag_masteragent_outputport_is_active = INACTIVE;
	}

	return true;
	}
	return false;
	}


	bool Agent :: mount_sensor(Channel* inputport, unsigned int position) {
	if(position < MAX_NUM_OF_MOUNTED_SENSORS) {
	if(flag_sensor_has_dedicated_position[position] == NO && inputport != NULL) {
	if(flag_sensor_is_mounted[position] == MOUNTED) {
	if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS) {
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {
	flag_sensor_is_mounted[s_ix] = flag_sensor_is_mounted[position];
	flag_sensor_has_dedicated_position[s_ix] = flag_sensor_has_dedicated_position[position];
	mounted_sensor_inputport[s_ix] = mounted_sensor_inputport[position];
	flag_sensor_inputport_is_active[s_ix] = flag_sensor_inputport_is_active[position];
	}
	}
	}
	else {
	return false;
	}
	}
	flag_sensor_is_mounted[position] = MOUNTED;
	flag_sensor_has_dedicated_position[position] = YES;
	mounted_sensor_inputport[position] = inputport;
	flag_sensor_inputport_is_active[position] = ACTIVE;
	num_of_mounted_sensors++;
	//abstraction.set_num_of_sensors(num_of_mounted_sensors);
	return true;
	}
	}
	return false;
	}


	//TODO: prevent possibility to mount yourself as subagent!
	//TODO: prevent possibility to mount subagent as sensor!
	bool Agent :: mount_sensor(Channel* inputport) {
	if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS && inputport != NULL) {
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {
	flag_sensor_is_mounted[s_ix] = MOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = inputport;
	flag_sensor_inputport_is_active[s_ix] = ACTIVE;
	num_of_mounted_sensors++;
	//abstraction.set_num_of_sensors(num_of_mounted_sensors);
	return true;
	}
	}
	}
	return false;
	}

	bool Agent :: mount_sensor(Channel* inputport, Abstraction* abstraction) {
	if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS && inputport != NULL) {
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {
	flag_sensor_is_mounted[s_ix] = MOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = inputport;
	flag_sensor_inputport_is_active[s_ix] = ACTIVE;

	if(abstraction != NULL) {
	flag_abstraction_exist[s_ix] = true;
	list_of_abstractions[s_ix] = abstraction;
	}

	num_of_mounted_sensors++;

	return true;
	}
	}
	}
	return false;
	}

	bool Agent :: mount_sensor(Channel* inputport, Confidence_Validator* confidence_validator) {
	if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS && inputport != NULL) {
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {
	flag_sensor_is_mounted[s_ix] = MOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = inputport;
	flag_sensor_inputport_is_active[s_ix] = ACTIVE;

	if(confidence_validator != NULL) {
	flag_confidence_validator_exist[s_ix] = true;
	list_of_confidence_validators[s_ix] = confidence_validator;
	}

	num_of_mounted_sensors++;

	return true;
	}
	}
	}
	return false;
	}


	bool Agent :: mount_sensor(Channel* inputport, HistoryModule* historyModule) {

	/*
	sensor_history[MAX_NUM_OF_MOUNTED_SENSORS];
	flag_sensor_history_exist[MAX_NUM_OF_MOUNTED_SENSORS];
	*/

	/* if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS && inputport != NULL && historyModule != NULL) {

	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {

	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {

	flag_sensor_is_mounted[s_ix] = MOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = inputport;
	flag_sensor_inputport_is_active[s_ix] = ACTIVE;

	flag_sensor_history_exist[s_ix] = true;
	sensor_history[s_ix] = historyModule;

	num_of_mounted_sensors++;

	return true;
	}
	}
	}

	return false;
	}


	bool Agent :: mount_sensor(Channel* inputport, Confidence_Validator* confidence_validator, Abstraction* abstraction) {
	if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS && inputport != NULL) {
	for(unsigned int s_ix=0; s_ix<MAX_NUM_OF_MOUNTED_SENSORS; s_ix++) {
	if(flag_sensor_is_mounted[s_ix] == UNMOUNTED) {
	flag_sensor_is_mounted[s_ix] = MOUNTED;
	flag_sensor_has_dedicated_position[s_ix] = NO;
	mounted_sensor_inputport[s_ix] = inputport;
	flag_sensor_inputport_is_active[s_ix] = ACTIVE;

	if(confidence_validator != NULL) {
	flag_confidence_validator_exist[s_ix] = true;
	list_of_confidence_validators[s_ix] = confidence_validator;
	}

	if(abstraction != NULL) {
	flag_abstraction_exist[s_ix] = true;
	list_of_abstractions[s_ix] = abstraction;
	}

	num_of_mounted_sensors++;

	return true;
	}
	}
	}
	return false;
	}

	// ----- Bunch Module -----
	bool Agent :: mount_bunch_module(Bunch_Module* bunch_module){
	if(bunch_module != NULL) {
	this->bunch_module = bunch_module;
	this->flag_bunch_module_exist = true;
	return true;
	}
	return false;
	}


	bool Agent :: get_flag_abstracted_sensor_score_exist(unsigned int position) {
	return flag_abstracted_sensor_score_exist[position];
	}

	//TODO: rückgabewert, wenn kein vernünftiger wert
	int Agent :: get_abstracted_sensor_score(unsigned int position) {
	if(position < num_of_mounted_sensors && flag_abstracted_sensor_score_exist[position]) {
	return abstracted_sensor_score[position];
	}
	return -1;
	}

	bool Agent :: get_flag_bunched_score_exist() {
	return flag_bunched_score_exist;
	}

	int Agent :: get_bunched_score() {
	if(flag_bunched_score_exist) {
	return bunched_score;
	}
	return -1;
	}

	unsigned int Agent :: get_bunch_score_confidency() {
	return bunch_score_confidency;
	}






	void Agent :: test_print_all_slaveagents() {

	for(int i=0; i<MAX_NUM_OF_MOUNTED_SLAVEAGENTS; i++) {
	if(flag_slaveagent_is_mounted[i]) {
	if(flag_slaveagent_inputport_is_active[i]) {
	printf("%s has mounted %s on position %i\n", this->name, mounted_slaveagent_inputport[i]->get_name(), i);
	}
	if(flag_slaveagent_outputport_is_active[i]) {
	printf("%s has mounted %s on position %i\n", this->name, mounted_slaveagent_outputport[i]->get_name(), i);
	}
	}
	else {
	printf("%s has nothing mounted on position %i\n", this->name, i);
	}
	}
	getchar();
	}

	void Agent :: test_print_all_sensors() {

	for(int i=0; i<MAX_NUM_OF_MOUNTED_SENSORS; i++) {
	if(flag_sensor_is_mounted[i]) {
	if(flag_sensor_inputport_is_active[i]) {
	printf("%s has mounted %s on position %i\n", this->name, mounted_sensor_inputport[i]->get_name(), i);
	}
	}
	else {
	printf("%s has nothing mounted on position %i\n", this->name, i);
	}
	}
	getchar();
	}
	*/

File Metadata

Mime Type: text/x-c
Expires: Sun, Apr 12, 11:30 AM (4 h, 53 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 307486
Default Alt Text: Agent.cpp (28 KB)

Agent.cppNo OneTemporaryActions

Agent.cppView Options

File Metadata

Event Timeline

Agent.cpp
No OneTemporary
Actions

Agent.cpp
View Options