AbstractValuesProperty.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 "AbstractProperty.h"
 
namespace RESQML2_NS
{
    class AbstractValuesProperty : public AbstractProperty
    {
    public:
 
        virtual ~AbstractValuesProperty() = default;
 
        DLL_IMPORT_OR_EXPORT uint64_t getPatchCount() const final;
 
        DLL_IMPORT_OR_EXPORT COMMON_NS::AbstractObject::numericalDatatypeEnum getValuesHdfDatatype() const final;
 
        DLL_IMPORT_OR_EXPORT uint64_t getValuesCountOfDimensionOfPatch(uint64_t dimIndex, uint64_t patchIndex) const final;
 
        DLL_IMPORT_OR_EXPORT uint64_t getDimensionsCountOfPatch(uint64_t patchIndex) const final;
 
        DLL_IMPORT_OR_EXPORT void pushBackFacet(gsoap_eml2_3::eml23__FacetKind facet, const std::string & facetValue);
 
        DLL_IMPORT_OR_EXPORT uint64_t getFacetCount() const;
 
        DLL_IMPORT_OR_EXPORT gsoap_eml2_3::eml23__FacetKind getFacetKind(uint64_t index) const;
 
        DLL_IMPORT_OR_EXPORT std::string getFacetValue(uint64_t index) const;
 
        //****************************
        //****** INTEGER *************
        //****************************
 
        DLL_IMPORT_OR_EXPORT void pushBackIntegerConstantArrayOfValues(int64_t value, uint64_t valueCount);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt64Hdf5Array1dOfValues(const int64_t * values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy, int64_t nullValue) {
            pushBackInt64Hdf5ArrayOfValues(values, &valueCount, 1, proxy, nullValue);
        }
 
