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)
        throw(nidas::util::InvalidParameterException)
    {
        _rate = val;
    }

    virtual double getRate() const { return _rate; }

    virtual void setPeriod(double val)
        throw(nidas::util::InvalidParameterException)
    {
        _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)
        throw(nidas::util::InvalidParameterException)
    {
        _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)
        throw(nidas::util::InvalidParameterException);

    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*)
        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);

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