coutvector.h

//==========================================================================
//  COUTVECTOR.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_COUTVECTOR_H
#define __OMNETPP_COUTVECTOR_H
 
#include <cstdio>
#include "cownedobject.h"
#include "simtime_t.h"
#include "opp_string.h"
 
namespace omnetpp {
 
 
typedef void (*RecordFunc)(void *, simtime_t, double);
 
class cEnum;
 
 
class SIM_API cOutVector : public cNoncopyableOwnedObject
{
  protected:
    enum {
      FL_ENABLED = 4,      // flag: when false, record() method will do nothing
      FL_RECORDWARMUP = 8, // flag: when set, object records data during warmup period as well
    };
 
    opp_string_map attributes; // collects vector attributes until registration
    void *handle = nullptr;   // identifies output vector for the output vector manager
    simtime_t lastTimestamp;  // last timestamp written, needed to ensure increasing timestamp order
    long numReceived = 0;     // total number of values passed to the output vector object
    long numStored = 0;       // number of values actually stored
 
    // the following members will be used directly by inspectors
    RecordFunc recordInInspector = nullptr; // to notify inspector about file writes
    void *dataForInspector;
 
  public:
    // internal: called from behind cEnvir
    void setCallback(RecordFunc f, void *d) {recordInInspector=f; dataForInspector=d;}
 
  public:
    enum Type { TYPE_INT, TYPE_DOUBLE, TYPE_ENUM };
    enum InterpolationMode { NONE, SAMPLE_HOLD, BACKWARD_SAMPLE_HOLD, LINEAR };
 
  protected:
    virtual void ensureRegistered();
 
  public:
    explicit cOutVector(const char *name=nullptr);
 
    explicit cOutVector(const char *name, const opp_string_map& attributes);
 
    virtual ~cOutVector();
 
 
    virtual void setName(const char *name) override;
 
    virtual std::string str() const override;
 
 
    virtual void setAttributes(const opp_string_map& attributes);
 
    virtual void setAttribute(const char *name, const char *value);
 
    virtual void registerVector();
 
    virtual void setEnum(const char *registeredEnumName);
 
    virtual void setEnum(cEnum *enumDecl);
 
    virtual void setUnit(const char *unit);
 
    virtual void setType(Type type);
 
    virtual void setInterpolationMode(InterpolationMode mode);
 
    virtual void setMin(double minValue);
 
    virtual void setMax(double maxValue);
 
    virtual bool record(double value);
 
    virtual bool record(SimTime value)  {return record(value.dbl());}
 
    virtual bool recordWithTimestamp(simtime_t t, double value);
 
    virtual bool recordWithTimestamp(simtime_t t, SimTime value) {return recordWithTimestamp(t, value.dbl());}
 
    virtual void enable()  {setFlag(FL_ENABLED,true);}
 
    virtual void disable()  {setFlag(FL_ENABLED,false);}
 
    virtual void setEnabled(bool b)  {setFlag(FL_ENABLED,b);}
 
    virtual bool isEnabled() const  {return flags&FL_ENABLED;}
 
    virtual void setRecordDuringWarmupPeriod(bool b)  {setFlag(FL_RECORDWARMUP,b);}
 
    virtual bool getRecordDuringWarmupPeriod() const  {return flags&FL_RECORDWARMUP;}
 
    long getValuesReceived() const  {return numReceived;}
 
    long getValuesStored() const  {return numStored;}
};
 
}  // namespace omnetpp
 
 
#endif