SampleTag.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
 **
 ** 2005, 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_SAMPLETAG_H
#define NIDAS_CORE_SAMPLETAG_H
 
#include "DOMable.h"
#include "Sample.h"
#include "NidsIterators.h"
 
#include <vector>
#include <list>
#include <algorithm>
 
namespace nidas { namespace core {
 
class DSMConfig;
class Variable;
class Parameter;
 
class SampleTag : public DOMable
{
 
public:
 
    SampleTag();
 
    SampleTag(const DSMSensor* sensor);
 
    SampleTag(const SampleTag&);
 
    virtual ~SampleTag();
 
    SampleTag& operator=(const SampleTag& rhs);
 
    void setSampleId(unsigned int val) {
    _sampleId = val;
        _id = SET_SPS_ID(_id,_sensorId + _sampleId);
    }
 
    unsigned int getSampleId() const { return _sampleId; }
 
    void setSensorId(unsigned int val) {
        _sensorId = val;
        _id = SET_SPS_ID(_id,_sensorId + _sampleId);
    }
 
    unsigned int getSensorId() const { return _sensorId; }
 
    void setDSMId(unsigned int val) { _id = SET_DSM_ID(_id,val); }
 
    unsigned int getDSMId() const { return GET_DSM_ID(_id); }
 
    dsm_sample_id_t getId()      const { return GET_FULL_ID(_id); }
 
    unsigned int getSpSId() const { return GET_SPS_ID(_id); }
 
    const std::string& getSuffix() const { return _suffix; }
 
    void setSuffix(const std::string& val);
 
    const DSMConfig* getDSMConfig() const { return _dsm; }
 
    void setDSMConfig(const DSMConfig* val) { _dsm = val; }
 
    const DSMSensor* getDSMSensor() const { return _sensor; }
 
    void setDSMSensor(const DSMSensor* val);
 
    int getStation() const { return _station; }
 
    void setStation(int val);
 
    const Site* getSite() const;
 
    virtual void setRate(double val)
    {
        _rate = val;
    }
 
    virtual double getRate() const { return _rate; }
 
    virtual void setPeriod(double val)
    {
        _rate = (val > 0.0) ? 1.0 / val : 0.0;
    }
 
    virtual double getPeriod() const
    {
 
    return (_rate > 0.0) ?  1.0 / _rate : 0.0;
    }
 
    void setProcessed(bool val)
    {
        _processed = val;
    }
    bool isProcessed() const { return _processed; };
 
    void setScanfFormat(const std::string& val)
    {
        _scanfFormat = val;
    }
 
    const std::string& getScanfFormat() const { return _scanfFormat; }
 
    void setPromptString(const std::string& val)
    {
        _promptString = val;
    }
 
    const std::string& getPromptString() const { return _promptString; }
 
    void setPromptOffset(double val)
    {
        _promptOffset = val;
    }
 
    double getPromptOffset() const { return _promptOffset; }
 
    virtual void addVariable(Variable* var);
 
    const std::vector<const Variable*>& getVariables() const;
 
    const std::vector<Variable*>& getVariables()
    {
        return _variables;
    }
 
    void removeVariable(const Variable* var);
 
    Variable& getVariable(int i) { return *_variables[i]; }
 
    void addParameter(Parameter* val);
 
    const std::list<const Parameter*>& getParameters() const
    {
        return _constParameters;
    }
 
    const Parameter* getParameter(const std::string& name) const;
 
    void setEnabled(bool val) { _enabled = val; }
    bool isEnabled() const { return _enabled; }
 
    unsigned int getDataIndex(const Variable* var) const;
 
    float getTimetagAdjust() const { return _ttAdjustVal; }
 
    void setTimetagAdjust(float val) { _ttAdjustVal = val; }
 
    VariableIterator getVariableIterator() const;
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    xercesc::DOMElement*
    toDOMParent(xercesc::DOMElement* parent,bool complete) const;
 
    xercesc::DOMElement*
    toDOMElement(xercesc::DOMElement* node,bool complete) const;
 
protected:
 
    void setId(dsm_sample_id_t val) { _id = SET_FULL_ID(_id,val); }
 
    void setSpSId(unsigned int val) { _id = SET_SPS_ID(_id,val); }
 
private:
 
    dsm_sample_id_t _id;
 
    unsigned int _sampleId;
 
    unsigned int _sensorId;
 
    std::string _suffix;
 
    int _station;
 
    double _rate;
 
    bool _processed;
 
    const DSMConfig* _dsm;
 
    const DSMSensor* _sensor;
 
    std::vector<const Variable*> _constVariables;
 
    std::vector<Variable*> _variables;
 
    std::vector<std::string> _variableNames;
 
    std::string _scanfFormat;
 
    std::string _promptString;
 
    double _promptOffset;
 
    std::list<Parameter*> _parameters;
 
    std::list<const Parameter*> _constParameters;
 
    bool _enabled;
 
    float _ttAdjustVal;
 
};
 
}}  // namespace nidas namespace core
 
#endif