NetcdfElement.h

// This file is part of the "NcML Module" project, a BES module designed
// to allow NcML files to be used to be used as a wrapper to add
// AIS to existing datasets of any format.
//
// Copyright (c) 2009 OPeNDAP, Inc.
// Author: Michael Johnson  <m.johnson@opendap.org>
//
// For more information, please also see the main website: http://opendap.org/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// Please see the files COPYING and COPYRIGHT for more information on the GLPL.
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#ifndef __NCML_MODULE__NETCDF_ELEMENT_H__
#define __NCML_MODULE__NETCDF_ELEMENT_H__
 
#include "AggMemberDataset.h" // agg_util
#include "DDSAccessInterface.h"
#include "DDSLoader.h"
#include "NCMLElement.h"
 
namespace libdap {
class BaseType;
class DDS;
}
 
class BESDapResponse;
 
namespace ncml_module {
 
class AggregationElement;
class DimensionElement;
class NCMLParser;
class VariableElement;

class NetcdfElement: public NCMLElement, // superclass
    public virtual agg_util::DDSAccessRCInterface // interface
{
private:
    NetcdfElement& operator=(const NetcdfElement& rhs); //disallow
 
public:
    static const std::string _sTypeName;
    static const std::vector<std::string> _sValidAttributes;
 
    NetcdfElement();
    NetcdfElement(const NetcdfElement& proto);
    virtual ~NetcdfElement();
    virtual const std::string& getTypeName() const;
    virtual NetcdfElement* clone() const; // override clone with more specific subclass
    virtual void setAttributes(const XMLAttributeMap& attrs);
    virtual void handleBegin();
    virtual void handleContent(const std::string& content);
    virtual void handleEnd();
    virtual std::string toString() const;
 
    // Accessors for attributes we deal with.
    // TODO Add these as we support aggregation attributes
    const std::string& location() const
    {
        return _location;
    }
    const std::string& id() const
    {
        return _id;
    }
    const std::string& title() const
    {
        return _title;
    }
    const std::string& coordValue() const
    {
        return _coordValue;
    }
    const std::string& ncoords() const
    {
        return _ncoords;
    }
 
    bool hasNcoords() const
    {
        return !_ncoords.empty();
    }

    unsigned int getNcoordsAsUnsignedInt() const;

    bool isValid() const;

    virtual const libdap::DDS* getDDS() const;

    virtual libdap::DDS* getDDS();
 
    bool getProcessedMetadataDirective() const
    {
        return _gotMetadataDirective;
    }
 
    void setProcessedMetadataDirective()
    {
        _gotMetadataDirective = true;
    }

    void borrowResponseObject(BESDapResponse* pResponse);

    void unborrowResponseObject(BESDapResponse* pResponse);

    void createResponseObject(agg_util::DDSLoader::ResponseType type);

    RCPtr<agg_util::AggMemberDataset> getAggMemberDataset() const;

    const DimensionElement* getDimensionInLocalScope(const std::string& name) const;

    const DimensionElement* getDimensionInFullScope(const std::string& name) const;

    void addDimension(DimensionElement* dim);

    std::string printDimensions() const;

    void clearDimensions();

    const std::vector<DimensionElement*>& getDimensionElements() const;

    void setChildAggregation(AggregationElement* agg, bool throwIfExists = true);

    AggregationElement* getChildAggregation() const;

    NetcdfElement* getParentDataset() const;

    AggregationElement* getParentAggregation() const;

    void setParentAggregation(AggregationElement* parent);
 
#if 0 // not sure we need this yet
    template <typename T> int getCoordValueVector(std::vector<T>& values) const;
#endif

    bool getCoordValueAsDouble(double& val) const;

    void addVariableToValidateOnClose(libdap::BaseType* pNewVar, VariableElement* pVE);

    void setVariableGotValues(libdap::BaseType* pVarToValidate, bool removeEntry);

    VariableElement* findVariableElementForLibdapVar(libdap::BaseType* pNewVar);

    static bool isLocationLexicographicallyLessThan(const NetcdfElement* pLHS, const NetcdfElement* pRHS);

    static bool isCoordValueLexicographicallyLessThan(const NetcdfElement* pLHS, const NetcdfElement* pRHS);
 
private:

    void loadLocation();

    void throwOnUnsupportedAttributes();

    bool validateAttributeContextOrThrow() const;
 
    static std::vector<std::string> getValidAttributes();
 
private:
    std::string _location;
    std::string _id;
    std::string _title;
    std::string _ncoords;
    std::string _enhance;
    std::string _addRecords;
    std::string _coordValue;
    std::string _fmrcDefinition;
 
    // Whether we got a metadata direction element { readMetadata | explicit } for this node yet.
    // Just used to check for more than one.
    bool _gotMetadataDirective;
 
    // Whether we own the memory for _response and need to destroy it in dtor or not.
    bool _weOwnResponse;
 
    // true after loadLocation has been called.
    bool _loaded;
 
    // Our response object
    // We OWN it if we're not the root element,
    // but the parser owns it if we are the root.
    // The parser sets _weOwnResponse correctly for our dtor.
    BESDapResponse* _response;
 
    // If non-null, a pointer to the singleton aggregation element for this dataset.
    // We use an RCPtr to automatically ref() it when we set it
    // and to unref() it in our dtor.
    RCPtr<AggregationElement> _aggregation;
 
    // If we are nested within an aggregation element,
    // this is a back ptr we can use to traverse upwards.
    // If it null if we're a root dataset.
    AggregationElement* _parentAgg;
 
    // A table of strong references to Dimensions valid for this element's lexical scope.
    // We use raw DimensionElement*, but ref() them upon adding them to the vector
    // and unref() them in the dtor.
    // We won't have that many, so a vector is more efficient than a map for this.
    std::vector<DimensionElement*> _dimensions;
 
    // Lazy evaluated, starts unassigned.
    // When getAggMemberDataset() is called, it is lazy-constructed
    // to weak ref the returned strong shared ptr (RCPtr).
    agg_util::WeakRCPtr<agg_util::AggMemberDataset> _pDatasetWrapper;
 
public:
    // inner classes can't be private?
    class VariableValueValidator {
    public:
        VariableValueValidator(NetcdfElement* pParent);

        ~VariableValueValidator();

        void addVariableToValidate(libdap::BaseType* pNewVar, VariableElement* pVE);

        void removeVariableToValidate(libdap::BaseType* pVarToRemove);

        void setVariableGotValues(libdap::BaseType* pVarToValidate);

        bool validate();

        VariableElement* findVariableElementForLibdapVar(libdap::BaseType* pNewVar);
 
    private:
        // disallow implicit copies
        VariableValueValidator(const VariableValueValidator&);
        VariableValueValidator& operator=(const VariableValueValidator&);
 
    public:
 
        class VVVEntry {
        public:
            VVVEntry() :
                _pNewVar(0), _pVarElt(0)
            {
            }
            VVVEntry(libdap::BaseType* pBT, VariableElement* pVE) :
                _pNewVar(pBT), _pVarElt(pVE)
            {
            }
            void clear()
            {
                _pNewVar = 0;
                _pVarElt = 0;
            }
            libdap::BaseType* _pNewVar;
            VariableElement* _pVarElt;
        };
 
        /********************* helper functions *******************/

    private:
        VariableValueValidator::VVVEntry* findEntryByLibdapVar(libdap::BaseType* pVarToFind);
 
        // We don't expect too many entries, so a simple vector is the best way to go,
        // avoid overhead of maps, etc.
        std::vector<VVVEntry> _entries;
        NetcdfElement* _pParent;
    }; // class VariableValueValidator
 
private:
    // The actual instance we will poke from methods in NetcdfElement
    VariableValueValidator _variableValidator;
};
 
}
 
#endif /* __NCML_MODULE__NETCDF_ELEMENT_H__ */