Representation.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __REPRESENTATION_H__
#define __REPRESENTATION_H__
 
#include <string>
#include "phoenix_data_stream.h"
#include "phoenix_path_stream.h"
#include "PString.h"
#include "MessageType.h"
#include "swarm_core_namespace_def.h"
 
#include "phoenix_type_stream.h"
#include "phoenix_data_stream.h"
#include "phoenix_check_stream.h"

class Swarm::Data{
        public:
                Data();
                virtual ~Data();
                Data(const Data & other);
                Data & operator = (const Data & other);
                void setName(const PString & name);
                void setDescription(const PString & description);
                void setType(const PString & type);
                void setValue(const DataStreamMsg & value);
                const PString & getName() const;
                PString & getName();
                const PString & getDescription() const;
                PString & getDescription();
                const PString & getType() const;
                PString & getType();
                const DataStreamMsg & getValue() const;
                DataStreamMsg & getValue();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_name);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_description);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_type);
                        b &= DataStream<Stream, Mode, DataStreamMsg >::data_stream(ds, p_value);
                        return b;
                }
 
        protected:
                void copyData(const Data & other);
        private:
                void initialisationData();
                PString p_name;
                PString p_description;
                PString p_type;
                DataStreamMsg p_value;
};
 
template<>
std::string phoenix_getTypeName<Swarm::Data>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::Data>{

        static bool data_stream(Stream & ds, Swarm::Data & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::Data>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::Data & data, const Swarm::Data & reference, std::ostream & out);
};
 
 
 

class Swarm::Function{
        public:
                Function();
                virtual ~Function();
                Function(const Function & other);
                Function & operator = (const Function & other);
                void setName(const PString & name);
                void setDescription(const PString & description);
                void setVecParam(const std::vector<Swarm::Data> & vecParam);
                void setReturnValue(const Swarm::Data & returnValue);
                const PString & getName() const;
                PString & getName();
                const PString & getDescription() const;
                PString & getDescription();
                const std::vector<Swarm::Data> & getVecParam() const;
                std::vector<Swarm::Data> & getVecParam();
                const Swarm::Data & getReturnValue() const;
                Swarm::Data & getReturnValue();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_name);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_description);
                        b &= DataStream<Stream, Mode, std::vector<Swarm::Data> >::data_stream(ds, p_vecParam);
                        b &= DataStream<Stream, Mode, Swarm::Data >::data_stream(ds, p_returnValue);
                        return b;
                }
 
        protected:
                void copyFunction(const Function & other);
        private:
                void initialisationFunction();
                PString p_name;
                PString p_description;
                std::vector<Swarm::Data> p_vecParam;
                Swarm::Data p_returnValue;
};
 
template<>
std::string phoenix_getTypeName<Swarm::Function>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::Function>{

        static bool data_stream(Stream & ds, Swarm::Function & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::Function>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::Function & data, const Swarm::Function & reference, std::ostream & out);
};
 
 
 

class Swarm::Message{
        public:
                Message();
                virtual ~Message();
                Message(const Message & other);
                Message & operator = (const Message & other);
                void setSendTime(const time_t & sendTime);
                void setId(size_t id);
                void setIsConfirmationNeeded(bool isConfirmationNeeded);
                void setSender(const PString & sender);
                void setVecRecver(const std::vector<PString> & vecRecver);
                void setType(const MessageType::MessageType & type);
                void setData(const Swarm::Data & data);
                const time_t & getSendTime() const;
                time_t & getSendTime();
                size_t getId() const;
                size_t & getId();
                bool getIsConfirmationNeeded() const;
                bool & getIsConfirmationNeeded();
                const PString & getSender() const;
                PString & getSender();
                const std::vector<PString> & getVecRecver() const;
                std::vector<PString> & getVecRecver();
                const MessageType::MessageType & getType() const;
                MessageType::MessageType & getType();
                const Swarm::Data & getData() const;
                Swarm::Data & getData();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, time_t >::data_stream(ds, p_sendTime);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_id);
                        b &= DataStream<Stream, Mode, bool >::data_stream(ds, p_isConfirmationNeeded);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_sender);
                        b &= DataStream<Stream, Mode, std::vector<PString> >::data_stream(ds, p_vecRecver);
                        b &= DataStream<Stream, Mode, MessageType::MessageType >::data_stream(ds, p_type);
                        b &= DataStream<Stream, Mode, Swarm::Data >::data_stream(ds, p_data);
                        return b;
                }
 
        protected:
                void copyMessage(const Message & other);
        private:
                void initialisationMessage();
                time_t p_sendTime;
                size_t p_id;
                bool p_isConfirmationNeeded;
                PString p_sender;
                std::vector<PString> p_vecRecver;
                MessageType::MessageType p_type;
                Swarm::Data p_data;
};
 
