DSMSensor.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
 **
 ** 2004, 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_DSMSENSOR_H
#define NIDAS_CORE_DSMSENSOR_H

#include "SampleClient.h"
#include "SampleSourceSupport.h"
#include "SampleScanner.h"
#include "SampleTag.h"
#include "IODevice.h"
#include "DOMable.h"
#include "Dictionary.h"
#include "VariableIndex.h"

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

#include <xmlrpcpp/XmlRpc.h>

#include <string>
#include <list>

#include <fcntl.h>

namespace nidas { namespace core {

class DSMConfig;
class Parameter;
class CalFile;
class Looper;

class DSMSensor : public SampleSource, public SampleClient, public DOMable
{

public:

    DSMSensor();

    virtual ~DSMSensor();

    void setDSMConfig(const DSMConfig* val);

    const DSMConfig* getDSMConfig() const
    {
        return _dsm;
    }

    const Site* getSite() const;

    virtual void setDeviceName(const std::string& val)
    {
       _devname = val;
    }

    virtual const std::string& getDeviceName() const
    {
    return _devname;
    }

    virtual void setClassName(const std::string& val)
    {
        _className = val;
    }

    virtual const std::string& getClassName() const
    {
        return _className;
    }

    virtual void setCatalogName(const std::string& val)
    {
        _catalogName = val;
    }

    virtual const std::string& getCatalogName() const
    {
        return _catalogName;
    }

    const std::string& getDSMName() const;

    virtual std::string getName() const
    {
        return getDSMName() + ':' + getDeviceName();
    }

    const std::string& getLocation() const;

    void setLocation(const std::string& val) { _location = val; }

    const std::string& getSuffix() const { return _suffix; }

    void setSuffix(const std::string& val);

    int getStation() const 
    {
        return _station;
    }

    void setStation(int val);

    void setHeight(const std::string& val);

    void setHeight(float val);

    const std::string& getHeightString() const { return _heightString; }

    float getHeight() const { return _height; }

    void setDepth(const std::string& val);

    void setDepth(float val);

    const std::string& getDepthString() const { return _depthString; }

    float getDepth() const { return -_height; }

    const std::string& getFullSuffix() const { return _fullSuffix; }

    std::string expandString(const std::string& input) const
    {
        return _dictionary.expandString(input);
    }

    bool getTokenValue(const std::string& token,std::string& value) const
    {
        return _dictionary.getTokenValue(token,value);
    }

    const Dictionary& getDictionary() const
    {
        return _dictionary;
    }

    SampleSource* getRawSampleSource()
    {
        return &_rawSource;
    }

    SampleSource* getProcessedSampleSource()
    {
        return this;
    }

    const SampleTag* getRawSampleTag() const
    {
        return &_rawSampleTag;
    }

    virtual void addSampleTag(SampleTag* val)
        throw(nidas::util::InvalidParameterException);

    virtual void removeSampleTag(SampleTag* val) throw();

    std::list<const SampleTag*> getSampleTags() const
    {
        return _source.getSampleTags();
    }

    std::list<SampleTag*>& getSampleTags()
    {
        return _sampleTags;
    }

    SampleTagIterator getSampleTagIterator() const
    {
        return SampleTagIterator(this);
    }

    void addSampleClient(SampleClient* c) throw()
    {
        return _source.addSampleClient(c);
    }

    void removeSampleClient(SampleClient* c) throw()
    {
        return _source.removeSampleClient(c);
    }

    void addSampleClientForTag(SampleClient* client,const SampleTag* tag) throw()
    {
        return _source.addSampleClientForTag(client,tag);
    }

    void removeSampleClientForTag(SampleClient* client,const SampleTag* tag) throw()
    {
        return _source.removeSampleClientForTag(client,tag);
    }

    int getClientCount() const throw()
    {
        return _source.getClientCount();
    }

    void flush() throw() {}

    void distributeRaw(const Sample* s) throw()
    {
        _rawSource.distribute(s);
    }

    const SampleStats& getSampleStats() const
    {
        return _source.getSampleStats();
    }

    virtual int getReadFd() const
    {
    if (_iodev) return _iodev->getReadFd();
    return -1;
    }

    virtual int getWriteFd() const
    {
    if (_iodev) return _iodev->getWriteFd();
    return -1;
    }

    virtual bool reopenOnIOException() const { return true; }

    void setId(dsm_sample_id_t val) { _id = SET_FULL_ID(_id,val); }
    void setSensorId(unsigned int val) { _id = SET_SPS_ID(_id,val); }
    void setDSMId(unsigned int val) { _id = SET_DSM_ID(_id,val); }

