fsfw/pus/newSchedulingImplementation/ScheduleTable.cpp

#include "ScheduleTable.h"


/*ctor
 * max_Commands: maximum number of commands in schedule
 * max_Subschedules: maximum number of subschedules
 */


ScheduleTable::ScheduleTable(object_id_t objectid, uint8_t max_Commands, uint8_t max_Subschedules):SystemObject(objectid)
					,schedule(max_Commands)/*TBD*/,statusMap(max_Subschedules){

}

ScheduleTable::~ScheduleTable(){


}

ReturnValue_t ScheduleTable::setStatus(bool state){

	for (statusIterator=statusMap.begin();statusIterator!=statusMap.end(); statusIterator++){

		statusIterator->second.status=State;
	}
			return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t ScheduleTable::setStatusInMap(bool state,subscheduleId_t subscheduleId){

	ReturnValue_t result = statusMap.exists(subscheduleId);

	if (result!= HasReturnvaluesIF::RETURN_OK){
		return result;
	}

	statusIterator = statusMap.find(subschduleId);
	statusIterator->second.status=state;
	return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t ScheduleTable::addCommandEntry(timeval TcTime,store_address_t TcAddress,subscheduleId_t SubscheduleId){

		commandInfo newCommandInfo = {TcAddress, SubscheduleId};
		result = schedule.insert(TcTime,newCommandInfo);
		if (result != HasRetrnvaluesIF::RETURN_OK){
			return result;
		}
		statusIterator = statusMap.find(subscheduleId);
		//would above return null?
		statusIterator->second.tcCount ++;


		return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t ScheduleTable:: addSubschedule(subscheduleId_t subscheduleId){
			// default status is false
			return statusMap.insert(subscheduleId,{false,0});
}

ReturnValue_t ScheduleTable:: shiftMap(timeval timeOffset){
			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
			schedule.clear();
			scheduleIterator = schedule.begin();
			for (scheduleIterator=schedule.begin();scheduleIterator!=schedule.end(); scheduleIterator++){
				result = shiftCommand(scheduleIterator, timeOffset);
				if (result != HasReturnvaluesIF::RETURN_OK){
					return result;
				}
			}

			return HasReturnvaluesIF::RETURN_OK;
}


ReturnValue_t ScheduleTable::shiftInMap(timeval timeOffset, subscheduleId_t subscheduleId){
	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
	scheduleIterator = schedule.begin();
	for (scheduleIterator=schedule.begin();scheduleIterator!=schedule.end(); schdeuleIterator++){

		if ((scheduleIterator->second.subschedule)==subscheduleId){
			result = shiftCommand(scheduleIterator, timeOffset);
			if (result !=HasReturnvaluesIF::RETURN_OK){
				return result;
			}
		}else{
			continue;
		}
	}

	return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t ScheduleTable::shiftCommand(OnboardSchedule_map::iterator it, timeval time_delta){

		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
		timeval tctime;
		//TODO check syntax
		timeradd(it.first, &time_delta , &tctime);
		commandInfo copyCommand= it->second;
		result = schedule.erase(it);
		if (result != HasReturnvaluesIF::RETURN_OK){
			return result;
		}
		// expect no errors, as we already used the iterator
		result =schedule.insert(tctime, copyCommand);
		//should not happen really.
		return result;
}


timeval ScheduleTable::findStart(subscheduleId_t subscheduleId){

	scheduleIterator = schedule.begin();
	timeval startTime= (*scheduleIterator).first;
	if (subscheduleId == 0){
		return startTime;
	}

	timeval checkTime;
	for (scheduleIterator = schedule.begin(); scheduleIterator!=schedule.end();scheduleIterator++){
		if ((scheduleIterator->second.subschedule)==subscheduleId){
			checkTime= scheduleIterator->first;
			if (checkTime < startTime){
				startTime=checkTime;
			}
		}else{
			continue;
		}
		return startTime;
	}
}

bool ScheduleTable::isNew(subscheduleId_t subscheduleId){
	bool newId = true;
	ReturnValue_t result = statusMap.exists(SubscheduleId);

	if (result != HasReturnvaluesIF::RETURN_OK){
		 NewId= true;
	}
	else {
		NewId= false;
	}

	return NewId;
}

void scheduleTable::goToStart(){
	scheduleIterator = schedule.begin();
}

void scheduleTable::getNextTc(timeval OnboardTime, stor_address_t *address){
	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
	commandReached = false;
	timeval time;
	while ( !commandReached){

		subscheduleId_t subscheduleId = scheduleIterator->second.subschedule;
		statusItertaor = statusMap.find (subscheduleId);
		if (statusIterator-> second.status != true){
			schdeuleIterator++;
			continue;
		}

		time = scheduleIterator.first;
		if (OnboardTime > time){
			address = scheduleIterator-> second.commandAddress;
			commandReached = true;
			//do sth with result??
			result = schedule.erase(&scheduleIterator);
			scheduleIterator++;
			statusIterator->second.tccount --;
			if (statusIterator-> second.tccount ==0){
				result = status.erase(&statusIterator);
				//for now I do nothing with the fail here

				}
			}

		}
}


void scheduleTable::clearScheduleMap(){
	schedule.clear();
	statusMap.clear();
}




/*

void scheduleTable::printAll(uint8_t* pointer, uint32_t maxSize) {

	uint32_t size = 0;
	uint16_t count = scheduleMap.scheduleSize();//should iterate and add all subschedule sizes
		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
				&pointer, &size, maxSize, true);

	for (scheduleIterator = schedule.begin(), scheduleIterator != schedule.end() && result == HasReturnvaluesIF::RETURN_OK;
			++iter) {
		for (subscheduleIterator = (scheduleIterator->second).begin();
									subscheduleIterator != (scheduleIterator->second).end()&& result == HasReturnvaluesIF::RETURN_OK;
									subscheduleIterator++ ){
		result = SerializeAdapter<subscheduleId_t>::serialize(&scheduleIterator->first,
				&pointer, &size, maxSize, true);
		uint8_t health = iter->second;
		result = SerializeAdapter<uint8_t>::serialize(&, &pointer, &size,
				maxSize, true);
	}

}

scheduleSize()

//how much the size should be?
uint16_t count = 0;
*/
*/