Site.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_SITE_H
#define NIDAS_CORE_SITE_H
 
#include "DOMable.h"
#include "DSMConfig.h"
#include "Parameter.h"
#include "Dictionary.h"
 
#include <list>
#include <map>
 
namespace nidas { namespace core {
 
class Project;
class DSMServer;
class DSMConfig;
class DSMSensor;
 
class Site : public DOMable {
public:
    Site();
 
    virtual ~Site();
 
    void setName(const std::string& val) { _name = val; }
 
    const std::string& getName() const { return _name; }
 
    void setNumber(int val) { _number = val; }
 
    int getNumber() const { return _number; }
 
    bool operator == (const Site& x) const
    {
        if (this == &x) return true;
        return _name == x._name &&
            _suffix == x._suffix &&
            _number == x._number;
    }
 
    bool operator != (const Site& x) const
    {
        return !operator == (x);
    }
 
    bool operator < (const Site& x) const
    {
        if (operator == (x)) return false;
        return _name.compare(x._name) < 0;
    }
 
    void setSuffix(const std::string& val) { _suffix = val; }
 
    const std::string& getSuffix() const { return _suffix; }
 
    const Project* getProject() const { return _project; }
 
    Project* getProject() { return _project; }
 
    void setProject(Project* val) { _project = val; }
 
    void addDSMConfig(DSMConfig* dsm)
    {
        _dsms.push_back(dsm);
        _ncDsms.push_back(dsm);
    }
 
    void removeDSMConfig(DSMConfig* dsm)
    {
        std::list<const DSMConfig*>::iterator di;
        for (di = _dsms.begin(); di != _dsms.end(); ) 
            if (dsm == *di) di = _dsms.erase(di);
            else ++di;
        for (std::list<DSMConfig*>::iterator di = _ncDsms.begin();
             di != _ncDsms.end(); )
            if (dsm == *di) {
                DSMConfig* deletableDSMConfig =  *di;
                di = _ncDsms.erase(di);
                // The DSM configuration has been removed from both lists, now delete the object.
                delete deletableDSMConfig;
            }
            else ++di;
    }
 
    const std::list<const DSMConfig*>& getDSMConfigs() const
    {
        return _dsms;
    }
 
    const std::list<DSMConfig*>& getDSMConfigs()
    {
        return _ncDsms;
    }
 
    void addServer(DSMServer* srvr) { _servers.push_back(srvr); }
 
    const std::list<DSMServer*>& getServers() const { return _servers; }
 
    DSMServer* findServer(const std::string& hostname) const;
 
    const DSMConfig* findDSM(unsigned int id) const;
 
    const DSMConfig* findDSM(const std::string& name) const;
 
    DSMSensor* findSensor(unsigned int id) const;
 
    void initSensors();
 
    void initSensors(DSMConfig* dsm);
 
    virtual void addParameter(Parameter* val);
 
    virtual const Parameter* getParameter(const std::string& name) const;
 
    virtual const std::list<const Parameter*>& getParameters() const;
 
    virtual bool getApplyVariableConversions() const
    {
        return _applyCals;
    }
 
    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;
    }
 
    DSMServerIterator getDSMServerIterator() const;
 
    DSMServiceIterator getDSMServiceIterator() const;
 
    ProcessorIterator getProcessorIterator() const;
 
    DSMConfigIterator getDSMConfigIterator() const;
 
    SensorIterator getSensorIterator() const;
 
    SampleTagIterator getSampleTagIterator() const;
 
    VariableIterator getVariableIterator() const;
 
    void validate();
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    xercesc::DOMElement*
    toDOMParent(xercesc::DOMElement* parent, bool complete) const;
 
    xercesc::DOMElement*
    toDOMElement(xercesc::DOMElement* node, bool complete) const;
 
private:
 
    Project* _project;
    
    std::string _name;
 
    int _number;
 
    std::string _suffix;
 
    class MyDictionary : public Dictionary {
    public:
        MyDictionary(Site* site): _site(site) {}
        MyDictionary(const MyDictionary& x): Dictionary(),_site(x._site) {}
        MyDictionary& operator=(const MyDictionary& rhs)
        {
            if (&rhs != this) {
                *(Dictionary*) this = rhs;
                _site = rhs._site;
            }
            return *this;
        }
        bool getTokenValue(const std::string& token, std::string& value) const;
    private:
        Site* _site;
    } _dictionary;
 
    std::list<const DSMConfig*> _dsms;
 
    std::list<DSMConfig*> _ncDsms;
 
    std::list<DSMServer*> _servers;
 
    std::map<std::string,Parameter*> _parameterMap;
 
    std::list<const Parameter*> _constParameters;
 
    Site(const Site&);
 
    Site& operator=(const Site&);
 
protected:
    bool _applyCals;
 
};
 
}}  // namespace nidas namespace core
 
#endif