AbstractHdfProxy.h

/*-----------------------------------------------------------------------
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"; you may not use this file except in compliance
with the License.  You may obtain a copy of the License at
 
  http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-----------------------------------------------------------------------*/
#pragma once
 
#include "EpcExternalPartReference.h"
#include "../common/HidtType.h"
 
namespace EML2_NS
{
    class AbstractHdfProxy : public EpcExternalPartReference
    {
    public:
 
        static constexpr char const* CUMULATIVE_LENGTH_DS_NAME = "cumulativeLength";
        static constexpr char const* ELEMENTS_DS_NAME = "elements";
 
        DLL_IMPORT_OR_EXPORT virtual ~AbstractHdfProxy() = default;
 
        DLL_IMPORT_OR_EXPORT void setRootPath(const std::string& rootPath) { packageDirectoryAbsolutePath = rootPath; }
 
        DLL_IMPORT_OR_EXPORT void setRelativePath(const std::string& relPath) { relativeFilePath = relPath; }
 
        DLL_IMPORT_OR_EXPORT void setOpeningMode(COMMON_NS::DataObjectRepository::openingMode openingMode_) { openingMode = openingMode_; }
 
        DLL_IMPORT_OR_EXPORT const std::string& getRelativePath() const { return relativeFilePath; }
 
        virtual void open() = 0;
 
        DLL_IMPORT_OR_EXPORT virtual bool isOpened() const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void close() = 0;
 
        DLL_IMPORT_OR_EXPORT virtual COMMON_NS::AbstractObject::numericalDatatypeEnum getNumericalDatatype(const std::string & datasetName) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual int getHdfDatatypeClassInDataset(const std::string & datasetName) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeItemizedListOfList(const std::string & groupName,
            const std::string & name,
            COMMON_NS::AbstractObject::numericalDatatypeEnum cumulativeLengthDatatype,
            const void * cumulativeLength,
            uint64_t cumulativeLengthSize,
            COMMON_NS::AbstractObject::numericalDatatypeEnum elementsDatatype,
            const void * elements,
            uint64_t elementsSize) = 0;
 
        DLL_IMPORT_OR_EXPORT uint64_t getDimensionCount(const std::string & datasetName) { return getElementCountPerDimension(datasetName).size(); }
 
        DLL_IMPORT_OR_EXPORT virtual std::vector<uint32_t> getElementCountPerDimension(const std::string & datasetName) = 0;
 
        DLL_IMPORT_OR_EXPORT uint64_t getElementCount(const std::string & datasetName);
 
