LinearApproxLogWriter.h

Go to the documentation of this file.

#ifndef LINEARAPPROXLOGWRITER_H_
#define LINEARAPPROXLOGWRITER_H_

#include "logger/EventEntry.h"
#include "logger/Logger.h"
#include "logger/DecimationLogWriter.h"
#include "utils/FlexArray.h"

class DataEntry;
class DataValue;
class ElementURI;
class LogEntry;
class SyslogEntry;

class LinearApproxLogWriter : public DecimationLogWriter
{
public:

    LinearApproxLogWriter( LogWriter& outputTo, const Str& varName, DataValue* approxErrorValue,
                           bool makeDirEntries, Logger& logger );

    virtual ~LinearApproxLogWriter();

    virtual unsigned int write( const LogEntry *entry, const Unit* unit = NULL );

    virtual unsigned int writeHeader();

    virtual void endCycle()
    {
        outputTo_.endCycle();
    }

    virtual void config( Logger& logger )
    {
        outputTo_.config( logger );
    }

    virtual unsigned int writeFooter();

    virtual void setParameter( DataValue* approxError, Logger& logger );

    virtual unsigned int flush();

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    LinearApproxLogWriter( const LinearApproxLogWriter& old ); // disallow copy constructor

    friend class Supervisor;

    class VarData
    {
    public:
        VarData( const DataEntry* startEntry, float approxError );
        ~VarData();

        DataEntry* getDataEntry()
        {
            return dataEntry_;
        }

        float getDeltaT( const Timestamp timestamp );

        void advance();

        // Returns whether due to deliver next output
        bool checkNextEntry( const DataEntry* nextEntry );

        bool isReady()
        {
            return ready_;
        }

        bool wasNaN()
        {
            return wasNaN_;
        }

        float getApproxError()
        {
            return approxError_;
        }

        void setApproxError( float approxError )
        {
            approxError_ = approxError;
        }

        bool flushed()
        {
            return startTime_ == endTime_ && endTime_ == nextTime_;
        }

    private:
        // Note that the copy constructor below is private and not given a body.
        // Any attempt to call it will return a compiler error.
        VarData( const VarData& old ); // disallow copy constructor

        DataEntry* dataEntry_;
        DataValue* dataValue_;
        const Unit& unit_;
        float approxError_;
        float minUpperSlope_;
        float maxLowerSlope_;
        double startValue_;
        double endValue_;
        double nextValue_;
        Timestamp startTime_;
        Timestamp endTime_;
        Timestamp nextTime_;
        bool ready_;
        bool wasNaN_;
    };

    unsigned int sendOutput( DataEntry* dataEntry );

    const Str varName_;
    DataValue* approxErrorValue_;

    LinearApproxLogWriter::VarData* varData_;

    EventEntry cycleStartEntry_;
    Timestamp lastTime_;

};

#endif /*LINEARAPPROXLOGWRITER_H_*/