template<>
std::string phoenix_getTypeName<Swarm::Message>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::Message>{

        static bool data_stream(Stream & ds, Swarm::Message & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::Message>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::Message & data, const Swarm::Message & reference, std::ostream & out);
};
 
 
 

class Swarm::VecStat{
        public:
                VecStat();
                virtual ~VecStat();
                VecStat(const VecStat & other);
                VecStat & operator = (const VecStat & other);
                void setNbEvent(const std::vector<size_t> & nbEvent);
                void setStartTimestamp(const std::vector<time_t> & startTimestamp);
                void setEndTimestamp(const std::vector<time_t> & endTimestamp);
                void setMin(const std::vector<float> & min);
                void setMax(const std::vector<float> & max);
                void setAverage(const std::vector<float> & average);
                void setRate(const std::vector<float> & rate);
                void setVecRateQuantile(const std::vector<std::vector<float> > & vecRateQuantile);
                void setRateEventBelowLowerBound(const std::vector<float> & rateEventBelowLowerBound);
                void setRateEventAboveUpperBound(const std::vector<float> & rateEventAboveUpperBound);
                const std::vector<size_t> & getNbEvent() const;
                std::vector<size_t> & getNbEvent();
                const std::vector<time_t> & getStartTimestamp() const;
                std::vector<time_t> & getStartTimestamp();
                const std::vector<time_t> & getEndTimestamp() const;
                std::vector<time_t> & getEndTimestamp();
                const std::vector<float> & getMin() const;
                std::vector<float> & getMin();
                const std::vector<float> & getMax() const;
                std::vector<float> & getMax();
                const std::vector<float> & getAverage() const;
                std::vector<float> & getAverage();
                const std::vector<float> & getRate() const;
                std::vector<float> & getRate();
                const std::vector<std::vector<float> > & getVecRateQuantile() const;
                std::vector<std::vector<float> > & getVecRateQuantile();
                const std::vector<float> & getRateEventBelowLowerBound() const;
                std::vector<float> & getRateEventBelowLowerBound();
                const std::vector<float> & getRateEventAboveUpperBound() const;
                std::vector<float> & getRateEventAboveUpperBound();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, std::vector<size_t> >::data_stream(ds, p_nbEvent);
                        b &= DataStream<Stream, Mode, std::vector<time_t> >::data_stream(ds, p_startTimestamp);
                        b &= DataStream<Stream, Mode, std::vector<time_t> >::data_stream(ds, p_endTimestamp);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_min);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_max);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_average);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_rate);
                        b &= DataStream<Stream, Mode, std::vector<std::vector<float> > >::data_stream(ds, p_vecRateQuantile);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_rateEventBelowLowerBound);
                        b &= DataStream<Stream, Mode, std::vector<float> >::data_stream(ds, p_rateEventAboveUpperBound);
                        return b;
                }
 
        protected:
                void copyVecStat(const VecStat & other);
        private:
                void initialisationVecStat();
                std::vector<size_t> p_nbEvent;
                std::vector<time_t> p_startTimestamp;
                std::vector<time_t> p_endTimestamp;
                std::vector<float> p_min;
                std::vector<float> p_max;
                std::vector<float> p_average;
                std::vector<float> p_rate;
                std::vector<std::vector<float> > p_vecRateQuantile;
                std::vector<float> p_rateEventBelowLowerBound;
                std::vector<float> p_rateEventAboveUpperBound;
};
 
template<>
std::string phoenix_getTypeName<Swarm::VecStat>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::VecStat>{

        static bool data_stream(Stream & ds, Swarm::VecStat & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::VecStat>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::VecStat & data, const Swarm::VecStat & reference, std::ostream & out);
};
 
 
 

