SampleScanner.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
#ifndef NIDAS_CORE_SAMPLESCANNER_H
#define NIDAS_CORE_SAMPLESCANNER_H

#include "SampleClock.h"

#include <nidas/util/IOException.h>
#include <nidas/util/InvalidParameterException.h>

namespace nidas { namespace core {

class DSMSensor;

class SampleScanner
{
public:

    SampleScanner(int bufsize=8192);

    virtual ~SampleScanner();

    virtual void init();

    virtual void setMessageParameters(unsigned int len, const std::string& val, bool eom)
        throw(nidas::util::InvalidParameterException) = 0;

    virtual const std::string& getMessageSeparator() const 
    {
        return _emptyString;
    }

    virtual const std::string getBackslashedMessageSeparator() const
    {
    return _emptyString; 
    }

    virtual bool getMessageSeparatorAtEOM() const
    {
        return false;
    }

    virtual unsigned int getMessageLength() const
    {
        return 0;
    }

    virtual bool getNullTerminate()  const
    {
        return false;
    }

    void setUsecsPerByte(int val)
    {
        _usecsPerByte = val;
    }

    int getUsecsPerByte() const
    {
        return _usecsPerByte;
    }

    virtual size_t readBuffer(DSMSensor* sensor, bool& exhausted)
        throw(nidas::util::IOException);

    virtual size_t readBuffer(DSMSensor* sensor, bool& exhausted,int msecTimeout)
        throw(nidas::util::IOException);

    virtual void clearBuffer();

    virtual Sample* nextSample(DSMSensor* sensor) = 0;

    unsigned int getBytesInBuffer() const { return _bufhead - _buftail; }

    virtual void resetStatistics();

    virtual void calcStatistics(unsigned int periodUsec);

    unsigned int getMaxSampleLength() const
        { return _maxSampleLength[_reportIndex]; }

    unsigned int getMinSampleLength() const
    { 
        // if max is 0 then we haven't gotten any data
        if (_maxSampleLength[_reportIndex] == 0) return 0;
        return _minSampleLength[_reportIndex];
    }

    unsigned int getBadTimeTagCount() const
    {
    return _badTimeTags;
    }

    float getObservedSamplingRate() const;

    float getObservedDataRate() const;

    void addNumBytesToStats(size_t val) { _nbytes += val; }

    void addSampleToStats(unsigned int val)
    {
    _nsamples++;
        _minSampleLength[_currentIndex] =
        std::min(_minSampleLength[_currentIndex],val);
        _maxSampleLength[_currentIndex] =
        std::max(_maxSampleLength[_currentIndex],val);
    }

    void incrementBadTimeTags()
    {
        _badTimeTags++;
    }

protected:

    const unsigned int BUFSIZE;

    char* _buffer;

    unsigned int _bufhead;

    unsigned int _buftail;

    Sample* _osamp;

    struct dsm_sample _header;

    unsigned int _outSampRead;
 
    unsigned int _outSampToRead;

    char* _outSampDataPtr;

    std::string _messageSeparator;

    int _messageLength;

    bool _separatorAtEOM;

    char* _separator;

    int _separatorLen;

private:

    std::string _emptyString;

    time_t _initialTimeSecs;

    unsigned int _minSampleLength[2];

    unsigned int _maxSampleLength[2];

    int _currentIndex;

    int _reportIndex;

    size_t _nsamples;

    size_t _nbytes;

    unsigned int _badTimeTags;

    float _sampleRateObs;

    float _dataRateObs;

    int _usecsPerByte;

    SampleScanner(const SampleScanner&);

    SampleScanner& operator=(const SampleScanner&);
};

class DriverSampleScanner: public SampleScanner
{
public:

    DriverSampleScanner(int bufsize=8192);

    void setMessageParameters(unsigned int, const std::string&, bool)
        throw(nidas::util::InvalidParameterException)
    {
        throw nidas::util::InvalidParameterException(
        "setMessageSeparator not supported");
    }