    dsm_sample_id_t  getId()      const { return GET_FULL_ID(_id); }
    unsigned int getDSMId()   const { return GET_DSM_ID(_id); }
    unsigned int getSensorId() const { return GET_SPS_ID(_id); }

    virtual void setLatency(float val)
        throw(nidas::util::InvalidParameterException)
    {
        _latency = val;
    }

    virtual float getLatency() const { return _latency; }

    virtual void setTimeoutMsecs(int val)
    {
        _timeoutMsecs = val;
    }

    virtual int getTimeoutMsecs() const
    {
        return _timeoutMsecs;
    }

    int getTimeoutCount() const
    {
        return _nTimeouts;
    }

    void incrementTimeoutCount()
    {
        _nTimeouts++;
    }

    void addParameter(Parameter* val);

    const std::list<const Parameter*>& getParameters() const
    {
    return _constParameters;
    }

    const Parameter* getParameter(const std::string& name) const;

    virtual IODevice* buildIODevice() throw(nidas::util::IOException) = 0;

    void setIODevice(IODevice* val)
    {
        _iodev = val;
    }

    virtual SampleScanner* buildSampleScanner()
        throw(nidas::util::InvalidParameterException) = 0;

    void setSampleScanner(SampleScanner* val)
    {
        _scanner = val;
    }

    virtual void validate() throw(nidas::util::InvalidParameterException);

    virtual void open(int flags)
        throw(nidas::util::IOException,nidas::util::InvalidParameterException);

    virtual void init() throw(nidas::util::InvalidParameterException);

    virtual int getDefaultMode() const
    {
        return _defaultMode;
    }

    virtual void setDefaultMode(int val)
    {
        _defaultMode = val;
    }

    virtual size_t getBytesAvailable() const
        throw(nidas::util::IOException)
    {
        return _iodev->getBytesAvailable();
    }

    virtual size_t read(void *buf, size_t len)
        throw(nidas::util::IOException)
    {
        return _iodev->read(buf,len);
    }

    virtual size_t read(void *buf, size_t len,int msecTimeout)
        throw(nidas::util::IOException)
    {
        return _iodev->read(buf,len,msecTimeout);
    }

    virtual size_t write(const void *buf, size_t len)
        throw(nidas::util::IOException)
    {
        return _iodev->write(buf,len);
    }

    virtual void ioctl(int request, void* buf, size_t len)
        throw(nidas::util::IOException)
    {
        _iodev->ioctl(request,buf,len);
    }

    virtual void close() throw(nidas::util::IOException);

    virtual bool readSamples()
        throw(nidas::util::IOException);

    virtual Sample* nextSample()
    {
        return _scanner->nextSample(this);
    }

    virtual Sample* readSample()
        throw(nidas::util::IOException);

    bool receive(const Sample *s) throw();

    virtual bool process(const Sample*,std::list<const Sample*>& result)
        throw() = 0;

    void printStatusHeader(std::ostream& ostr) throw();
    virtual void printStatus(std::ostream&) throw();
    void printStatusTrailer(std::ostream& ostr) throw();

    void calcStatistics(unsigned int periodUsec)
    {
        if (_scanner) _scanner->calcStatistics(periodUsec);
    }

    unsigned int getMaxSampleLength() const
    {
    if (_scanner) return _scanner->getMaxSampleLength();
    return 0;
    }

    unsigned int getMinSampleLength() const
    {
        if (_scanner) return _scanner->getMinSampleLength();
    return 0;
    }

    float getObservedSamplingRate() const
    {
        if (_scanner) return _scanner->getObservedSamplingRate();
    return 0.0;
    }

    float getObservedDataRate() const
    {
        if (_scanner) return _scanner->getObservedDataRate();
    return 0.0;
    }

    size_t getBadTimeTagCount() const
    {
    if (_scanner) return _scanner->getBadTimeTagCount();
    return 0;
    }

    VariableIterator getVariableIterator() const;

    static const std::string getClassName(const xercesc::DOMElement* node,
        const Project* project)
        throw(nidas::util::InvalidParameterException);

    void fromDOMElement(const xercesc::DOMElement*)
        throw(nidas::util::InvalidParameterException);

    xercesc::DOMElement*
        toDOMParent(xercesc::DOMElement* parent,bool complete) const
                throw(xercesc::DOMException);

    xercesc::DOMElement*
        toDOMElement(xercesc::DOMElement* node,bool complete) const
                throw(xercesc::DOMException);

    virtual void setTypeName(const std::string& val)
    {
        _typeName = val;
    }