class Swarm::Stat{
        public:
                Stat();
                virtual ~Stat();
                Stat(const Stat & other);
                Stat & operator = (const Stat & other);
                void setName(const PString & name);
                void setMapStatComputing(const std::map<PString, Swarm::VecStat > & mapStatComputing);
                void setMapStatCommunication(const std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & mapStatCommunication);
                const PString & getName() const;
                PString & getName();
                const std::map<PString, Swarm::VecStat > & getMapStatComputing() const;
                std::map<PString, Swarm::VecStat > & getMapStatComputing();
                const std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & getMapStatCommunication() const;
                std::map<DaemonName, std::map<DataType, Swarm::VecStat > > & getMapStatCommunication();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_name);
                        b &= DataStream<Stream, Mode, std::map<PString, Swarm::VecStat > >::data_stream(ds, p_mapStatComputing);
                        b &= DataStream<Stream, Mode, std::map<DaemonName, std::map<DataType, Swarm::VecStat > > >::data_stream(ds, p_mapStatCommunication);
                        return b;
                }
 
        protected:
                void copyStat(const Stat & other);
        private:
                void initialisationStat();
                PString p_name;
                std::map<PString, Swarm::VecStat > p_mapStatComputing;
                std::map<DaemonName, std::map<DataType, Swarm::VecStat > > p_mapStatCommunication;
};
 
template<>
std::string phoenix_getTypeName<Swarm::Stat>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::Stat>{

        static bool data_stream(Stream & ds, Swarm::Stat & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::Stat>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::Stat & data, const Swarm::Stat & reference, std::ostream & out);
};
 
 
 

class Swarm::StatAccumulator{
        public:
                StatAccumulator();
                virtual ~StatAccumulator();
                StatAccumulator(const StatAccumulator & other);
                StatAccumulator & operator = (const StatAccumulator & other);
                void setNbEvent(size_t nbEvent);
                void setSum(float sum);
                void setMin(float min);
                void setMax(float max);
                void setVecHistogram(const std::vector<size_t> & vecHistogram);
                void setHistLowerBound(float histLowerBound);
                void setHistUpperBound(float histUpperBound);
                void setNbEventBelowLowerBound(size_t nbEventBelowLowerBound);
                void setNbEventAboveUpperBound(size_t nbEventAboveUpperBound);
                size_t getNbEvent() const;
                size_t & getNbEvent();
                float getSum() const;
                float & getSum();
                float getMin() const;
                float & getMin();
                float getMax() const;
                float & getMax();
                const std::vector<size_t> & getVecHistogram() const;
                std::vector<size_t> & getVecHistogram();
                float getHistLowerBound() const;
                float & getHistLowerBound();
                float getHistUpperBound() const;
                float & getHistUpperBound();
                size_t getNbEventBelowLowerBound() const;
                size_t & getNbEventBelowLowerBound();
                size_t getNbEventAboveUpperBound() const;
                size_t & getNbEventAboveUpperBound();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_nbEvent);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_sum);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_min);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_max);
                        b &= DataStream<Stream, Mode, std::vector<size_t> >::data_stream(ds, p_vecHistogram);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_histLowerBound);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_histUpperBound);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_nbEventBelowLowerBound);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_nbEventAboveUpperBound);
                        return b;
                }
 
        protected:
                void copyStatAccumulator(const StatAccumulator & other);
        private:
                void initialisationStatAccumulator();
                size_t p_nbEvent;
                float p_sum;
                float p_min;
                float p_max;
                std::vector<size_t> p_vecHistogram;
                float p_histLowerBound;
                float p_histUpperBound;
                size_t p_nbEventBelowLowerBound;
                size_t p_nbEventAboveUpperBound;
};
 
template<>
std::string phoenix_getTypeName<Swarm::StatAccumulator>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::StatAccumulator>{

        static bool data_stream(Stream & ds, Swarm::StatAccumulator & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::StatAccumulator>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::StatAccumulator & data, const Swarm::StatAccumulator & reference, std::ostream & out);
};
 
 
 

class Swarm::DaemonStatAccumulator{
        public:
                DaemonStatAccumulator();
                virtual ~DaemonStatAccumulator();
                DaemonStatAccumulator(const DaemonStatAccumulator & other);
                DaemonStatAccumulator & operator = (const DaemonStatAccumulator & other);
                void setMapStatComputing(const std::map<PString, Swarm::StatAccumulator > & mapStatComputing);
                void setMapStatCommunication(const std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & mapStatCommunication);
                const std::map<PString, Swarm::StatAccumulator > & getMapStatComputing() const;
                std::map<PString, Swarm::StatAccumulator > & getMapStatComputing();
                const std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & getMapStatCommunication() const;
                std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > & getMapStatCommunication();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, std::map<PString, Swarm::StatAccumulator > >::data_stream(ds, p_mapStatComputing);
                        b &= DataStream<Stream, Mode, std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > >::data_stream(ds, p_mapStatCommunication);
                        return b;
                }
 
        protected:
                void copyDaemonStatAccumulator(const DaemonStatAccumulator & other);
        private:
                void initialisationDaemonStatAccumulator();
                std::map<PString, Swarm::StatAccumulator > p_mapStatComputing;
                std::map<DaemonName, std::map<DataType, Swarm::StatAccumulator > > p_mapStatCommunication;
};
 
