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);
 
    virtual void removeSampleTag(SampleTag* val);
 
    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() {}
 
    void distributeRaw(const Sample* s)
    {
        _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)
    {
        _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() = 0;
 
    void setIODevice(IODevice* val)
    {
        _iodev = val;
    }
 
    virtual SampleScanner* buildSampleScanner() = 0;
 
    void setSampleScanner(SampleScanner* val)
    {
        _scanner = val;
    }
 
    virtual void validate();
 
    virtual void open(int flags);
 
    virtual void init();
 
    virtual int getDefaultMode() const
    {
        return _defaultMode;
    }
 
    virtual void setDefaultMode(int val)
    {
        _defaultMode = val;
    }
 
    virtual size_t getBytesAvailable() const
    {
        return _iodev->getBytesAvailable();
    }
 
    virtual size_t read(void *buf, size_t len)
    {
        return _iodev->read(buf,len);
    }
 
    virtual size_t read(void *buf, size_t len,int msecTimeout)
    {
        return _iodev->read(buf,len,msecTimeout);
    }
 
    virtual size_t write(const void *buf, size_t len)
    {
        return _iodev->write(buf,len);
    }
 
    virtual void ioctl(int request, void* buf, size_t len)
    {
        _iodev->ioctl(request,buf,len);
    }
 
    virtual void close();
 
    virtual bool readSamples();
 
    virtual Sample* nextSample()
    {
        return _scanner->nextSample(this);
    }
 
    virtual Sample* readSample();
 
    bool receive(const Sample *s);
 
    virtual bool process(const Sample*,std::list<const Sample*>& result) = 0;
 
    void printStatusHeader(std::ostream& ostr);
    virtual void printStatus(std::ostream&);
    void printStatusTrailer(std::ostream& ostr);
 
    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);
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    xercesc::DOMElement*
    toDOMParent(xercesc::DOMElement* parent, bool complete) const;
 
    xercesc::DOMElement*
    toDOMElement(xercesc::DOMElement* node, bool complete) const;
 
    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&)
    {}
 
    static void deleteLooper();
 
    virtual const std::list<SampleTag*>& getNonConstSampleTags()
    {
        return _sampleTags;
    }
 
 
    bool allowOpen()
    {
        return _openable;
    }
 
    bool readBuffer()
    {
        bool exhausted;
        _scanner->readBuffer(this,exhausted);
        return exhausted;
    }
 
    bool readBuffer(int msecTimeout)
    {
        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);
 
    void removeSampleTag(const SampleTag* val);
 
    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