    Sample* nextSample(DSMSensor* sensor);

private:

};

class MessageSampleScanner: public DriverSampleScanner
{
public:
    
    MessageSampleScanner(int bufsize=8192);

    void setMessageParameters(unsigned int len, const std::string& val, bool eom)
        throw(nidas::util::InvalidParameterException);

    const std::string& getMessageSeparator() const
    {
        return _messageSeparator;
    }

    const std::string getBackslashedMessageSeparator() const;

    bool getMessageSeparatorAtEOM() const
    {
        return _separatorAtEOM; 
    }

    unsigned int getMessageLength() const
    {
        return _messageLength;
    }

private:

};

class MessageStreamScanner: public SampleScanner
{
public:
    
    MessageStreamScanner(int bufsize=4096);

    void setMessageParameters(unsigned int len, const std::string& val, bool eom)
        throw(nidas::util::InvalidParameterException);

    const std::string& getMessageSeparator() const
    {
        return _messageSeparator;
    }

    const std::string getBackslashedMessageSeparator() const;

    bool getMessageSeparatorAtEOM() const
    {
        return _separatorAtEOM; 
    }

    unsigned int getMessageLength() const
    {
        return _messageLength;
    }

    void setNullTerminate(bool val) 
    {
        _nullTerminate = val;
    }

    bool getNullTerminate()  const
    {
        return _nullTerminate;
    }

    Sample* nextSample(DSMSensor* sensor)
    {
        return (this->*_nextSampleFunc)(sensor);
    }

    size_t readBuffer(DSMSensor* sensor, bool& exhausted)
        throw(nidas::util::IOException);

    size_t readBuffer(DSMSensor* sensor, bool& exhausted,int msecTimeout)
        throw(nidas::util::IOException);

    void warnNonIncrTimeTag(const DSMSensor *sensor,
        dsm_time_t badtt, dsm_time_t cortt, unsigned int nbad);

    void warnBackwardsStepTimeTag( const DSMSensor *sensor,
            dsm_time_t badtt, unsigned int nbad);

protected:

    virtual Sample* nextSampleSepBOM(DSMSensor* sensor);

    virtual Sample* nextSampleSepEOM(DSMSensor* sensor);

    Sample* nextSampleByLength(DSMSensor* sensor);

    /* ptr to setXXX member function for setting an attribute of this
     * class, based on the value of the tag from the IOStream.
     */
    Sample* (MessageStreamScanner::* _nextSampleFunc)(DSMSensor*);

    Sample* requestBiggerSample(unsigned int nc);

protected:

    dsm_time_t _tfirstchar;

    dsm_time_t _lastBufferTime;

    dsm_time_t _lastSampleTime;

    const unsigned int MAX_MESSAGE_STREAM_SAMPLE_SIZE;

    int _separatorCnt;

    dsm_time_t _bomtt;

    int _sampleOverflows;

    unsigned int _sampleLengthAlloc;

    bool _nullTerminate;

    int _nsmallSamples;
    
    unsigned int _outSampLengthAlloc;

    bool _stepBackwards;

    unsigned int _stepBackTimeTag;

    unsigned int _nonIncrTimeTag;

};

class DatagramSampleScanner: public SampleScanner
{
public:
    
    DatagramSampleScanner(int bufsize=16384);

    void setMessageParameters(unsigned int, const std::string&, bool)
        throw(nidas::util::InvalidParameterException)
    {
        throw nidas::util::InvalidParameterException(
        "setMessageParameters not supported");
    }

    size_t readBuffer(DSMSensor* sensor, bool& exhausted)
        throw(nidas::util::IOException);

    Sample* nextSample(DSMSensor* sensor);

    void setNullTerminate(bool val) 
    {
        _nullTerminate = val;
    }

    bool getNullTerminate()  const
    {
        return _nullTerminate;
    }


private:
    std::list<int> _packetLengths;

    std::list<dsm_time_t> _packetTimes;

    bool _nullTerminate;

};

}}  // namespace nidas namespace core

#endif