template<>
std::string phoenix_getTypeName<Swarm::DaemonStatAccumulator>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::DaemonStatAccumulator>{

        static bool data_stream(Stream & ds, Swarm::DaemonStatAccumulator & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::DaemonStatAccumulator>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::DaemonStatAccumulator & data, const Swarm::DaemonStatAccumulator & reference, std::ostream & out);
};
 
 
 

class Swarm::DaemonConfig{
        public:
                DaemonConfig();
                virtual ~DaemonConfig();
                DaemonConfig(const DaemonConfig & other);
                DaemonConfig & operator = (const DaemonConfig & other);
                void setHostName(const PString & hostName);
                void setReceivingPort(size_t receivingPort);
                void setName(const PString & name);
                void setDescription(const PString & description);
                void setMapTimeout(const std::map<PString, time_t> & mapTimeout);
                void setStatNbBin(size_t statNbBin);
                void setStatHistLowerBound(float statHistLowerBound);
                void setStatHistUpperBound(float statHistUpperBound);
                void setStatTimerPeriodMs(const time_t & statTimerPeriodMs);
                void setDaemonStatAccumulator(const Swarm::DaemonStatAccumulator & daemonStatAccumulator);
                void setStatDaemonName(const PString & statDaemonName);
                const PString & getHostName() const;
                PString & getHostName();
                size_t getReceivingPort() const;
                size_t & getReceivingPort();
                const PString & getName() const;
                PString & getName();
                const PString & getDescription() const;
                PString & getDescription();
                const std::map<PString, time_t> & getMapTimeout() const;
                std::map<PString, time_t> & getMapTimeout();
                size_t getStatNbBin() const;
                size_t & getStatNbBin();
                float getStatHistLowerBound() const;
                float & getStatHistLowerBound();
                float getStatHistUpperBound() const;
                float & getStatHistUpperBound();
                const time_t & getStatTimerPeriodMs() const;
                time_t & getStatTimerPeriodMs();
                const Swarm::DaemonStatAccumulator & getDaemonStatAccumulator() const;
                Swarm::DaemonStatAccumulator & getDaemonStatAccumulator();
                const PString & getStatDaemonName() const;
                PString & getStatDaemonName();


                template<typename Stream, DataStreamMode::DataStreamMode Mode>
                bool readWriteStream(Stream & ds){
                        bool b(true);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_hostName);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_receivingPort);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_name);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_description);
                        b &= DataStream<Stream, Mode, std::map<PString, time_t> >::data_stream(ds, p_mapTimeout);
                        b &= DataStream<Stream, Mode, size_t >::data_stream(ds, p_statNbBin);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_statHistLowerBound);
                        b &= DataStream<Stream, Mode, float >::data_stream(ds, p_statHistUpperBound);
                        b &= DataStream<Stream, Mode, time_t >::data_stream(ds, p_statTimerPeriodMs);
                        b &= DataStream<Stream, Mode, Swarm::DaemonStatAccumulator >::data_stream(ds, p_daemonStatAccumulator);
                        b &= DataStream<Stream, Mode, PString >::data_stream(ds, p_statDaemonName);
                        return b;
                }
 
        protected:
                void copyDaemonConfig(const DaemonConfig & other);
        private:
                void initialisationDaemonConfig();
                PString p_hostName;
                size_t p_receivingPort;
                PString p_name;
                PString p_description;
                std::map<PString, time_t> p_mapTimeout;
                size_t p_statNbBin;
                float p_statHistLowerBound;
                float p_statHistUpperBound;
                time_t p_statTimerPeriodMs;
                Swarm::DaemonStatAccumulator p_daemonStatAccumulator;
                PString p_statDaemonName;
};
 
template<>
std::string phoenix_getTypeName<Swarm::DaemonConfig>();

template<typename Stream, DataStreamMode::DataStreamMode Mode>
struct DataStream<Stream, Mode, Swarm::DaemonConfig>{

        static bool data_stream(Stream & ds, Swarm::DaemonConfig & data){
                return data.readWriteStream<Stream, Mode>(ds);
        }
};

template<>
struct CheckStream<Swarm::DaemonConfig>{
        static bool check_stream(const std::string & fieldDescription, const Swarm::DaemonConfig & data, const Swarm::DaemonConfig & reference, std::ostream & out);
};
 
 
 
 
 
 
#endif