        DLL_IMPORT_OR_EXPORT virtual void setCompressionLevel(unsigned int newCompressionLevel) = 0;
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfFloatValues(const std::string & groupName,
            const std::string & name,
            const float * values,
            const uint64_t * numValuesInEachDimension,
            unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::FLOAT, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfDoubleValues(const std::string & groupName,
          const std::string & name,
          const double * values,
          const uint64_t * numValuesInEachDimension,
          unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::DOUBLE, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfInt8Values(const std::string & groupName,
            const std::string & name,
            const int8_t * values,
            const uint64_t * numValuesInEachDimension,
            unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::INT8, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfIntValues(const std::string & groupName,
          const std::string & name,
          const int * values,
          const uint64_t * numValuesInEachDimension,
          unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::INT32, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfInt64Values(const std::string & groupName,
            const std::string & name,
            const int64_t * values,
            const uint64_t * numValuesInEachDimension,
            unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::INT64, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT void writeArrayNdOfUInt64Values(const std::string & groupName,
            const std::string & name,
            const uint64_t * values,
            const uint64_t * numValuesInEachDimension,
            unsigned int numDimensions) {
            writeArrayNd(groupName, name, COMMON_NS::AbstractObject::numericalDatatypeEnum::UINT64, values, numValuesInEachDimension, numDimensions);
        }
 
        DLL_IMPORT_OR_EXPORT virtual void writeArrayNd(const std::string & groupName,
          const std::string & name,
          COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
          const void * values,
          const uint64_t * numValuesInEachDimension,
          unsigned int numDimensions) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void createArrayNd(
          const std::string& groupName,
          const std::string& name,
          COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
          const uint64_t* numValuesInEachDimension,
          unsigned int numDimensions
          ) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeArrayNdSlab(
          const std::string& groupName,
          const std::string& name,
          COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
          const void* values,
          const uint64_t* numValuesInEachDimension,
          const uint64_t* offsetValuesInEachDimension,
          unsigned int numDimensions
          ) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeGroupAttributes(const std::string & groupName,
            const std::vector<std::string> & attributeNames,
            const std::vector<std::string> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeGroupAttribute(const std::string & groupName,
            const std::string & attributeName,
            const std::vector<std::string> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeGroupAttributes(const std::string & groupName,
            const std::vector<std::string> & attributeNames,
            const std::vector<double> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeGroupAttributes(const std::string & groupName,
            const std::vector<std::string> & attributeNames,
            const std::vector<int> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeDatasetAttributes(const std::string & datasetName,
            const std::vector<std::string> & attributeNames,
            const std::vector<std::string> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeDatasetAttribute(const std::string & datasetName,
            const std::string & attributeName,
            const std::vector<std::string> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeDatasetAttributes(const std::string & datasetName,
            const std::vector<std::string> & attributeNames,
            const std::vector<double> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void writeDatasetAttributes(const std::string & datasetName,
            const std::vector<std::string> & attributeNames,
            const std::vector<int> & values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual std::string readStringAttribute(const std::string & obj_name,
            const std::string & attr_name) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual std::vector<std::string> readStringArrayAttribute(const std::string & obj_name,
            const std::string & attr_name) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual double readDoubleAttribute(const std::string & obj_name,
            const std::string & attr_name) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual int64_t readInt64Attribute(const std::string & obj_name,
            const std::string & attr_name) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfDoubleValues(const std::string & datasetName, double* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfDoubleValues(
          const std::string & datasetName,
          double* values,
          uint64_t const * numValuesInEachDimension,
          uint64_t const * offsetInEachDimension,
          unsigned int numDimensions
          ) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfDoubleValues(
            const std::string & datasetName, 
            double* values,
            uint64_t const * blockCountPerDimension,
            uint64_t const * offsetInEachDimension,
            uint64_t const * strideInEachDimension,
            uint64_t const * blockSizeInEachDimension,
            unsigned int numDimensions) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void selectArrayNdOfValues(
            const std::string & datasetName,
            uint64_t const* blockCountPerDimension,
            uint64_t const* offsetInEachDimension,
            uint64_t const* strideInEachDimension,
            uint64_t const* blockSizeInEachDimension,
            unsigned int numDimensions,
            bool newSelection,
            hdf5_hid_t & dataset,
            hdf5_hid_t & filespace) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfDoubleValues(
            hdf5_hid_t dataset,
            hdf5_hid_t filespace,
            void* values,
            uint64_t slabSize) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfFloatValues(const std::string & datasetName, float* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfFloatValues(
          const std::string & datasetName,
          float* values,
          uint64_t const * numValuesInEachDimension,
          uint64_t const * offsetInEachDimension,
          unsigned int numDimensions
          ) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfInt64Values(const std::string & datasetName, int64_t* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfInt64Values(
            const std::string & datasetName,
            int64_t* values,
            uint64_t const * numValuesInEachDimension,
            uint64_t const * offsetInEachDimension,
            unsigned int numDimensions) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfUInt64Values(const std::string & datasetName, uint64_t* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfIntValues(const std::string & datasetName, int* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfIntValues(
            const std::string & datasetName,
            int* values,
            uint64_t const * numValuesInEachDimension,
            uint64_t const * offsetInEachDimension,
            unsigned int numDimensions
        ) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfUIntValues(const std::string & datasetName, unsigned int* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfShortValues(const std::string & datasetName, short* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfUShortValues(const std::string & datasetName, unsigned short* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfInt8Values(const std::string & datasetName, int8_t* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void readArrayNdOfUInt8Values(const std::string & datasetName, uint8_t* values) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual bool exist(const std::string & absolutePathInHdfFile) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual bool isCompressed(const std::string & datasetName) = 0;
        
        DLL_IMPORT_OR_EXPORT void setMaxChunkSize(unsigned int newMaxChunkSize) { maxChunkSize = newMaxChunkSize; }
 
        DLL_IMPORT_OR_EXPORT virtual std::vector<uint32_t> getElementCountPerChunkDimension(const std::string & datasetName) = 0;
 
        DLL_IMPORT_OR_EXPORT void initGsoapProxy(COMMON_NS::DataObjectRepository* repo, const std::string& guid, const std::string& title, unsigned int emlVersion);
 
        static constexpr char const* MIME_TYPE = "application/x-hdf5";
 
    protected:
 
        AbstractHdfProxy(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : EpcExternalPartReference(partialObject) {}
        AbstractHdfProxy(const COMMON_NS::DataObjectReference& dor) : EpcExternalPartReference(dor) {}
 
        DLL_IMPORT_OR_EXPORT AbstractHdfProxy(const std::string & packageDirAbsolutePath, const std::string & externalFilePath, COMMON_NS::DataObjectRepository::openingMode hdfPermissionAccess = COMMON_NS::DataObjectRepository::openingMode::READ_ONLY) :
            packageDirectoryAbsolutePath(packageDirAbsolutePath), relativeFilePath(externalFilePath), openingMode(hdfPermissionAccess) {}
 
        AbstractHdfProxy(gsoap_resqml2_0_1::_eml20__EpcExternalPartReference* fromGsoap) :
            EpcExternalPartReference(fromGsoap) {}
 
        std::string packageDirectoryAbsolutePath;
        std::string relativeFilePath;
        COMMON_NS::DataObjectRepository::openingMode openingMode = COMMON_NS::DataObjectRepository::openingMode::READ_ONLY;
        unsigned int maxChunkSize = 1000000;
    };
}