        DLL_IMPORT_OR_EXPORT void pushBackInt32Hdf5Array1dOfValues(const int * values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy, int nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt16Hdf5Array1dOfValues(const short * values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy, short nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt8Hdf5Array1dOfValues(const int8_t* values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy, int8_t nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt64Hdf5Array2dOfValues(const int64_t * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int64_t nullValue) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            pushBackInt64Hdf5ArrayOfValues(values, valueCountPerDimension, 2, proxy, nullValue);
        }
 
        DLL_IMPORT_OR_EXPORT void pushBackInt32Hdf5Array2dOfValues(const int * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt16Hdf5Array2dOfValues(const short * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, short nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackUInt16Hdf5Array2dOfValues(const unsigned short * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, unsigned short nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt8Hdf5Array2dOfValues(const int8_t * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int8_t nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt64Hdf5Array3dOfValues(const int64_t * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int64_t nullValue) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            pushBackInt64Hdf5ArrayOfValues(values, valueCountPerDimension, 3, proxy, nullValue);
        }
 
        DLL_IMPORT_OR_EXPORT void pushBackInt32Hdf5Array3dOfValues(const int * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt16Hdf5Array3dOfValues(const short * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, short nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackUInt16Hdf5Array3dOfValues(const unsigned short * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, unsigned short nullValue);
 
        DLL_IMPORT_OR_EXPORT void pushBackInt8Hdf5Array3dOfValues(const int8_t * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy, int8_t nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual void pushBackInt64Hdf5ArrayOfValues(const int64_t * values, const uint64_t * numValues, unsigned int numDimensionsInArray, EML2_NS::AbstractHdfProxy* proxy, int64_t nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual void pushBackInt32Hdf5ArrayOfValues(const int * values, const uint64_t * numValues, unsigned int numDimensionsInArray, EML2_NS::AbstractHdfProxy* proxy, int nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual void pushBackInt16Hdf5ArrayOfValues(const short * values, const uint64_t * numValues, unsigned int numDimensionsInArray, EML2_NS::AbstractHdfProxy* proxy, short nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual void pushBackUInt16Hdf5ArrayOfValues(const unsigned short * values, const uint64_t * numValues, unsigned int numDimensionsInArray, EML2_NS::AbstractHdfProxy* proxy, unsigned short nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual void pushBackInt8Hdf5ArrayOfValues(const int8_t * values, const uint64_t * numValues, unsigned int numDimensionsInArray, EML2_NS::AbstractHdfProxy* proxy, int8_t nullValue);
 
        DLL_IMPORT_OR_EXPORT virtual std::string pushBackRefToExistingIntegerDataset(EML2_NS::AbstractHdfProxy* hdfProxy, const std::string & dataset = "", int64_t nullValue = (std::numeric_limits<int64_t>::max)());
 
        DLL_IMPORT_OR_EXPORT bool hasConstantValues(uint64_t patchIndex) const;
 
        DLL_IMPORT_OR_EXPORT int64_t getInt64ConstantValuesOfPatch(uint64_t patchIndex) const;
 
        DLL_IMPORT_OR_EXPORT double getDoubleConstantValuesOfPatch(uint64_t patchIndex) const;
 
        DLL_IMPORT_OR_EXPORT int64_t getNullValueOfPatch(uint64_t patchIndex) const;
 
        DLL_IMPORT_OR_EXPORT int64_t getInt64ValuesOfPatch(uint64_t patchIndex, int64_t* values) const;
 
        DLL_IMPORT_OR_EXPORT uint64_t getUInt64ValuesOfPatch(uint64_t patchIndex, uint64_t* values) const;
 
        DLL_IMPORT_OR_EXPORT int32_t getInt32ValuesOfPatch(uint64_t patchIndex, int32_t* values) const;
 
        DLL_IMPORT_OR_EXPORT uint32_t getUInt32ValuesOfPatch(uint64_t patchIndex, uint32_t* values) const;
 
        DLL_IMPORT_OR_EXPORT int16_t getInt16ValuesOfPatch(uint64_t patchIndex, int16_t* values) const;
 
        DLL_IMPORT_OR_EXPORT uint16_t getUInt16ValuesOfPatch(uint64_t patchIndex, uint16_t* values) const;
 
        DLL_IMPORT_OR_EXPORT int8_t getInt8ValuesOfPatch(uint64_t patchIndex, int8_t* values) const;
 
        DLL_IMPORT_OR_EXPORT uint8_t getUInt8ValuesOfPatch(uint64_t patchIndex, uint8_t* values) const;
 
        //***********************************
        //*** Writing with hyperslabbing *****
        //***********************************
 
        DLL_IMPORT_OR_EXPORT void pushBackHdf5ArrayOfValues(
            COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
            uint64_t const * numValues,
            unsigned int numArrayDimensions,
            int64_t nullValue = (std::numeric_limits<int64_t>::max)(),
            EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        DLL_IMPORT_OR_EXPORT void pushBackHdf5Array1dOfValues(
            COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
            uint64_t valueCount,
            int64_t nullValue = (std::numeric_limits<int64_t>::max)(), EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        DLL_IMPORT_OR_EXPORT void pushBackHdf5Array2dOfValues(
            COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            int64_t nullValue = (std::numeric_limits<int64_t>::max)(),
            EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        DLL_IMPORT_OR_EXPORT void pushBackHdf5Array3dOfValues(
            COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            int64_t nullValue = (std::numeric_limits<int64_t>::max)(),
            EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        DLL_IMPORT_OR_EXPORT void setValuesOfInt64Hdf5ArrayOfValues(
            int64_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::INT64, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt64Hdf5ArrayOfValues(
            uint64_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::UINT64, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt32Hdf5ArrayOfValues(
            int32_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::INT32, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt32Hdf5ArrayOfValues(
            uint32_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::UINT32, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt16Hdf5ArrayOfValues(
            int16_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::INT16, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt16Hdf5ArrayOfValues(
            uint16_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::UINT16, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt8Hdf5ArrayOfValues(
            int8_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::INT8, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt8Hdf5ArrayOfValues(
            uint8_t const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::UINT8, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfDoubleHdf5ArrayOfValues(
            double const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::DOUBLE, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfFloatHdf5ArrayOfValues(
            float const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfHdf5ArrayOfValues(
                COMMON_NS::AbstractObject::numericalDatatypeEnum::FLOAT, values, numValues,
                offsetValues, numArrayDimensions, proxy, patchIndex);
        }
 
        DLL_IMPORT_OR_EXPORT void setValuesOfInt64Hdf5Array1dOfValues(
            int64_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfInt64Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt64Hdf5Array1dOfValues(
            uint64_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfUInt64Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt32Hdf5Array1dOfValues(
            int32_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfInt32Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt32Hdf5Array1dOfValues(
            uint32_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfUInt32Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt16Hdf5Array1dOfValues(
            int16_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfInt16Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt16Hdf5Array1dOfValues(
            uint16_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfUInt16Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt8Hdf5Array1dOfValues(
            int8_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfInt8Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt8Hdf5Array1dOfValues(
            uint8_t const* values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfUInt8Hdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfDoubleHdf5Array1dOfValues(
            double const * values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfDoubleHdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfFloatHdf5Array1dOfValues(
            float const * values,
            uint64_t valueCount,
            uint64_t offset,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            setValuesOfFloatHdf5ArrayOfValues(values, &valueCount, &offset, 1, proxy, patchIndex);
        }
 
        DLL_IMPORT_OR_EXPORT void setValuesOfInt64Hdf5Array2dOfValues(
            int64_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfInt64Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt64Hdf5Array2dOfValues(
            uint64_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfUInt64Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt32Hdf5Array2dOfValues(
            int32_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfInt32Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt32Hdf5Array2dOfValues(
            uint32_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfUInt32Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt16Hdf5Array2dOfValues(
            int16_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfInt16Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt16Hdf5Array2dOfValues(
            uint16_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfUInt16Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt8Hdf5Array2dOfValues(
            int8_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfInt8Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt8Hdf5Array2dOfValues(
            uint8_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfUInt8Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfDoubleHdf5Array2dOfValues(
            double const * values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfDoubleHdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfFloatHdf5Array2dOfValues(
            float const * values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[2] = { valueCountInSlowestDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[2] = { offsetInSlowestDim, offsetInFastestDim };
            setValuesOfFloatHdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 2, proxy, patchIndex);
        }
 
        DLL_IMPORT_OR_EXPORT void setValuesOfInt64Hdf5Array3dOfValues(
            int64_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfInt64Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt64Hdf5Array3dOfValues(
            uint64_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfUInt64Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt32Hdf5Array3dOfValues(
            int32_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfInt32Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt32Hdf5Array3dOfValues(
            uint32_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfUInt32Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt16Hdf5Array3dOfValues(
            int16_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfInt16Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt16Hdf5Array3dOfValues(
            uint16_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfUInt16Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfInt8Hdf5Array3dOfValues(
            int8_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfInt8Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfUInt8Hdf5Array3dOfValues(
            uint8_t const* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfUInt8Hdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfDoubleHdf5Array3dOfValues(
            double const * values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfDoubleHdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
        DLL_IMPORT_OR_EXPORT void setValuesOfFloatHdf5Array3dOfValues(
            float const * values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)()) {
            const uint64_t valueCountPerDimension[3] = { valueCountInSlowestDim, valueCountInMiddleDim, valueCountInFastestDim };
            const uint64_t offsetPerDimension[3] = { offsetInSlowestDim, offsetInMiddleDim, offsetInFastestDim };
            setValuesOfFloatHdf5ArrayOfValues(values, valueCountPerDimension, offsetPerDimension, 3, proxy, patchIndex);
        }
 
        //***********************************
        //*** Reading with hyperslabbing *****
        //***********************************
 
        DLL_IMPORT_OR_EXPORT void getInt64ValuesOfPatch(
            uint64_t patchIndex,
            int64_t* values,
            uint64_t const * numValuesInEachDimension,
            uint64_t const * offsetInEachDimension,
            unsigned int numArrayDimensions
        ) const;
 
        DLL_IMPORT_OR_EXPORT void getInt64ValuesOf3dPatch(
            uint64_t patchIndex,
            int64_t* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim
        ) const;
 
        DLL_IMPORT_OR_EXPORT int32_t getIntValuesOfPatch(
            uint64_t patchIndex,
            int32_t* values,
            const uint64_t* numValuesInEachDimension,
            const uint64_t* offsetInEachDimension,
            unsigned int numArrayDimensions
        ) const;
 
        DLL_IMPORT_OR_EXPORT void getIntValuesOf3dPatch(
            uint64_t patchIndex,
            int32_t* values,
            unsigned int valueCountInFastestDim,
            unsigned int valueCountInMiddleDim,
            unsigned int valueCountInSlowestDim,
            unsigned int offsetInFastestDim,
            unsigned int offsetInMiddleDim,
            unsigned int offsetInSlowestDim
        ) const;
 
        //***********************************
        //****** FLOATING POINT *************
        //***********************************
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatingPointConstantArrayOfValues(double value, uint64_t valueCount);
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array1dOfValues(const double * values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array2dOfValues(const double * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array3dOfValues(const double * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5ArrayOfValues(double const * values, uint64_t const * numValues, unsigned int numArrayDimensions, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array1dOfValues(const float * values, uint64_t valueCount, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array2dOfValues(const float * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array3dOfValues(const float * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5ArrayOfValues(float const * values, uint64_t const * numValues, unsigned int numArrayDimensions, EML2_NS::AbstractHdfProxy* proxy = nullptr);
 
        DLL_IMPORT_OR_EXPORT virtual std::string pushBackRefToExistingFloatingPointDataset(EML2_NS::AbstractHdfProxy* proxy, const std::string & datasetName = "");
 
        DLL_IMPORT_OR_EXPORT void getDoubleValuesOfPatch(uint64_t patchIndex, double * values) const;
 
        DLL_IMPORT_OR_EXPORT void getFloatValuesOfPatch(uint64_t patchIndex, float * values) const;
 
        //******************************************
        //*** For FLOATING POINT hyperslabbing *****
        //******************************************
 
        DLL_IMPORT_OR_EXPORT void getFloatValuesOfPatch(
            uint64_t patchIndex,
            float* values,
            uint64_t const * numValuesInEachDimension,
            uint64_t const * offsetInEachDimension,
            unsigned int numArrayDimensions
        ) const;
 
        DLL_IMPORT_OR_EXPORT void getFloatValuesOf3dPatch(
            uint64_t patchIndex,
            float* values,
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            uint64_t offsetInFastestDim,
            uint64_t offsetInMiddleDim,
            uint64_t offsetInSlowestDim
        ) const;
 
    protected:
 
        DLL_IMPORT_OR_EXPORT AbstractValuesProperty(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : AbstractProperty(partialObject) {}
 
        AbstractValuesProperty() {}
 
        AbstractValuesProperty(gsoap_resqml2_0_1::resqml20__AbstractValuesProperty* fromGsoap) : RESQML2_NS::AbstractProperty(fromGsoap) {}
        AbstractValuesProperty(gsoap_eml2_3::resqml22__AbstractValuesProperty* fromGsoap) : RESQML2_NS::AbstractProperty(fromGsoap) {}
 
        EML2_NS::AbstractHdfProxy* getDatasetOfPatch(uint64_t patchIndex, int64_t & nullValue, std::string & dsPath) const final;
 
        COMMON_NS::DataObjectReference getHdfProxyDor(uint64_t patchIndex) const final;
 
        void setValuesOfHdf5ArrayOfValues(
            COMMON_NS::AbstractObject::numericalDatatypeEnum datatype,
            void const* values,
            uint64_t const * numValues,
            uint64_t const * offsetValues,
            unsigned int numArrayDimensions,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            uint64_t patchIndex = (std::numeric_limits<uint64_t>::max)());
    };
}