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() throw(nidas::util::IOException);

    SampleScanner* buildSampleScanner()
        throw(nidas::util::InvalidParameterException);

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

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

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

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

    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)
    {
        throw nidas::util::IOException(getName(),
        "startPrompting","not supported");
    }

    virtual void stopPrompting() throw(nidas::util::IOException)
    {
        throw nidas::util::IOException(getName(),
        "stopPrompting","not supported");
    }

    virtual void togglePrompting() throw(nidas::util::IOException)
    {
    if (isPrompting()) stopPrompting();
    else startPrompting();
    }

    void setInitString(const std::string& val) { _initString = val; }

    const std::string& getInitString() const { return _initString; }

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

    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() throw(nidas::util::InvalidParameterException);

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

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

    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