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) = 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);
 
    virtual size_t readBuffer(DSMSensor* sensor, bool& exhausted, int msecTimeout);
 
    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(
        "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);
 
    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);
 
    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);
 
    size_t readBuffer(DSMSensor* sensor, bool& exhausted,int msecTimeout);
 
    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(
        "setMessageParameters not supported");
    }
 
    size_t readBuffer(DSMSensor* sensor, bool& exhausted);
 
    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