CharacterSensor.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_CHARACTERSENSOR_H
#define NIDAS_CORE_CHARACTERSENSOR_H
 
#include "DSMSensor.h"
#include "Prompt.h"
#include <nidas/util/util.h>
 
namespace nidas { namespace core {
 
class AsciiSscanf;
class Sample;
class TimetagAdjuster;
 
class CharacterSensor: public DSMSensor {
 
public:
 
    CharacterSensor();
 
    virtual ~CharacterSensor();
 
    IODevice* buildIODevice();
 
    SampleScanner* buildSampleScanner();
 
    void open(int flags);
 
    void validate();
 
    void init();
 
    virtual void setMessageParameters(unsigned int length, const std::string& val,
                                      bool eom);
 
    const std::string& getMessageSeparator() const
    {
    return _messageSeparator;
    }
 
    const std::string getBackslashedMessageSeparator() const
    {
        return nidas::util::addBackslashSequences(_messageSeparator);
    }
 
    bool getMessageSeparatorAtEOM() const
    {
        return _separatorAtEOM;
    }
 
    int getMessageLength() const
    {
    return _messageLength;
    }
 
    virtual void addPrompt(const std::string& promptString, double promptRate,
            double promptOffset)
    {
        Prompt prompt;
        prompt.setString(promptString);
        prompt.setRate(promptRate);
        prompt.setOffset(promptOffset);
 
        _prompts.push_back(prompt);
        _prompted = true;
//cerr<< "pushed back prompt.  String = "<<promptString<<" rate= "<<promptRate;
    }
 
    const std::list<Prompt>& getPrompts() const { return _prompts;}
 
    virtual bool isPrompted() const { return _prompted; }
 
    virtual bool isPrompting() const { return false; }
 
    virtual void startPrompting()
    {
        throw nidas::util::IOException(getName(),
        "startPrompting","not supported");
    }
 
    virtual void stopPrompting()
    {
        throw nidas::util::IOException(getName(),
        "stopPrompting","not supported");
    }
 
    virtual void togglePrompting()
    {
        if (isPrompting()) stopPrompting();
        else startPrompting();
    }
 
    void setInitString(const std::string& val) { _initString = val; }
 
    const std::string& getInitString() const { return _initString; }
 
    virtual void sendInitString();
 
    bool getNullTerminated() const
    {
        if (!getSampleScanner()) return false;
        return getSampleScanner()->getNullTerminate();
    }
 
    int getNumScanfFailures() const {
        return _scanfFailures;
    }
 
    int getNumScanfPartials() const {
        return _scanfPartials;
    }
 
    const std::list<AsciiSscanf*>& getScanfers() const
    {
        return _sscanfers;
    }
 
    int getMaxScanfFields() const { return _maxScanfFields; }
 
    virtual void validateSscanfs();
 
    virtual bool process(const Sample*,std::list<const Sample*>& result);
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    bool doesAsciiSscanfs();
 
protected:
 
    void setPromptRate(const double val) {_promptRate = val;}
 
    double getPromptRate() const { return (_promptRate);}
 
    void setPromptOffset(const double val) {_promptOffset = val;}
 
    double getPromptOffset()const { return (_promptOffset);}
 
    void setPromptString(const std::string& val) { _promptString = val; }
 
    const std::string& getPromptString() const { return (_promptString);}
 
    virtual int scanSample(AsciiSscanf* sscanf, const char* inputstr,
               float* data_ptr);
 
    SampleT<float>*
    searchSampleScanners(const Sample* samp, SampleTag** stag_out=0) throw();
 
    void
    adjustTimeTag(SampleTag* stag, SampleT<float>* outs);
 
    std::map<const SampleTag*, TimetagAdjuster*> _ttadjusters;
 
private:
 
    std::string _messageSeparator;
 
    bool _separatorAtEOM;
 
    int _messageLength;
 
    std::list<Prompt> _prompts;
 
    std::string _promptString;
 
    double _promptRate;
 
    double _promptOffset;
 
    std::list<AsciiSscanf*> _sscanfers;
 
    std::list<AsciiSscanf*>::const_iterator _nextSscanfer;
 
    int _maxScanfFields;
 
    int _scanfFailures;
 
    int _scanfPartials;
 
    bool _prompted;
 
    std::string _initString;
 
    std::string _emptyString;
 
    CharacterSensor(const CharacterSensor&);
 
    CharacterSensor& operator=(const CharacterSensor&);
 
};
 
}}  // namespace nidas namespace core
 
#endif