Project.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
 **
 ** 2004, 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_PROJECT_H
#define NIDAS_CORE_PROJECT_H
 
#include "DOMable.h"
#include "Sample.h"
#include "NidsIterators.h"
#include "Dictionary.h"
#include "Datasets.h"
#include <nidas/util/ThreadSupport.h>
#include <nidas/util/Inet4Address.h>
#include <nidas/util/IOException.h>
 
#include <list>
#include <set>
#include <map>
 
#define ACCESS_AS_SINGLETON
 
namespace nidas { namespace core {
 
class Site;
class DSMServer;
class DSMConfig;
class DSMSensor;
class SampleTag;
class SensorCatalog;
class DSMCatalog;
class ServiceCatalog;
class FileSet;
class Parameter;
 
class Project : public DOMable {
public:
 
    Project();
 
    virtual ~Project();
 
    void
    parseXMLConfigFile(const std::string& xmlfilepath);
 
#ifdef ACCESS_AS_SINGLETON
    static Project* getInstance();
 
    static void destroyInstance();
#endif
 
    void setName(const std::string& val) { _name = val; }
    const std::string& getName() const { return _name; }
 
    void setSystemName(const std::string& val) { _sysname = val; }
    const std::string& getSystemName() const { return _sysname; }
 
    void setConfigVersion(const std::string& val) { _configVersion = val; }
    const std::string& getConfigVersion() const { return _configVersion; }
 
    void setConfigName(const std::string& val) { _configName = val; }
    const std::string& getConfigName() const { return _configName; }
 
    void setFlightName(const std::string& val) { _flightName = val; }
 
    const std::string& getFlightName() const;
 
    void addSite(Site* val);
 
    const std::list<Site*>& getSites() const { return _sites; }
 
    int getMaxSiteNumber() const { return _maxSiteNumber; }
 
    int getMinSiteNumber() const { return _minSiteNumber; }
 
    void addServer(DSMServer* srvr) { _servers.push_back(srvr); }
 
    const std::list<DSMServer*>& getServers() const { return _servers; }
 
    std::list<DSMServer*> findServers(const std::string& hostname) const;
 
    DSMServer* findServer(const nidas::util::Inet4Address& addr) const;
 
    const DSMConfig* findDSM(const nidas::util::Inet4Address& addr) const;
 
    const DSMConfig* findDSM(const std::string& name) const;
 
    const DSMConfig* findDSM(unsigned int id) const;
 
    std::list<nidas::core::FileSet*> findServerSampleOutputStreamFileSets(const std::string& name) const;
 
    std::list<nidas::core::FileSet*> findServerSampleOutputStreamFileSets() const;
 
    std::list<nidas::core::FileSet*> findSampleOutputStreamFileSets(
    const std::string& dsmName) const;
 
    std::list<nidas::core::FileSet*> findSampleOutputStreamFileSets() const;
 
    DSMSensor* findSensor(dsm_sample_id_t id) const;
 
    DSMSensor* findSensor(const SampleTag* tag) const;
 
    Site* findSite(int stationNumber) const;
 
    Site* findSite(const std::string& name) const;
 
    dsm_sample_id_t getUniqueSampleId(unsigned int dsmid);
 
    void setSensorCatalog(SensorCatalog* val) { _sensorCatalog = val; }
    SensorCatalog* getSensorCatalog() const { return _sensorCatalog; }
 
    void setDSMCatalog(DSMCatalog* val) { _dsmCatalog = val; }
    DSMCatalog* getDSMCatalog() const { return _dsmCatalog; }
 
    void setServiceCatalog(ServiceCatalog* val) { _serviceCatalog = val; }
    ServiceCatalog* getServiceCatalog() const { return _serviceCatalog; }
 
    DSMServerIterator getDSMServerIterator() const;
 
    DSMServiceIterator getDSMServiceIterator() const;
 
    ProcessorIterator getProcessorIterator() const;
 
    SiteIterator getSiteIterator() const;
 
    DSMConfigIterator getDSMConfigIterator() const;
 
    SensorIterator getSensorIterator() const;
 
    SampleTagIterator getSampleTagIterator() const;
 
    VariableIterator getVariableIterator() const;
 
    void initSensors();
 
    void initSensors(Site* site);
 
    void initSensors(DSMConfig* dsm);
 
    const Parameter* getParameter(const std::string& name) const;
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    xercesc::DOMElement*
    toDOMParent(xercesc::DOMElement* parent,bool complete) const;
 
    xercesc::DOMElement*
    toDOMElement(xercesc::DOMElement* node,bool complete) const;
 
    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;
    }
 
    void setDataset(const Dataset& val)
    {
        _dataset = val;
    }
 
    const Dataset& getDataset() const
    {
        return _dataset;
    }
 
    void
    disableAutoconfig(bool disable)
    {
        _disableAutoconfig = disable;
    }
 
protected:
    void addParameter(Parameter* val)
    {
        _parameters.push_back(val);
    }
 
private:
 
    void removeAutoConfig(xercesc::DOMNode* node, bool bumpRecursion=false);
 
#ifdef ACCESS_AS_SINGLETON
    static Project* _instance;
#endif
 
    std::string _name;
 
    std::string _sysname;
 
    std::string _configVersion;
 
    std::string _configName;
 
    mutable std::string _flightName;
 
    class MyDictionary : public Dictionary {
    public:
        MyDictionary(Project* project): _project(project) {}
        MyDictionary(const MyDictionary& x): Dictionary(),_project(x._project) {}
        MyDictionary& operator=(const MyDictionary& rhs)
        {
            if (&rhs != this) {
                *(Dictionary*)this = rhs;
                _project = rhs._project;
            }
            return *this;
        }
        bool getTokenValue(const std::string& token, std::string& value) const;
    private:
        Project* _project;
    } _dictionary;
 
    std::list<Site*> _sites;
 
    SensorCatalog* _sensorCatalog;
 
    DSMCatalog* _dsmCatalog;
 
    ServiceCatalog* _serviceCatalog;
 
    std::list<DSMServer*> _servers;
 
    mutable nidas::util::Mutex _lookupLock;
 
    mutable std::map<dsm_sample_id_t,const DSMConfig*> _dsmById;
 
    mutable nidas::util::Mutex _sensorMapLock;
 
    mutable std::map<dsm_sample_id_t,DSMSensor*> _sensorById;
 
    std::map<int,Site*> _siteByStationNumber;
 
    std::map<std::string,Site*> _siteByName;
 
    std::set<dsm_sample_id_t> _usedIds;
 
    int _maxSiteNumber;
 
    int _minSiteNumber;
 
    std::list<Parameter*> _parameters;
 
    Dataset _dataset;
 
    bool _disableAutoconfig;
 
    Project(const Project&);
 
    Project& operator=(const Project&);
 
};
 
}}  // namespace nidas namespace core
 
#endif