AggregationUtil.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 __AGG_UTIL__AGGREGATION_UTIL_H__
#define __AGG_UTIL__AGGREGATION_UTIL_H__

#include <AttrTable.h>
#include <iostream>
#include <string>
#include <vector>

namespace libdap
{
  class Array;
  class BaseType;
  class Constructor;
  class DataDDS;
  class DDS;
  class Grid;
};

namespace agg_util
{
  class AggMemberDataset;
  struct Dimension;
  // jhrg 4/16/14 class Dimension;
};

namespace agg_util
{

  struct ArrayGetterInterface
  {
    virtual ~ArrayGetterInterface();

    virtual ArrayGetterInterface* clone() const = 0;

    virtual libdap::Array* readAndGetArray(
        const std::string& name,
        const libdap::DataDDS& dds,
        const libdap::Array* const pConstraintTemplate,
        const std::string& debugChannel
        ) const = 0;
  }; // class ArrayGetterInterface

  struct TopLevelArrayGetter : public ArrayGetterInterface
  {
    TopLevelArrayGetter();
    virtual ~TopLevelArrayGetter();

    virtual TopLevelArrayGetter* clone() const;

    virtual libdap::Array* readAndGetArray(
            const std::string& name,
            const libdap::DataDDS& dds,
            const libdap::Array* const pConstraintTemplate,
            const std::string& debugChannel
            ) const;
  }; // class TopLevelArrayGetter

  struct TopLevelGridDataArrayGetter : public ArrayGetterInterface
  {
    TopLevelGridDataArrayGetter();
    virtual ~TopLevelGridDataArrayGetter();

    virtual TopLevelGridDataArrayGetter* clone() const;

    virtual libdap::Array* readAndGetArray(
            const std::string& name,
            const libdap::DataDDS& dds,
            const libdap::Array* const pConstraintTemplate,
            const std::string& debugChannel
            ) const;
  }; // class TopLevelGridDataArrayGetter

  struct TopLevelGridMapArrayGetter : public ArrayGetterInterface
    {
      TopLevelGridMapArrayGetter(const std::string& gridName);
      virtual ~TopLevelGridMapArrayGetter();

      virtual TopLevelGridMapArrayGetter* clone() const;

      virtual libdap::Array* readAndGetArray(
              const std::string& name,
              const libdap::DataDDS& dds,
              const libdap::Array* const pConstraintTemplate,
              const std::string& debugChannel
              ) const;

      // The name of the Grid within which the desired map is contained.
      const string _gridName;
    }; // class TopLevelGridMapArrayGetter

  class AggregationUtil
  {
  private: // This is a static class for now...
    AggregationUtil() {}
    ~AggregationUtil() {}

    static int d_last_added_cv_position;

  public:

    // Typedefs
    typedef std::vector<const libdap::DDS*> ConstDDSList;

    static void performUnionAggregation(
        libdap::DDS* pOutputUnion,
        const ConstDDSList& datasetsInOrder);

    static void unionAttrsInto(libdap::AttrTable* pOut, const libdap::AttrTable& fromTable);

    static bool findAttribute(const libdap::AttrTable& inTable, const string& name, libdap::AttrTable::Attr_iter& attr);

    static void unionAllVariablesInto(libdap::DDS* pOutputUnion, const ConstDDSList& datasetsInOrder);

    static void resetCVInsertionPosition();

    static void unionAllVariablesInto(libdap::DDS* pOutputUnion, const libdap::DDS& fromDDS, bool add_at_top = false);

    static bool addCopyOfVariableIfNameIsAvailable(libdap::DDS* pOutDDS, const libdap::BaseType& varProto, bool add_at_top = false);

    static void addOrReplaceVariableForName(libdap::DDS* pOutDDS, const libdap::BaseType& varProto);

    static libdap::BaseType* findVariableAtDDSTopLevel(const libdap::DDS& dds, const string& name);

