cstatistic.h

//==========================================================================
//  CSTATISTIC.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_CSTATISTIC_H
#define __OMNETPP_CSTATISTIC_H

#include "crandom.h"
#include "simtime.h"
#include "opp_string.h"

namespace omnetpp {

class SIM_API cStatistic : public cRandom
{
  private:
    void copy(const cStatistic& other);

  protected:
    // internal: utility function for implementing loadFromFile() functions
    void freadvarsf (FILE *f,  const char *fmt, ...) _OPP_GNU_ATTRIBUTE((format(scanf, 3, 4)));
    // internal: for collecting the attributes to record into the scalar file
    virtual void getAttributesToRecord(opp_string_map& attributes) {}

  public:

    cStatistic(const cStatistic& r);

    explicit cStatistic(const char *name=nullptr);

    virtual ~cStatistic();

    cStatistic& operator=(const cStatistic& res);


    /* Note: No dup() because this is an abstract class! */

    virtual void parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;

    virtual bool isWeighted() const = 0;

    virtual void collect(double value) = 0;

    virtual void collect(SimTime value) {collect(value.dbl());}

    virtual void collectWeighted(double value, double weight);

    virtual void collectWeighted(SimTime value, double weight) {collectWeighted(value.dbl(), weight);}

    virtual void collectWeighted(double value, SimTime weight) {collectWeighted(value, weight.dbl());}

    virtual void collectWeighted(SimTime value, SimTime weight) {collectWeighted(value.dbl(), weight.dbl());}

    virtual void merge(const cStatistic *other) = 0;

    virtual void clear() = 0;


    virtual int64_t getCount() const = 0;

    virtual double getSum() const = 0;

    virtual double getSqrSum() const = 0;

    virtual double getMin() const = 0;

    virtual double getMax() const = 0;

    virtual double getMean() const = 0;

    virtual double getStddev() const = 0;

    virtual double getVariance() const = 0;

    virtual double getSumWeights() const = 0;

    virtual double getWeightedSum() const = 0;

    virtual double getSqrSumWeights() const = 0;

    virtual double getWeightedSqrSum() const = 0;


    virtual void saveToFile(FILE *) const = 0;

    virtual void loadFromFile(FILE *) = 0;

    virtual void record()  {recordAs(nullptr, nullptr);}

    virtual void recordWithUnit(const char *unit)  {recordAs(nullptr, unit);}

    virtual void recordAs(const char *name, const char *unit=nullptr);

    _OPPDEPRECATED virtual double getWeights() const final {return getSumWeights();}

    _OPPDEPRECATED virtual void collect2(double value, double weight) final {collectWeighted(value, weight);}

    _OPPDEPRECATED virtual void collect2(SimTime value, double weight) final {collectWeighted(value, weight);}

    _OPPDEPRECATED virtual void collect2(double value, SimTime weight) final {collectWeighted(value, weight);}

    _OPPDEPRECATED virtual void collect2(SimTime value, SimTime weight) final {collectWeighted(value, weight);}

    _OPPDEPRECATED virtual double random() const final {return draw();}

    _OPPDEPRECATED virtual void clearResult() final {clear();}
};

}  // namespace omnetpp

#endif