AggregationUtil.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 __AGG_UTIL__AGGREGATION_UTIL_H__
#define __AGG_UTIL__AGGREGATION_UTIL_H__
 
#include <libdap/AttrTable.h>
#include <iostream>
#include <string>
#include <vector>
 
namespace libdap {
class Array;
class BaseType;
class Constructor;
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::DDS& 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::DDS& 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::DDS& 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::DDS& 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);
 
#if 0
    static void produceOuterDimensionJoinedArray(libdap::Array* pJoinedArray, const std::string& joinedArrayName,
        const std::string& newOuterDimName, const std::vector<libdap::Array*>& fromVars, bool copyData);
#endif

    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);
 
#if 0
    static void joinArrayData(libdap::Array* pAggArray, const std::vector<libdap::Array*>& varArrays,
        bool reserveStorage = true, bool clearDataAfterUse = false);
#endif

    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 libdap::Array* readDatasetArrayDataForAggregation(const libdap::Array& constrainedTemplateArray,
        const std::string& varName, AggMemberDataset& dataset, const ArrayGetterInterface& arrayGetter,
        const std::string& debugChannel);

    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__ */