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) 
        throw(nidas::core::XMLException);

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

    DSMConfig*
    findDSMFromHostname(const std::string& hostname);

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

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

    void initSensors(Site* site) throw(nidas::util::IOException);

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

    const Parameter* getParameter(const std::string& name) 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);

    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