Representation.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
 
#include "Representation.h"
 
using namespace Swarm;


template<>
std::string phoenix_getTypeName<Data >(){
        return "Data";
}


bool CheckStream<Swarm::Data>::check_stream(const std::string & fieldDescription, const Swarm::Data & data, const Swarm::Data & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Data::name", data.getName(), reference.getName(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Data::description", data.getDescription(), reference.getDescription(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Data::type", data.getType(), reference.getType(), out);
        b &= CheckStream<DataStreamMsg>::check_stream(fieldDescription + "\n- Data::value", data.getValue(), reference.getValue(), out);
        return b;
}
 

Data::Data(){
        initialisationData();
}

Data::~Data(){
        
}


Data::Data(const Data & other){
        copyData(other);
}


Data & Data::operator = (const Data & other){
        copyData(other);
        return *this;
}


void Data::setName(const PString & name){
        p_name = name;
}


void Data::setDescription(const PString & description){
        p_description = description;
}


void Data::setType(const PString & type){
        p_type = type;
}


void Data::setValue(const DataStreamMsg & value){
        p_value = value;
}


const PString & Data::getName() const{
        return p_name;
}


PString & Data::getName(){
        return p_name;
}


const PString & Data::getDescription() const{
        return p_description;
}


PString & Data::getDescription(){
        return p_description;
}


const PString & Data::getType() const{
        return p_type;
}


PString & Data::getType(){
        return p_type;
}


const DataStreamMsg & Data::getValue() const{
        return p_value;
}


DataStreamMsg & Data::getValue(){
        return p_value;
}


void Data::copyData(const Data & other){
        p_name = other.p_name;
        p_description = other.p_description;
        p_type = other.p_type;
        p_value = other.p_value;
}

void Data::initialisationData(){
        p_name = "";
        p_description = "";
        p_type = "";
}


template<>
std::string phoenix_getTypeName<Function >(){
        return "Function";
}


bool CheckStream<Swarm::Function>::check_stream(const std::string & fieldDescription, const Swarm::Function & data, const Swarm::Function & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Function::name", data.getName(), reference.getName(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Function::description", data.getDescription(), reference.getDescription(), out);
        b &= CheckStream<std::vector<Swarm::Data>>::check_stream(fieldDescription + "\n- Function::vecParam", data.getVecParam(), reference.getVecParam(), out);
        b &= CheckStream<Swarm::Data>::check_stream(fieldDescription + "\n- Function::returnValue", data.getReturnValue(), reference.getReturnValue(), out);
        return b;
}
 

Function::Function(){
        initialisationFunction();
}

Function::~Function(){
        
}


Function::Function(const Function & other){
        copyFunction(other);
}


Function & Function::operator = (const Function & other){
        copyFunction(other);
        return *this;
}


void Function::setName(const PString & name){
        p_name = name;
}


void Function::setDescription(const PString & description){
        p_description = description;
}


void Function::setVecParam(const std::vector<Swarm::Data> & vecParam){
        p_vecParam = vecParam;
}


void Function::setReturnValue(const Swarm::Data & returnValue){
        p_returnValue = returnValue;
}


const PString & Function::getName() const{
        return p_name;
}


PString & Function::getName(){
        return p_name;
}


const PString & Function::getDescription() const{
        return p_description;
}


PString & Function::getDescription(){
        return p_description;
}


const std::vector<Swarm::Data> & Function::getVecParam() const{
        return p_vecParam;
}


std::vector<Swarm::Data> & Function::getVecParam(){
        return p_vecParam;
}


const Swarm::Data & Function::getReturnValue() const{
        return p_returnValue;
}


Swarm::Data & Function::getReturnValue(){
        return p_returnValue;
}


void Function::copyFunction(const Function & other){
        p_name = other.p_name;
        p_description = other.p_description;
        p_vecParam = other.p_vecParam;
        p_returnValue = other.p_returnValue;
}

void Function::initialisationFunction(){
        p_name = "";
        p_description = "";
}


template<>
std::string phoenix_getTypeName<Message >(){
        return "Message";
}


