NetcdfElement.h

Go to the documentation of this file.

// 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 string _sTypeName;
    static const vector<string> _sValidAttributes;

    NetcdfElement();
    NetcdfElement(const NetcdfElement& proto);
    virtual ~NetcdfElement();
    virtual const 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 string& content);
    virtual void handleEnd();
    virtual string toString() const;

    // Accessors for attributes we deal with.
    // TODO Add these as we support aggregation attributes
    const string& location() const { return _location; }
    const string& id() const { return _id; }
    const string& title() const { return _title; }
    const string& coordValue() const { return _coordValue; }
    const 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 string& name) const;

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

    void addDimension(DimensionElement* dim);

    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(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 vector<string> getValidAttributes();

  private:
    string _location;
    string _id;
    string _title;
    string _ncoords;
    string _enhance;
    string _addRecords;
    string _coordValue;
    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.
      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__ */