    template <class LibdapType> static LibdapType* findTypedVariableAtDDSTopLevel(const libdap::DDS& dds, const string& name);

    static void produceOuterDimensionJoinedArray(libdap::Array* pJoinedArray,
          const std::string& joinedArrayName,
          const std::string& newOuterDimName,
          const std::vector<libdap::Array*>& fromVars,
          bool copyData);

    static bool validateArrayTypesAndShapesMatch(const std::vector<libdap::Array*>& arrays,
        bool enforceMatchingDimNames);

    static bool doTypesMatch(const libdap::Array& lhs, const libdap::Array& rhs);

    static bool doShapesMatch(const libdap::Array& lhs, const libdap::Array& rhs, bool checkDimNames);

    static unsigned int collectVariableArraysInOrder(
          std::vector<libdap::Array*>& varArrays,
          const std::string& collectVarName,
          const ConstDDSList& datasetsInOrder);

    static bool couldBeCoordinateVariable(libdap::BaseType* pBT);

    static void joinArrayData(libdap::Array* pAggArray,
        const std::vector<libdap::Array*>& varArrays,
        bool reserveStorage=true,
        bool clearDataAfterUse=false);

    static void printDimensions(std::ostream& os, const libdap::Array& fromArray);

    static void printConstraints(std::ostream& os, const libdap::Array& fromArray);

    static void printConstraintsToDebugChannel(const std::string& debugChannel, const libdap::Array& fromArray);

    static void transferArrayConstraints(
                libdap::Array* pToArray,
                const libdap::Array& fromArray,
                bool skipFirstFromDim,
                bool skipFirstToDim,
                bool printDebug = false,
                const std::string& debugChannel = "agg_util");

    static libdap::BaseType* getVariableNoRecurse(
        const libdap::DDS& dds,
        const std::string& name);

    static libdap::BaseType* getVariableNoRecurse(
        const libdap::Constructor& varContainer,
        const std::string& name);

    static libdap::Array* getAsArrayIfPossible(libdap::BaseType* pBT);

    static const libdap::Array* findMapByName(const libdap::Grid& inGrid, const std::string& findName);

    static void addDatasetArrayDataToAggregationOutputArray(
        libdap::Array& oOutputArray, // output location
        unsigned int atIndex, // oOutputArray[atIndex] will be where data put
        const libdap::Array& constrainedTemplateArray, // for copying constraints
        const string& varName, // top level var to find in dataset DDS
        AggMemberDataset& dataset, // Dataset who's DDS should be searched
        const ArrayGetterInterface& arrayGetter, // alg for getting Array from DDS
        const string& debugChannel // if !"", debug output goes to this channel.
        );

    static void gatherMetadataChangesFrom(
        libdap::BaseType* pIntoVar,
        const libdap::BaseType& fromVar);

  }; // class AggregationUtil

  template <typename T>
  void clearVectorAndDeletePointers(std::vector<T*>& vecToClear)
  {
    while (!vecToClear.empty())
      {
        T* pElt = vecToClear.back();
        delete pElt;
        vecToClear.pop_back();
      }
  }

  template <class T>
  void clearAndUnrefAllElements(std::vector<T*>& vecToClear)
   {
     while (!vecToClear.empty())
       {
         T* pElt = vecToClear.back();
         pElt->unref();
         vecToClear.pop_back();
       }
   }

  template <class T>
  void appendVectorOfRCObject(std::vector<T*>& intoVec,
       const std::vector<T*>& fromVec)
  {
    class std::vector<T*>::const_iterator it;
    class std::vector<T*>::const_iterator endIt = fromVec.end();
    for (it = fromVec.begin(); it != endIt; ++it)
       {
         T* pElt = *it;
         if (pElt)
           {
             pElt->ref();
           }
         intoVec.push_back(pElt);
       }
   }

}

#endif /* __AGG_UTIL__AGGREGATION_UTIL_H__ */