bool CheckStream<Swarm::Message>::check_stream(const std::string & fieldDescription, const Swarm::Message & data, const Swarm::Message & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<time_t>::check_stream(fieldDescription + "\n- Message::sendTime", data.getSendTime(), reference.getSendTime(), out);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- Message::id", data.getId(), reference.getId(), out);
        b &= CheckStream<bool>::check_stream(fieldDescription + "\n- Message::isConfirmationNeeded", data.getIsConfirmationNeeded(), reference.getIsConfirmationNeeded(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Message::sender", data.getSender(), reference.getSender(), out);
        b &= CheckStream<std::vector<PString>>::check_stream(fieldDescription + "\n- Message::vecRecver", data.getVecRecver(), reference.getVecRecver(), out);
        b &= CheckStream<MessageType::MessageType>::check_stream(fieldDescription + "\n- Message::type", data.getType(), reference.getType(), out);
        b &= CheckStream<Swarm::Data>::check_stream(fieldDescription + "\n- Message::data", data.getData(), reference.getData(), out);
        return b;
}
 

Message::Message(){
        initialisationMessage();
}

Message::~Message(){
        
}


Message::Message(const Message & other){
        copyMessage(other);
}


Message & Message::operator = (const Message & other){
        copyMessage(other);
        return *this;
}


void Message::setSendTime(const time_t & sendTime){
        p_sendTime = sendTime;
}


void Message::setId(size_t id){
        p_id = id;
}


void Message::setIsConfirmationNeeded(bool isConfirmationNeeded){
        p_isConfirmationNeeded = isConfirmationNeeded;
}


void Message::setSender(const PString & sender){
        p_sender = sender;
}


void Message::setVecRecver(const std::vector<PString> & vecRecver){
        p_vecRecver = vecRecver;
}


void Message::setType(const MessageType::MessageType & type){
        p_type = type;
}


void Message::setData(const Swarm::Data & data){
        p_data = data;
}


const time_t & Message::getSendTime() const{
        return p_sendTime;
}


time_t & Message::getSendTime(){
        return p_sendTime;
}


size_t Message::getId() const{
        return p_id;
}


size_t & Message::getId(){
        return p_id;
}


bool Message::getIsConfirmationNeeded() const{
        return p_isConfirmationNeeded;
}


bool & Message::getIsConfirmationNeeded(){
        return p_isConfirmationNeeded;
}


const PString & Message::getSender() const{
        return p_sender;
}


PString & Message::getSender(){
        return p_sender;
}


const std::vector<PString> & Message::getVecRecver() const{
        return p_vecRecver;
}


std::vector<PString> & Message::getVecRecver(){
        return p_vecRecver;
}


const MessageType::MessageType & Message::getType() const{
        return p_type;
}


MessageType::MessageType & Message::getType(){
        return p_type;
}


const Swarm::Data & Message::getData() const{
        return p_data;
}


Swarm::Data & Message::getData(){
        return p_data;
}


void Message::copyMessage(const Message & other){
        p_sendTime = other.p_sendTime;
        p_id = other.p_id;
        p_isConfirmationNeeded = other.p_isConfirmationNeeded;
        p_sender = other.p_sender;
        p_vecRecver = other.p_vecRecver;
        p_type = other.p_type;
        p_data = other.p_data;
}

void Message::initialisationMessage(){
        p_id = 0lu;
        p_isConfirmationNeeded = false;
        p_sender = "";
}


template<>
std::string phoenix_getTypeName<VecStat >(){
        return "VecStat";
}


bool CheckStream<Swarm::VecStat>::check_stream(const std::string & fieldDescription, const Swarm::VecStat & data, const Swarm::VecStat & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<std::vector<size_t>>::check_stream(fieldDescription + "\n- VecStat::nbEvent", data.getNbEvent(), reference.getNbEvent(), out);
        b &= CheckStream<std::vector<time_t>>::check_stream(fieldDescription + "\n- VecStat::startTimestamp", data.getStartTimestamp(), reference.getStartTimestamp(), out);
        b &= CheckStream<std::vector<time_t>>::check_stream(fieldDescription + "\n- VecStat::endTimestamp", data.getEndTimestamp(), reference.getEndTimestamp(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::min", data.getMin(), reference.getMin(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::max", data.getMax(), reference.getMax(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::average", data.getAverage(), reference.getAverage(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::rate", data.getRate(), reference.getRate(), out);
        b &= CheckStream<std::vector<std::vector<float> >>::check_stream(fieldDescription + "\n- VecStat::vecRateQuantile", data.getVecRateQuantile(), reference.getVecRateQuantile(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::rateEventBelowLowerBound", data.getRateEventBelowLowerBound(), reference.getRateEventBelowLowerBound(), out);
        b &= CheckStream<std::vector<float>>::check_stream(fieldDescription + "\n- VecStat::rateEventAboveUpperBound", data.getRateEventAboveUpperBound(), reference.getRateEventAboveUpperBound(), out);
        return b;
}
 

VecStat::VecStat(){
        initialisationVecStat();
}

VecStat::~VecStat(){
        
}


VecStat::VecStat(const VecStat & other){
        copyVecStat(other);
}


VecStat & VecStat::operator = (const VecStat & other){
        copyVecStat(other);
        return *this;
}


void VecStat::setNbEvent(const std::vector<size_t> & nbEvent){
        p_nbEvent = nbEvent;
}


void VecStat::setStartTimestamp(const std::vector<time_t> & startTimestamp){
        p_startTimestamp = startTimestamp;
}


void VecStat::setEndTimestamp(const std::vector<time_t> & endTimestamp){
        p_endTimestamp = endTimestamp;
}


void VecStat::setMin(const std::vector<float> & min){
        p_min = min;
}


void VecStat::setMax(const std::vector<float> & max){
        p_max = max;
}


void VecStat::setAverage(const std::vector<float> & average){
        p_average = average;
}


void VecStat::setRate(const std::vector<float> & rate){
        p_rate = rate;
}


void VecStat::setVecRateQuantile(const std::vector<std::vector<float> > & vecRateQuantile){
        p_vecRateQuantile = vecRateQuantile;
}


void VecStat::setRateEventBelowLowerBound(const std::vector<float> & rateEventBelowLowerBound){
        p_rateEventBelowLowerBound = rateEventBelowLowerBound;
}


void VecStat::setRateEventAboveUpperBound(const std::vector<float> & rateEventAboveUpperBound){
        p_rateEventAboveUpperBound = rateEventAboveUpperBound;
}


const std::vector<size_t> & VecStat::getNbEvent() const{
        return p_nbEvent;
}


std::vector<size_t> & VecStat::getNbEvent(){
        return p_nbEvent;
}


const std::vector<time_t> & VecStat::getStartTimestamp() const{
        return p_startTimestamp;
}


std::vector<time_t> & VecStat::getStartTimestamp(){
        return p_startTimestamp;
}


const std::vector<time_t> & VecStat::getEndTimestamp() const{
        return p_endTimestamp;
}


std::vector<time_t> & VecStat::getEndTimestamp(){
        return p_endTimestamp;
}


const std::vector<float> & VecStat::getMin() const{
        return p_min;
}


std::vector<float> & VecStat::getMin(){
        return p_min;
}


const std::vector<float> & VecStat::getMax() const{
        return p_max;
}


std::vector<float> & VecStat::getMax(){
        return p_max;
}


const std::vector<float> & VecStat::getAverage() const{
        return p_average;
}


std::vector<float> & VecStat::getAverage(){
        return p_average;
}


const std::vector<float> & VecStat::getRate() const{
        return p_rate;
}


std::vector<float> & VecStat::getRate(){
        return p_rate;
}


const std::vector<std::vector<float> > & VecStat::getVecRateQuantile() const{
        return p_vecRateQuantile;
}


std::vector<std::vector<float> > & VecStat::getVecRateQuantile(){
        return p_vecRateQuantile;
}


const std::vector<float> & VecStat::getRateEventBelowLowerBound() const{
        return p_rateEventBelowLowerBound;
}


std::vector<float> & VecStat::getRateEventBelowLowerBound(){
        return p_rateEventBelowLowerBound;
}


const std::vector<float> & VecStat::getRateEventAboveUpperBound() const{
        return p_rateEventAboveUpperBound;
}


std::vector<float> & VecStat::getRateEventAboveUpperBound(){
        return p_rateEventAboveUpperBound;
}


void VecStat::copyVecStat(const VecStat & other){
        p_nbEvent = other.p_nbEvent;
        p_startTimestamp = other.p_startTimestamp;
        p_endTimestamp = other.p_endTimestamp;
        p_min = other.p_min;
        p_max = other.p_max;
        p_average = other.p_average;
        p_rate = other.p_rate;
        p_vecRateQuantile = other.p_vecRateQuantile;
        p_rateEventBelowLowerBound = other.p_rateEventBelowLowerBound;
        p_rateEventAboveUpperBound = other.p_rateEventAboveUpperBound;
}

void VecStat::initialisationVecStat(){
}


template<>
std::string phoenix_getTypeName<Stat >(){
        return "Stat";
}


bool CheckStream<Swarm::Stat>::check_stream(const std::string & fieldDescription, const Swarm::Stat & data, const Swarm::Stat & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- Stat::name", data.getName(), reference.getName(), out);
        b &= CheckStream<std::map<PString, Swarm::VecStat >>::check_stream(fieldDescription + "\n- Stat::mapStatComputing", data.getMapStatComputing(), reference.getMapStatComputing(), out);
        b &= CheckStream<std::map<DaemonName, std::map<DataType, Swarm::VecStat > >>::check_stream(fieldDescription + "\n- Stat::mapStatCommunication", data.getMapStatCommunication(), reference.getMapStatCommunication(), out);
        return b;
}
 

Stat::Stat(){
        initialisationStat();
}

Stat::~Stat(){
        
}


Stat::Stat(const Stat & other){
        copyStat(other);
}


Stat & Stat::operator = (const Stat & other){
        copyStat(other);
        return *this;
}


void Stat::setName(const PString & name){
        p_name = name;
}


void Stat::setMapStatComputing(const std::map<PString, Swarm::VecStat > & mapStatComputing){
        p_mapStatComputing = mapStatComputing;
}


void Stat::setMapStatCommunication(const std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & mapStatCommunication){
        p_mapStatCommunication = mapStatCommunication;
}


const PString & Stat::getName() const{
        return p_name;
}


PString & Stat::getName(){
        return p_name;
}


const std::map<PString, Swarm::VecStat > & Stat::getMapStatComputing() const{
        return p_mapStatComputing;
}


std::map<PString, Swarm::VecStat > & Stat::getMapStatComputing(){
        return p_mapStatComputing;
}


const std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & Stat::getMapStatCommunication() const{
        return p_mapStatCommunication;
}


std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & Stat::getMapStatCommunication(){
        return p_mapStatCommunication;
}


void Stat::copyStat(const Stat & other){
        p_name = other.p_name;
        p_mapStatComputing = other.p_mapStatComputing;
        p_mapStatCommunication = other.p_mapStatCommunication;
}

void Stat::initialisationStat(){
        p_name = "";
}


template<>
std::string phoenix_getTypeName<StatAccumulator >(){
        return "StatAccumulator";
}


bool CheckStream<Swarm::StatAccumulator>::check_stream(const std::string & fieldDescription, const Swarm::StatAccumulator & data, const Swarm::StatAccumulator & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- StatAccumulator::nbEvent", data.getNbEvent(), reference.getNbEvent(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- StatAccumulator::sum", data.getSum(), reference.getSum(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- StatAccumulator::min", data.getMin(), reference.getMin(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- StatAccumulator::max", data.getMax(), reference.getMax(), out);
        b &= CheckStream<std::vector<size_t>>::check_stream(fieldDescription + "\n- StatAccumulator::vecHistogram", data.getVecHistogram(), reference.getVecHistogram(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- StatAccumulator::histLowerBound", data.getHistLowerBound(), reference.getHistLowerBound(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- StatAccumulator::histUpperBound", data.getHistUpperBound(), reference.getHistUpperBound(), out);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- StatAccumulator::nbEventBelowLowerBound", data.getNbEventBelowLowerBound(), reference.getNbEventBelowLowerBound(), out);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- StatAccumulator::nbEventAboveUpperBound", data.getNbEventAboveUpperBound(), reference.getNbEventAboveUpperBound(), out);
        return b;
}
 

StatAccumulator::StatAccumulator(){
        initialisationStatAccumulator();
}

StatAccumulator::~StatAccumulator(){
        
}


StatAccumulator::StatAccumulator(const StatAccumulator & other){
        copyStatAccumulator(other);
}


StatAccumulator & StatAccumulator::operator = (const StatAccumulator & other){
        copyStatAccumulator(other);
        return *this;
}


void StatAccumulator::setNbEvent(size_t nbEvent){
        p_nbEvent = nbEvent;
}


void StatAccumulator::setSum(float sum){
        p_sum = sum;
}


void StatAccumulator::setMin(float min){
        p_min = min;
}


void StatAccumulator::setMax(float max){
        p_max = max;
}


void StatAccumulator::setVecHistogram(const std::vector<size_t> & vecHistogram){
        p_vecHistogram = vecHistogram;
}


void StatAccumulator::setHistLowerBound(float histLowerBound){
        p_histLowerBound = histLowerBound;
}


void StatAccumulator::setHistUpperBound(float histUpperBound){
        p_histUpperBound = histUpperBound;
}


void StatAccumulator::setNbEventBelowLowerBound(size_t nbEventBelowLowerBound){
        p_nbEventBelowLowerBound = nbEventBelowLowerBound;
}


void StatAccumulator::setNbEventAboveUpperBound(size_t nbEventAboveUpperBound){
        p_nbEventAboveUpperBound = nbEventAboveUpperBound;
}


size_t StatAccumulator::getNbEvent() const{
        return p_nbEvent;
}


size_t & StatAccumulator::getNbEvent(){
        return p_nbEvent;
}


float StatAccumulator::getSum() const{
        return p_sum;
}


float & StatAccumulator::getSum(){
        return p_sum;
}


float StatAccumulator::getMin() const{
        return p_min;
}


float & StatAccumulator::getMin(){
        return p_min;
}


float StatAccumulator::getMax() const{
        return p_max;
}


float & StatAccumulator::getMax(){
        return p_max;
}


const std::vector<size_t> & StatAccumulator::getVecHistogram() const{
        return p_vecHistogram;
}


std::vector<size_t> & StatAccumulator::getVecHistogram(){
        return p_vecHistogram;
}


float StatAccumulator::getHistLowerBound() const{
        return p_histLowerBound;
}


float & StatAccumulator::getHistLowerBound(){
        return p_histLowerBound;
}


float StatAccumulator::getHistUpperBound() const{
        return p_histUpperBound;
}


float & StatAccumulator::getHistUpperBound(){
        return p_histUpperBound;
}


size_t StatAccumulator::getNbEventBelowLowerBound() const{
        return p_nbEventBelowLowerBound;
}


size_t & StatAccumulator::getNbEventBelowLowerBound(){
        return p_nbEventBelowLowerBound;
}


size_t StatAccumulator::getNbEventAboveUpperBound() const{
        return p_nbEventAboveUpperBound;
}


size_t & StatAccumulator::getNbEventAboveUpperBound(){
        return p_nbEventAboveUpperBound;
}


void StatAccumulator::copyStatAccumulator(const StatAccumulator & other){
        p_nbEvent = other.p_nbEvent;
        p_sum = other.p_sum;
        p_min = other.p_min;
        p_max = other.p_max;
        p_vecHistogram = other.p_vecHistogram;
        p_histLowerBound = other.p_histLowerBound;
        p_histUpperBound = other.p_histUpperBound;
        p_nbEventBelowLowerBound = other.p_nbEventBelowLowerBound;
        p_nbEventAboveUpperBound = other.p_nbEventAboveUpperBound;
}

void StatAccumulator::initialisationStatAccumulator(){
        p_nbEvent = 0lu;
        p_sum = 0.0f;
        p_min = 0.0f;
        p_max = 0.0f;
        p_histLowerBound = 0.0f;
        p_histUpperBound = 0.0f;
        p_nbEventBelowLowerBound = 0lu;
        p_nbEventAboveUpperBound = 0lu;
}


template<>
std::string phoenix_getTypeName<DaemonStatAccumulator >(){
        return "DaemonStatAccumulator";
}


bool CheckStream<Swarm::DaemonStatAccumulator>::check_stream(const std::string & fieldDescription, const Swarm::DaemonStatAccumulator & data, const Swarm::DaemonStatAccumulator & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<std::map<PString, Swarm::StatAccumulator >>::check_stream(fieldDescription + "\n- DaemonStatAccumulator::mapStatComputing", data.getMapStatComputing(), reference.getMapStatComputing(), out);
        b &= CheckStream<std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > >>::check_stream(fieldDescription + "\n- DaemonStatAccumulator::mapStatCommunication", data.getMapStatCommunication(), reference.getMapStatCommunication(), out);
        return b;
}
 

DaemonStatAccumulator::DaemonStatAccumulator(){
        initialisationDaemonStatAccumulator();
}

DaemonStatAccumulator::~DaemonStatAccumulator(){
        
}


DaemonStatAccumulator::DaemonStatAccumulator(const DaemonStatAccumulator & other){
        copyDaemonStatAccumulator(other);
}


DaemonStatAccumulator & DaemonStatAccumulator::operator = (const DaemonStatAccumulator & other){
        copyDaemonStatAccumulator(other);
        return *this;
}


void DaemonStatAccumulator::setMapStatComputing(const std::map<PString, Swarm::StatAccumulator > & mapStatComputing){
        p_mapStatComputing = mapStatComputing;
}


void DaemonStatAccumulator::setMapStatCommunication(const std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & mapStatCommunication){
        p_mapStatCommunication = mapStatCommunication;
}


const std::map<PString, Swarm::StatAccumulator > & DaemonStatAccumulator::getMapStatComputing() const{
        return p_mapStatComputing;
}


std::map<PString, Swarm::StatAccumulator > & DaemonStatAccumulator::getMapStatComputing(){
        return p_mapStatComputing;
}


const std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & DaemonStatAccumulator::getMapStatCommunication() const{
        return p_mapStatCommunication;
}


std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & DaemonStatAccumulator::getMapStatCommunication(){
        return p_mapStatCommunication;
}


void DaemonStatAccumulator::copyDaemonStatAccumulator(const DaemonStatAccumulator & other){
        p_mapStatComputing = other.p_mapStatComputing;
        p_mapStatCommunication = other.p_mapStatCommunication;
}

void DaemonStatAccumulator::initialisationDaemonStatAccumulator(){
}


template<>
std::string phoenix_getTypeName<DaemonConfig >(){
        return "DaemonConfig";
}


bool CheckStream<Swarm::DaemonConfig>::check_stream(const std::string & fieldDescription, const Swarm::DaemonConfig & data, const Swarm::DaemonConfig & reference, std::ostream & out){
        bool b(true);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- DaemonConfig::hostName", data.getHostName(), reference.getHostName(), out);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- DaemonConfig::receivingPort", data.getReceivingPort(), reference.getReceivingPort(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- DaemonConfig::name", data.getName(), reference.getName(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- DaemonConfig::description", data.getDescription(), reference.getDescription(), out);
        b &= CheckStream<std::map<PString, time_t>>::check_stream(fieldDescription + "\n- DaemonConfig::mapTimeout", data.getMapTimeout(), reference.getMapTimeout(), out);
        b &= CheckStream<size_t>::check_stream(fieldDescription + "\n- DaemonConfig::statNbBin", data.getStatNbBin(), reference.getStatNbBin(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- DaemonConfig::statHistLowerBound", data.getStatHistLowerBound(), reference.getStatHistLowerBound(), out);
        b &= CheckStream<float>::check_stream(fieldDescription + "\n- DaemonConfig::statHistUpperBound", data.getStatHistUpperBound(), reference.getStatHistUpperBound(), out);
        b &= CheckStream<time_t>::check_stream(fieldDescription + "\n- DaemonConfig::statTimerPeriodMs", data.getStatTimerPeriodMs(), reference.getStatTimerPeriodMs(), out);
        b &= CheckStream<Swarm::DaemonStatAccumulator>::check_stream(fieldDescription + "\n- DaemonConfig::daemonStatAccumulator", data.getDaemonStatAccumulator(), reference.getDaemonStatAccumulator(), out);
        b &= CheckStream<PString>::check_stream(fieldDescription + "\n- DaemonConfig::statDaemonName", data.getStatDaemonName(), reference.getStatDaemonName(), out);
        return b;
}
 

DaemonConfig::DaemonConfig(){
        initialisationDaemonConfig();
}

DaemonConfig::~DaemonConfig(){
        
}


DaemonConfig::DaemonConfig(const DaemonConfig & other){
        copyDaemonConfig(other);
}


DaemonConfig & DaemonConfig::operator = (const DaemonConfig & other){
        copyDaemonConfig(other);
        return *this;
}


void DaemonConfig::setHostName(const PString & hostName){
        p_hostName = hostName;
}


void DaemonConfig::setReceivingPort(size_t receivingPort){
        p_receivingPort = receivingPort;
}


void DaemonConfig::setName(const PString & name){
        p_name = name;
}


void DaemonConfig::setDescription(const PString & description){
        p_description = description;
}


void DaemonConfig::setMapTimeout(const std::map<PString, time_t> & mapTimeout){
        p_mapTimeout = mapTimeout;
}


void DaemonConfig::setStatNbBin(size_t statNbBin){
        p_statNbBin = statNbBin;
}


void DaemonConfig::setStatHistLowerBound(float statHistLowerBound){
        p_statHistLowerBound = statHistLowerBound;
}


void DaemonConfig::setStatHistUpperBound(float statHistUpperBound){
        p_statHistUpperBound = statHistUpperBound;
}


void DaemonConfig::setStatTimerPeriodMs(const time_t & statTimerPeriodMs){
        p_statTimerPeriodMs = statTimerPeriodMs;
}


void DaemonConfig::setDaemonStatAccumulator(const Swarm::DaemonStatAccumulator & daemonStatAccumulator){
        p_daemonStatAccumulator = daemonStatAccumulator;
}


void DaemonConfig::setStatDaemonName(const PString & statDaemonName){
        p_statDaemonName = statDaemonName;
}


const PString & DaemonConfig::getHostName() const{
        return p_hostName;
}


PString & DaemonConfig::getHostName(){
        return p_hostName;
}


size_t DaemonConfig::getReceivingPort() const{
        return p_receivingPort;
}


size_t & DaemonConfig::getReceivingPort(){
        return p_receivingPort;
}


const PString & DaemonConfig::getName() const{
        return p_name;
}


PString & DaemonConfig::getName(){
        return p_name;
}


const PString & DaemonConfig::getDescription() const{
        return p_description;
}


PString & DaemonConfig::getDescription(){
        return p_description;
}


const std::map<PString, time_t> & DaemonConfig::getMapTimeout() const{
        return p_mapTimeout;
}


std::map<PString, time_t> & DaemonConfig::getMapTimeout(){
        return p_mapTimeout;
}


size_t DaemonConfig::getStatNbBin() const{
        return p_statNbBin;
}


size_t & DaemonConfig::getStatNbBin(){
        return p_statNbBin;
}


float DaemonConfig::getStatHistLowerBound() const{
        return p_statHistLowerBound;
}


float & DaemonConfig::getStatHistLowerBound(){
        return p_statHistLowerBound;
}


float DaemonConfig::getStatHistUpperBound() const{
        return p_statHistUpperBound;
}


float & DaemonConfig::getStatHistUpperBound(){
        return p_statHistUpperBound;
}


const time_t & DaemonConfig::getStatTimerPeriodMs() const{
        return p_statTimerPeriodMs;
}


time_t & DaemonConfig::getStatTimerPeriodMs(){
        return p_statTimerPeriodMs;
}


const Swarm::DaemonStatAccumulator & DaemonConfig::getDaemonStatAccumulator() const{
        return p_daemonStatAccumulator;
}


Swarm::DaemonStatAccumulator & DaemonConfig::getDaemonStatAccumulator(){
        return p_daemonStatAccumulator;
}


const PString & DaemonConfig::getStatDaemonName() const{
        return p_statDaemonName;
}


PString & DaemonConfig::getStatDaemonName(){
        return p_statDaemonName;
}


void DaemonConfig::copyDaemonConfig(const DaemonConfig & other){
        p_hostName = other.p_hostName;
        p_receivingPort = other.p_receivingPort;
        p_name = other.p_name;
        p_description = other.p_description;
        p_mapTimeout = other.p_mapTimeout;
        p_statNbBin = other.p_statNbBin;
        p_statHistLowerBound = other.p_statHistLowerBound;
        p_statHistUpperBound = other.p_statHistUpperBound;
        p_statTimerPeriodMs = other.p_statTimerPeriodMs;
        p_daemonStatAccumulator = other.p_daemonStatAccumulator;
        p_statDaemonName = other.p_statDaemonName;
}

void DaemonConfig::initialisationDaemonConfig(){
        p_hostName = "";
        p_receivingPort = 0lu;
        p_name = "";
        p_description = "";
        p_statNbBin = 0lu;
        p_statHistLowerBound = 0.0f;
        p_statHistUpperBound = 0.0f;
        p_statDaemonName = "";
}