    virtual const std::string& getTypeName(void) const
    {
        return _typeName;
    }

    bool getDuplicateIdOK() const
    {
        return _duplicateIdOK;
    }

    void setDuplicateIdOK(bool val)
    {
        _duplicateIdOK = val;
    }

    virtual bool getApplyVariableConversions() const
    {
        return _applyVariableConversions;
    }

    virtual void setApplyVariableConversions(bool val)
    {
        _applyVariableConversions = val;
    }

    virtual int getDriverTimeTagUsecs() const
    {
        return _driverTimeTagUsecs;
    }

    virtual void setDriverTimeTagUsecs(int val)
    {
        _driverTimeTagUsecs = val;
    }

    void addCalFile(CalFile* val);

    const std::map<std::string,CalFile*>& getCalFiles()
    {
        return _calFiles;
    }

    CalFile* getCalFile(const std::string& name);

    void removeCalFiles();

    virtual void executeXmlRpc(XmlRpc::XmlRpcValue&, XmlRpc::XmlRpcValue&)
        throw() {}

    static void deleteLooper();

    virtual const std::list<SampleTag*>& getNonConstSampleTags()
    {
        return _sampleTags;
    }


    bool allowOpen()
    {
        return _openable;
    }

    bool readBuffer() throw(nidas::util::IOException)
    {
        bool exhausted;
        _scanner->readBuffer(this,exhausted);
        return exhausted;
    }

    bool readBuffer(int msecTimeout)
       throw(nidas::util::IOException)
    {
        bool exhausted;
        _scanner->readBuffer(this,exhausted, msecTimeout);
        return exhausted;
    }


protected:

    void clearBuffer()
    {
        _scanner->clearBuffer();
    }


    IODevice* getIODevice() const { return _iodev; }

    SampleScanner* getSampleScanner() const { return _scanner; }

    void setFullSuffix(const std::string& val) { _fullSuffix = val; }

    static Looper* getLooper();

    virtual int getLagUsecs() const
    {
        return _lag;
    }
    virtual double getLagSecs() const
    {
        return (double)_lag / USECS_PER_SEC;
    }

    virtual void setLagSecs(double val)
    {
        _lag = (int) rint(val * USECS_PER_SEC);
    }

    void
    applyConversions(SampleTag* stag, SampleT<float>* outs, float* results=0);

    void
    trimUnparsed(SampleTag* stag, SampleT<float>* outs, int nparsed);

    VariableIndex
    findVariableIndex(const std::string& vprefix);

    bool _openable;


private:

    void addSampleTag(const SampleTag* val)
        throw(nidas::util::InvalidParameterException);

    void removeSampleTag(const SampleTag* val) throw();

    std::string _devname;

    class MyDictionary : public Dictionary {
    public:
        MyDictionary(DSMSensor* sensor): _sensor(sensor) {}
        MyDictionary(const MyDictionary& x): Dictionary(),_sensor(x._sensor) {}
        MyDictionary& operator=(const MyDictionary& rhs)
        {
            if (&rhs != this) {
                *(Dictionary*)this = rhs;
                _sensor = rhs._sensor;
            }
            return *this;
        }
        bool getTokenValue(const std::string& token, std::string& value) const;
    private:
        DSMSensor* _sensor;
    } _dictionary;


    IODevice* _iodev;

    int _defaultMode;

    std::string _className;

    std::string _catalogName;

    std::string _suffix;

    std::string _heightString;

    std::string _depthString;

    float _height;

    std::string _fullSuffix;

    std::string _location;

    SampleScanner* _scanner;

    const DSMConfig* _dsm;

    dsm_sample_id_t _id;

    SampleTag _rawSampleTag;

    std::list<SampleTag*> _sampleTags;

    SampleSourceSupport _rawSource;

    SampleSourceSupport _source;

    // toggle flag for zebra striping printStatus
    static bool zebra;

    float _latency;

    std::map<std::string,Parameter*> _parameters;

    std::list<const Parameter*> _constParameters;

    std::map<std::string,CalFile*> _calFiles;

    std::string _typeName;

    int _timeoutMsecs;

    bool _duplicateIdOK;

    bool _applyVariableConversions;

    int _driverTimeTagUsecs;

    int _nTimeouts;

    static Looper* _looper;

    static nidas::util::Mutex _looperMutex;

    int _lag;

    int _station;

private:

    // no copying
    DSMSensor(const DSMSensor& x);

    // no assignment
    DSMSensor& operator=(const DSMSensor& x);

};

}}  // namespace nidas namespace core

#endif