ContinuousProperty.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 "AbstractValuesProperty.h"
#include "../eml2/AbstractHdfProxy.h"
 
#include <stdexcept>
 
namespace RESQML2_NS
{
    class ContinuousProperty : public AbstractValuesProperty
    {
    public:
 
        virtual ~ContinuousProperty() = default;
 
        std::string pushBackRefToExistingIntegerDataset(EML2_NS::AbstractHdfProxy*, const std::string&, int64_t) final {
            throw std::logic_error("You cannot push back integer values in a Continuous Property.");
        }
 
        DLL_IMPORT_OR_EXPORT virtual gsoap_resqml2_0_1::resqml20__ResqmlUom getUom() const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual std::string getUomAsString() const = 0;
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array1dOfValues(const double * values, uint64_t valueCount,
            double minimumValue, double maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackDoubleHdf5Array1dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array2dOfValues(const double * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim,
            double minimumValue, double maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackDoubleHdf5Array2dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5Array3dOfValues(const double * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim,
            double minimumValue, double maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackDoubleHdf5Array3dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackDoubleHdf5ArrayOfValues(double const * values, unsigned long long const * numValues, unsigned int numArrayDimensions,
            double * minimumValue, double * maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackDoubleHdf5ArrayOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array1dOfValues(const float * values, uint64_t valueCount,
            float minimumValue, float maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackFloatHdf5Array1dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array2dOfValues(const float * values, uint64_t valueCountInFastestDim, uint64_t valueCountInSlowestDim,
            float minimumValue, float maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackFloatHdf5Array2dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array3dOfValues(const float * values, uint64_t valueCountInFastestDim, uint64_t valueCountInMiddleDim, uint64_t valueCountInSlowestDim,
            float minimumValue, float maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackFloatHdf5Array3dOfValues;
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5ArrayOfValues(float const * values, unsigned long long const * numValues, unsigned int numArrayDimensions,
            float * minimumValue, float * maximumValue, EML2_NS::AbstractHdfProxy* proxy = nullptr);
        using AbstractValuesProperty::pushBackFloatHdf5ArrayOfValues;
 
        DLL_IMPORT_OR_EXPORT virtual double getMinimumValue(unsigned int index = 0) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual double getMaximumValue(unsigned int index = 0) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void setMinimumValue(double value, unsigned int index = 0) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual void setMaximumValue(double value, unsigned int index = 0) const = 0;
 
        //***************************
        //*** For hyperslabbing *****
        //***************************
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5ArrayOfValues(
            unsigned long long const * numValues,
            unsigned int numArrayDimensions,
            float * minimumValue, float * maximumValue,
            EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        DLL_IMPORT_OR_EXPORT void pushBackFloatHdf5Array3dOfValues(
            uint64_t valueCountInFastestDim,
            uint64_t valueCountInMiddleDim,
            uint64_t valueCountInSlowestDim,
            float minimumValue, float maximumValue,
            EML2_NS::AbstractHdfProxy* proxy = nullptr
        );
 
        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,
            bool computeMinMax,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            unsigned int patchIndex = (std::numeric_limits<unsigned int>::max)()
        );
        using AbstractValuesProperty::setValuesOfFloatHdf5Array3dOfValues;
 
        DLL_IMPORT_OR_EXPORT void setValuesOfFloatHdf5ArrayOfValues(
            float const * values,
            unsigned long long const * numValues,
            unsigned long long const * offsetValues,
            unsigned int numArrayDimensions,
            bool computeMinMax,
            EML2_NS::AbstractHdfProxy* proxy = nullptr,
            unsigned int patchIndex = (std::numeric_limits<unsigned int>::max)()
        );
        using AbstractValuesProperty::setValuesOfFloatHdf5ArrayOfValues;
 
        DLL_IMPORT_OR_EXPORT static const char* XML_TAG;
 
        DLL_IMPORT_OR_EXPORT virtual std::string getXmlTag() const final { return XML_TAG; }
 
    protected:
 
        DLL_IMPORT_OR_EXPORT ContinuousProperty(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : RESQML2_NS::AbstractValuesProperty(partialObject) {}
 
        ContinuousProperty() {}
 
        ContinuousProperty(gsoap_resqml2_0_1::_resqml20__ContinuousProperty* fromGsoap) : AbstractValuesProperty(fromGsoap) {}
 
        ContinuousProperty(gsoap_eml2_3::_resqml22__ContinuousProperty* fromGsoap) : AbstractValuesProperty(fromGsoap) {}
 
        virtual size_t getMinimumValueSize() const = 0;
        virtual size_t getMaximumValueSize() const = 0;
 
    private:
 
        template <class T>
        void setPropertyMinMax(
            T const * values, 
            unsigned long long const * numValuesInEachDimension,
            unsigned int numArrayDimensions,
            T * minimumValue = nullptr, T * maximumValue = nullptr)
        {
            const unsigned int elementCount = getElementCountPerValue();
 
            // Some minimum and maximum values are given : No need to compute them.
            if (minimumValue != nullptr) {
                for (size_t propIndex = 0; propIndex < elementCount; ++propIndex) {
                    setMinimumValue(getMinimumValueSize() > propIndex ? fmin(getMinimumValue(propIndex), minimumValue[propIndex]) : minimumValue[propIndex], propIndex);
                }
            }
            if (maximumValue != nullptr) {
                for (size_t propIndex = 0; propIndex < elementCount; ++propIndex) {
                    setMaximumValue(getMaximumValueSize() > propIndex ? fmax(getMaximumValue(propIndex), maximumValue[propIndex]) : maximumValue[propIndex], propIndex);
                }
            }
            if (minimumValue != nullptr && maximumValue != nullptr) return; // No need to compute max or min value
 
            uint64_t nValues = numValuesInEachDimension[0];
            //If count > 1, the last (fastest) dimension has the number of properties per indexable element of the representation.
            for (unsigned int dim = 1; dim < (elementCount == 1 ? numArrayDimensions : numArrayDimensions - 1); ++dim) {
                nValues *= numValuesInEachDimension[dim];
            }
 
            // Minimum or maximum values are not given : Need to compute them.
            std::unique_ptr<T[]> allComputedMin(new T[elementCount]);
            std::unique_ptr<T[]> allComputedMax(new T[elementCount]);
            for (size_t propIndex = 0; propIndex < elementCount; ++propIndex) {
                allComputedMin[propIndex] = std::numeric_limits<T>::quiet_NaN();
                allComputedMax[propIndex] = std::numeric_limits<T>::quiet_NaN();
                for (size_t i = 0; i < nValues; i += elementCount) {
                    allComputedMin[propIndex] = fmin(allComputedMin[propIndex], values[i]);
                    allComputedMax[propIndex] = fmax(allComputedMax[propIndex], values[i]);
                }
            }
            setPropertyMinMax(values, numValuesInEachDimension, numArrayDimensions, allComputedMin.get(), allComputedMax.get());
        }
    };
}