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(const nidas::util::Inet4Address& addr) const;

    const DSMConfig* findDSM(unsigned int id) const;

    const DSMConfig* findDSM(const std::string& name) const;

    DSMSensor* findSensor(unsigned int id) const;

    void initSensors() throw(nidas::util::IOException);

    void initSensors(DSMConfig* dsm) throw(nidas::util::IOException);

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

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

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