resultfilters.h Source File¶

API: resultfilters.h Source File
API
//==========================================================================
//  RESULTFILTERS.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_RESULTFILTERS_H
#define __OMNETPP_RESULTFILTERS_H
 
#include <cmath>  // INFINITY, NAN
#include "omnetpp/simkerneldefs.h"
#include "omnetpp/statsum_t.h"
#include "omnetpp/cresultfilter.h"
#include "omnetpp/csimulation.h"
#include "omnetpp/cstatistic.h"
 
namespace omnetpp {
class SIM_API WarmupPeriodFilter : public cResultFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override;
    public:
        virtual simtime_t_cref getEndWarmupPeriod() const {return getSimulation()->getWarmupPeriod();}
        virtual std::string str() const override;
};
class SIM_API DemuxFilter : public cResultFilter
{
    private:
        int fanOut = -1; // number of initial outputs; #outputs is a multiple of fanOut
        std::map<std::string, int> labelToDelegateStartIndexMap;
    private:
        int getDelegateStartIndexByLabel(cObject *details);
        cResultListener *copyChain(cResultListener *templateChain, const char *label);
    protected:
        virtual std::string getDemuxLabel(cObject *details);
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override;
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override;
    public:
        virtual std::string str() const override;
};
class SIM_API TotalCountFilter : public cResultFilter
{
    protected:
        intval_t count;
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t l, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t l, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override {count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override {count++; fire(this,t,count,details);}
    public:
        TotalCountFilter() {count = 0;}
        intval_t getCount() const {return count;}
        virtual double getInitialDoubleValue() const override {return getCount();}
        virtual std::string str() const override;
};
class SIM_API CountFilter : public TotalCountFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override {if (!std::isnan(d)) count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override {if (s) count++; fire(this,t,count,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override {if (obj) count++; fire(this,t,count,details);}
    public:
        CountFilter() {}
};
class SIM_API ConstantFilter : public cResultFilter
{
    protected:
        double c;
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t l, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t l, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override {fire(this,t,c,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override {fire(this,t,c,details);}
    public:
        ConstantFilter(double c) {this->c = c;}
        double getConstant() const {return c;}
        virtual double getInitialDoubleValue() const override {return c;}
        virtual std::string str() const override;
};
class SIM_API Constant0Filter : public ConstantFilter
{
    public:
        Constant0Filter() : ConstantFilter(0) {}
};
class SIM_API Constant1Filter : public ConstantFilter
{
    public:
        Constant1Filter() : ConstantFilter(1) {}
};
class SIM_API TimeFilter : public cResultFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t l, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t l, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override {fire(this,t,t,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override {fire(this,t,t,details);}
    public:
        TimeFilter() {}
};
class SIM_API IdentityFilter : public cResultFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, bool b, cObject *details) override {fire(this,t,b,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, intval_t l, cObject *details) override {fire(this,t,l,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, uintval_t l, cObject *details) override {fire(this,t,l,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, double d, cObject *details) override {fire(this,t,d,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const SimTime& v, cObject *details) override {fire(this,t,v,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, const char *s, cObject *details) override {fire(this,t,s,details);}
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *obj, cObject *details) override {fire(this,t,obj,details);}
    public:
        IdentityFilter() {}
};
class SIM_API MergeFilter : public IdentityFilter
{
    protected:
        virtual void subscribedTo(cResultFilter *prev) override {} // to allow subscription to multiple signals
    public:
        MergeFilter() {}
};
 
class SIM_API SkipNanFilter : public cNumericResultFilter
{
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override {return !std::isnan(value);}
};
class SIM_API ErrorNanFilter : public cNumericResultFilter
{
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
};
class SIM_API CountNanFilter : public cNumericResultFilter
{
    protected:
        intval_t count = 0;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        CountNanFilter() {}
        intval_t getCount() const {return count;}
        virtual double getInitialDoubleValue() const override {return getCount();}
        virtual std::string str() const override;
};
class SIM_API SumFilter : public cNumericResultFilter
{
    protected:
        statsum_t sum;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        SumFilter() {sum = 0;}
        double getSum() const {return sum;}
        virtual double getInitialDoubleValue() const override {return getSum();}
        virtual std::string str() const override;
};
class SIM_API MeanFilter : public cNumericResultFilter
{
    protected:
        bool timeWeighted = false;
        intval_t count = 0;
        double lastValue = NAN;
        simtime_t lastTime = SIMTIME_ZERO;
        statsum_t weightedSum = 0;
        simtime_t totalTime = SIMTIME_ZERO;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        MeanFilter() {}
        virtual void init(Context *ctx) override;
        virtual void finish(cResultFilter *prev) override;
        double getMean() const;
        virtual std::string str() const override;
};
class SIM_API MinFilter : public cNumericResultFilter
{
    protected:
        double min;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        MinFilter() {min = INFINITY;}
        double getMin() const {return min;}
        virtual std::string str() const override;
};
class SIM_API MaxFilter : public cNumericResultFilter
{
    protected:
        double max;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        MaxFilter() {max = -INFINITY;}
        double getMax() const {return max;}
        virtual std::string str() const override;
};
class SIM_API AverageFilter : public cNumericResultFilter
{
    protected:
        intval_t count;
        statsum_t sum;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        AverageFilter() {count = 0; sum = 0;}
        double getAverage() const {return sum/count;}
        virtual std::string str() const override;
};
class SIM_API TimeAverageFilter : public cNumericResultFilter
{
    protected:
        double lastValue = NAN;
        simtime_t lastTime = SIMTIME_ZERO;
        statsum_t weightedSum = 0;
        simtime_t totalTime = SIMTIME_ZERO;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        TimeAverageFilter() {}
        virtual void finish(cResultFilter *prev) override;
        double getTimeAverage() const;
        virtual std::string str() const override;
};
class SIM_API RateAverageFilter : public cNumericResultFilter
{
    protected:
        simtime_t lastTime = SIMTIME_ZERO;
        statsum_t weightedSum = 0;
        simtime_t totalTime = SIMTIME_ZERO;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        RateAverageFilter() {}
        double getRateAverage() const;
        virtual std::string str() const override;
};
class SIM_API RemoveRepeatsFilter : public cNumericResultFilter
{
    protected:
        double prev;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        RemoveRepeatsFilter() {prev = NAN;}
        double getLastValue() const {return prev;}
        virtual std::string str() const override;
};
class SIM_API PacketBytesFilter : public cObjectResultFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override;
    public:
        using cObjectResultFilter::receiveSignal;
};
class SIM_API PacketBitsFilter : public cObjectResultFilter
{
    protected:
        virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override;
    public:
        using cObjectResultFilter::receiveSignal;
};
class SIM_API SumPerDurationFilter : public cNumericResultFilter
{
    protected:
        statsum_t sum;
    protected:
        virtual bool process(simtime_t& t, double& value, cObject *details) override;
    public:
        SumPerDurationFilter() {sum = 0;}
        virtual void finish(cResultFilter *prev) override;
        double getSumPerDuration() const;
        virtual double getInitialDoubleValue() const override {return getSumPerDuration();}
        virtual std::string str() const override;
};
 
}  // namespace omnetpp
 
#endif