AbstractObject.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 <regex>
#include <sstream>
#include <stdexcept>
#include <unordered_map>
#include <vector>
 
#include "DataObjectRepository.h"
 
namespace COMMON_NS
{
    class AbstractObject
    {
    public:

        enum class numericalDatatypeEnum { UNKNOWN = 0, DOUBLE = 1, FLOAT = 2, INT64 = 3, UINT64 = 4, INT32 = 5, UINT32 = 6, INT16 = 7, UINT16 = 8, INT8 = 9, UINT8 = 10};
 
        DLL_IMPORT_OR_EXPORT virtual ~AbstractObject() = default;

        DLL_IMPORT_OR_EXPORT bool isPartial() const;

        DLL_IMPORT_OR_EXPORT virtual bool isTopLevelElement() const { return true; }

        DLL_IMPORT_OR_EXPORT std::string getUuid() const;

        DLL_IMPORT_OR_EXPORT std::string getTitle() const;

        DLL_IMPORT_OR_EXPORT std::string getEditor() const;

        DLL_IMPORT_OR_EXPORT time_t getCreation() const;

        DLL_IMPORT_OR_EXPORT tm getCreationAsTimeStructure() const;

        DLL_IMPORT_OR_EXPORT std::string getOriginator() const;

        DLL_IMPORT_OR_EXPORT std::string getDescription() const;

        DLL_IMPORT_OR_EXPORT time_t getLastUpdate() const;

        DLL_IMPORT_OR_EXPORT tm getLastUpdateAsTimeStructure() const;

        DLL_IMPORT_OR_EXPORT std::string getFormat() const;

        DLL_IMPORT_OR_EXPORT std::string getDescriptiveKeywords() const;

        DLL_IMPORT_OR_EXPORT std::string getVersion() const;

        DLL_IMPORT_OR_EXPORT void setTitle(const std::string & title);

        DLL_IMPORT_OR_EXPORT void setEditor(const std::string & editor);

        DLL_IMPORT_OR_EXPORT void setCreation(time_t creation);

        DLL_IMPORT_OR_EXPORT void setCreation(const tm & creation);

        DLL_IMPORT_OR_EXPORT void setOriginator(const std::string & originator);

        DLL_IMPORT_OR_EXPORT void setDescription(const std::string & description);

        DLL_IMPORT_OR_EXPORT void setLastUpdate(time_t lastUpdate);

        DLL_IMPORT_OR_EXPORT void setLastUpdate(const tm & lastUpdate);

        DLL_IMPORT_OR_EXPORT static void setFormat(const std::string & vendor, const std::string & applicationName, const std::string & applicationVersionNumber);

        DLL_IMPORT_OR_EXPORT void setDescriptiveKeywords(const std::string & descriptiveKeywords);

        DLL_IMPORT_OR_EXPORT void setVersion(const std::string & version);

        DLL_IMPORT_OR_EXPORT void setMetadata(const std::string & title, const std::string & editor, time_t creation, const std::string & originator,
            const std::string & description, time_t lastUpdate, const std::string & descriptiveKeywords);

        DLL_IMPORT_OR_EXPORT void serializeIntoStream(std::ostream * stream);

        gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* getEml20GsoapProxy() const { return gsoapProxy2_0_1; }
        void setGsoapProxy(gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* gsoapProxy) { gsoapProxy2_0_1 = gsoapProxy; }

        gsoap_eml2_3::eml23__AbstractObject* getEml23GsoapProxy() const { return gsoapProxy2_3; }
        void setGsoapProxy(gsoap_eml2_3::eml23__AbstractObject* gsoapProxy) { gsoapProxy2_3 = gsoapProxy; }

        soap* getGsoapContext() const;

        int getGsoapType() const;

        gsoap_resqml2_0_1::eml20__DataObjectReference* newResqmlReference() const;

        gsoap_eml2_3::eml23__DataObjectReference* newEml23Reference() const;

        gsoap_resqml2_0_1::resqml20__ContactElementReference* newContactElementReference2_0_1() const;

        gsoap_eml2_3::resqml22__ContactElement* newContactElementReference2_2() const;

        DLL_IMPORT_OR_EXPORT COMMON_NS::DataObjectRepository* getRepository() const {return repository;}

        DLL_IMPORT_OR_EXPORT virtual std::string getXmlNamespace() const = 0;

        DLL_IMPORT_OR_EXPORT virtual std::string getXmlTag() const = 0;

        DLL_IMPORT_OR_EXPORT virtual std::string getXmlNamespaceVersion() const;

        DLL_IMPORT_OR_EXPORT virtual std::string getContentType() const;

        DLL_IMPORT_OR_EXPORT virtual std::string getQualifiedType() const;
        
        DLL_IMPORT_OR_EXPORT virtual std::string getPartNameInEpcDocument() const;

        DLL_IMPORT_OR_EXPORT std::string serializeIntoString();

        DLL_IMPORT_OR_EXPORT void addAlias(const std::string & authority, const std::string & title);

        DLL_IMPORT_OR_EXPORT uint64_t getAliasCount() const;

        DLL_IMPORT_OR_EXPORT std::string getAliasAuthorityAtIndex(uint64_t index) const;

        DLL_IMPORT_OR_EXPORT std::string getAliasTitleAtIndex(uint64_t index) const;

        DLL_IMPORT_OR_EXPORT std::vector<EML2_NS::Activity*> getActivitySet() const;

        DLL_IMPORT_OR_EXPORT uint64_t getActivityCount() const;

        DLL_IMPORT_OR_EXPORT EML2_NS::Activity* getActivity(uint64_t index) const;

        DLL_IMPORT_OR_EXPORT void pushBackExtraMetadata(const std::string & key, const std::string & value);

        DLL_IMPORT_OR_EXPORT std::unordered_map< std::string, std::string > getExtraMetadataSet() const;

        DLL_IMPORT_OR_EXPORT std::vector<std::string> getExtraMetadata(const std::string & key) const;

        DLL_IMPORT_OR_EXPORT uint64_t getExtraMetadataCount() const;

        DLL_IMPORT_OR_EXPORT std::string getExtraMetadataKeyAtIndex(uint64_t index) const;

        DLL_IMPORT_OR_EXPORT std::string getExtraMetadataStringValueAtIndex(uint64_t index) const;
        
        DLL_IMPORT_OR_EXPORT std::string buildEtp12Uri() const {
            std::string tmp = uriSource_.empty() ? "eml:///" : uriSource_;
            return (tmp.back() == '/' ? tmp : tmp + '/') + getQualifiedType() + '(' + getUuid() + ')';
        }

        DLL_IMPORT_OR_EXPORT void setUriSource(const std::string & uriSource) { uriSource_ = uriSource; }

        DLL_IMPORT_OR_EXPORT const std::string& getUriSource() const { return uriSource_; }

        std::string getEpcSourceFolder() const {
            if (uriSource_.find(".epc") != uriSource_.size() - 4 &&
                uriSource_.find(".EPC") != uriSource_.size() - 4) {
                return "";
            }
 
            const size_t slashPos = uriSource_.find_last_of("/\\");
            return slashPos != std::string::npos ? uriSource_.substr(0, slashPos + 1) : "";
        }

        void changeToPartialObject();
        
        virtual void loadTargetRelationships() = 0;
 
    protected:
        gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject;

        gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* gsoapProxy2_0_1;

        gsoap_eml2_3::eml23__AbstractObject* gsoapProxy2_3;

        COMMON_NS::DataObjectRepository* repository;

        AbstractObject() :
            partialObject(nullptr),
            gsoapProxy2_0_1(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}

        AbstractObject(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject_) :
            partialObject(partialObject_),
            gsoapProxy2_0_1(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
        AbstractObject(const DataObjectReference& dor) :
            partialObject(dor.toDor20()),
            gsoapProxy2_0_1(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}

        AbstractObject(gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* proxy) :
            partialObject(nullptr),
            gsoapProxy2_0_1(proxy),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}

        AbstractObject(gsoap_eml2_3::eml23__AbstractObject* proxy) :
            partialObject(nullptr),
            gsoapProxy2_0_1(nullptr),
            gsoapProxy2_3(proxy),
            repository(nullptr) {}
 
        //This class is non copyable (non movable) since it is designed to be owned by a DataObjectRepository
        AbstractObject(const AbstractObject&) = delete;
        AbstractObject& operator=(const AbstractObject&) = delete;
 
        friend bool COMMON_NS::DataObjectRepository::addDataObject(std::unique_ptr<COMMON_NS::AbstractObject> proxy);
        friend COMMON_NS::AbstractObject* COMMON_NS::DataObjectRepository::addOrReplaceDataObject(std::unique_ptr<COMMON_NS::AbstractObject> proxy, bool replaceOnlyContent);

        void initMandatoryMetadata();

        void setMetadata(const std::string & guid, const std::string & title, const std::string & editor, time_t creation, const std::string & originator,
            const std::string & description, time_t lastUpdate, const std::string & descriptiveKeywords);

        DLL_IMPORT_OR_EXPORT void cannotBePartial() const;

        DLL_IMPORT_OR_EXPORT void readArrayNdOfFloatValues(gsoap_resqml2_0_1::resqml20__AbstractDoubleArray const* arrayInput, float* arrayOutput) const;

        DLL_IMPORT_OR_EXPORT void readArrayNdOfFloatValues(gsoap_eml2_3::eml23__AbstractFloatingPointArray const* arrayInput, float* arrayOutput) const;

        DLL_IMPORT_OR_EXPORT void readArrayNdOfDoubleValues(gsoap_resqml2_0_1::resqml20__AbstractDoubleArray const* arrayInput, double * arrayOutput) const;

        DLL_IMPORT_OR_EXPORT void readArrayNdOfDoubleValues(gsoap_eml2_3::eml23__AbstractFloatingPointArray const* arrayInput, double * arrayOutput) const;
 
        template <class T>
        T readArrayNdOfNonHdf5IntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const * arrayInput, T * arrayOutput) const {
            switch (arrayInput->soap_type()) {
            case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerRangeArray:
            {
                gsoap_resqml2_0_1::resqml20__IntegerRangeArray const* rangeArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerRangeArray const *>(arrayInput);
                if constexpr (std::is_signed_v<T>) {
                    if (rangeArray->Value < (std::numeric_limits<T>::min)()) {
                        throw std::overflow_error("Too low integers in XML for the C++ chosen datatype");
                    }
                }
                else {
                    if (rangeArray->Value < 0 ) {
                        throw std::underflow_error("Cannot deal with negative values when using unsigned integer");
                    }
                }
                if (rangeArray->Value + rangeArray->Count > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
                    throw std::overflow_error("The range integer values are superior to maximum value of read datatype.");
                }
                for (T i = 0; i < static_cast<T>(rangeArray->Count); ++i) {
                    arrayOutput[i] = i + static_cast<T>(rangeArray->Value);
                }
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerConstantArray:
            {
                gsoap_resqml2_0_1::resqml20__IntegerConstantArray const* constantArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerConstantArray const*>(arrayInput);
                T value;
                if constexpr (std::is_signed_v<T>) {
                    value = static_cast<T>(std::clamp(constantArray->Value,
                        static_cast<int64_t>((std::numeric_limits<T>::min)()), static_cast<int64_t>((std::numeric_limits<T>::max)())));
                }
                else {
                    value = constantArray->Value > 0
                        ? static_cast<T>(std::clamp(static_cast<uint64_t>(constantArray->Value), static_cast<uint64_t>(0), static_cast<uint64_t>((std::numeric_limits<T>::max)())))
                        : (std::numeric_limits<T>::max)();
                }
                std::fill(arrayOutput, arrayOutput + constantArray->Count, value);
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__BooleanConstantArray:
            {
                gsoap_resqml2_0_1::resqml20__BooleanConstantArray const* constantArray = static_cast<gsoap_resqml2_0_1::resqml20__BooleanConstantArray const*>(arrayInput);
                std::fill(arrayOutput, arrayOutput + constantArray->Count, static_cast<T>(constantArray->Value));
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerLatticeArray:
            {
                gsoap_resqml2_0_1::resqml20__IntegerLatticeArray const* latticeArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerLatticeArray const*>(arrayInput);
                if (latticeArray->Offset.size() > 1) {
                    throw std::invalid_argument("The integer lattice array contains more than one offset.");
                }
                if constexpr (std::is_signed_v<T>) {
                    if (latticeArray->StartValue < (std::numeric_limits<T>::min)() || latticeArray->Offset[0]->Value < (std::numeric_limits<T>::min)()) {
                        throw std::underflow_error("Too low integers in XML for the C++ chosen datatype");
                    }
                    if (latticeArray->StartValue > (std::numeric_limits<T>::max)() ||
                        latticeArray->Offset[0]->Value > (std::numeric_limits<T>::max)()) {
                        throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
                    }
                }
                else {
                    if (latticeArray->StartValue < 0 || latticeArray->Offset[0]->Value < 0) {
                        throw std::underflow_error("Cannot deal with negative values when using unsigned integer");
                    }
                    if (static_cast<uint64_t>(latticeArray->StartValue) > (std::numeric_limits<T>::max)() ||
                        static_cast<uint64_t>(latticeArray->Offset[0]->Value) > (std::numeric_limits<T>::max)()) {
                        throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
                    }
                }
                for (uint64_t i = 0; i <= latticeArray->Offset[0]->Count; ++i) {
                    arrayOutput[i] = static_cast<T>(latticeArray->StartValue) + (i * static_cast<T>(latticeArray->Offset[0]->Value));
                }
                return (std::numeric_limits<T>::max)();
            }
            default:
                throw std::invalid_argument("The integer array type is not supported yet.");
            }
        }
 
        template <class T>
        T readArrayNdOfNonHdf5IntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const * arrayInput, T * arrayOutput) const {
            switch (arrayInput->soap_type()) {
            case SOAP_TYPE_gsoap_eml2_3_eml23__IntegerConstantArray:
            {
                gsoap_eml2_3::eml23__IntegerConstantArray const* constantArray = static_cast<gsoap_eml2_3::eml23__IntegerConstantArray const*>(arrayInput);
                if constexpr (std::is_signed_v<T>) {
                    if (constantArray->Value < (std::numeric_limits<T>::min)()) {
                        throw std::underflow_error("Too low integers in XML for the C++ chosen datatype");
                    }
                    if (constantArray->Value > (std::numeric_limits<T>::max)()) {
                        throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
                    }
                }
                else {
                    if (constantArray->Value < 0) {
                        throw std::underflow_error("Cannot deal with negative values when using unsigned integer");
                    }
                    if (static_cast<uint64_t>(constantArray->Value) > (std::numeric_limits<T>::max)()) {
                        throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
                    }
                }
                std::fill(arrayOutput, arrayOutput + constantArray->Count, static_cast<T>(constantArray->Value));
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_eml2_3_eml23__BooleanConstantArray:
            {
                gsoap_eml2_3::eml23__BooleanConstantArray const* constantArray = static_cast<gsoap_eml2_3::eml23__BooleanConstantArray const*>(arrayInput);
                std::fill(arrayOutput, arrayOutput + constantArray->Count, static_cast<T>(constantArray->Value));
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_eml2_3_eml23__IntegerLatticeArray:
            {
                gsoap_eml2_3::eml23__IntegerLatticeArray const* latticeArray = static_cast<gsoap_eml2_3::eml23__IntegerLatticeArray const*>(arrayInput);
                if (latticeArray->Offset.empty() || latticeArray->Offset.size() > 1) {
                    throw std::invalid_argument("The integer lattice array of UUID " + getUuid() + " contains zero or more than one offset.");
                }
                if (latticeArray->Offset[0]->Count < 0) {
                    throw std::invalid_argument("The count of the integer lattice array of UUID " + getUuid() + " is negative which is not valid.");
                }
 
                for (size_t i = 0; i <= static_cast<size_t>(latticeArray->Offset[0]->Count); ++i) {
                    arrayOutput[i] = latticeArray->StartValue + (i * latticeArray->Offset[0]->Value);
                }
                return (std::numeric_limits<T>::max)();
            }
            case SOAP_TYPE_gsoap_eml2_3_eml23__IntegerXmlArray:
            {
                gsoap_eml2_3::eml23__IntegerXmlArray const * xmlArray = static_cast<gsoap_eml2_3::eml23__IntegerXmlArray const*>(arrayInput);
                const std::regex ws_re("\\s+"); // whitespace
                std::sregex_token_iterator it(xmlArray->Values.begin(), xmlArray->Values.end(), ws_re, -1);
                std::sregex_token_iterator endToken;
                size_t index = 0;
                while (it != endToken) {
                    arrayOutput[index++] = std::stoll(*it++);
                }
                return (std::numeric_limits<T>::max)();
            }
            default: throw std::invalid_argument("The integer array type is not supported yet.");
            }
        }

        void readArrayNdOfBooleanValues(gsoap_eml2_3::eml23__BooleanExternalArray const * arrayInput, int8_t * arrayOutput) const;

        template<typename T>
        T readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, T* arrayOutput) const;

        template<typename T>
        T readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, T* arrayOutput) const;

        uint64_t getCountOfArray(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput) const;

        uint64_t getCountOfArray(gsoap_eml2_3::eml23__AbstractValueArray const * arrayInput) const;

        void convertDorIntoRel(const DataObjectReference& dor);

        template <class valueType>
        void convertDorIntoRel(const DataObjectReference& dor)
        {
            valueType * targetObj = getRepository()->getDataObjectByUuid<valueType>(dor.getUuid());
            if (targetObj == nullptr) { // partial transfer
                getRepository()->createPartial(dor);
                targetObj = getRepository()->getDataObjectByUuid<valueType>(dor.getUuid());
                if (targetObj == nullptr) {
                    throw std::invalid_argument("The DOR looks invalid.");
                }
                targetObj->setUriSource(getUriSource());
            }
            getRepository()->addRelationship(this, targetObj);
        }

        EML2_NS::AbstractHdfProxy* getHdfProxyFromDataset(gsoap_resqml2_0_1::eml20__Hdf5Dataset const * dataset, bool throwException = true) const;

        EML2_NS::AbstractHdfProxy* getOrCreateHdfProxyFromDataArrayPart(gsoap_eml2_3::eml23__ExternalDataArrayPart const * dataArrayPart) const;

        std::string getHdfGroup() const {
            return "/" + getXmlNamespace() + "/" + getUuid();
        }

        gsoap_eml2_3::eml23__ExternalDataArrayPart* createExternalDataArrayPart(const std::string& datasetName, LONG64 count, EML2_NS::AbstractHdfProxy* proxy = nullptr) const;
 
        gsoap_resqml2_0_1::resqml20__IndexableElements mapIndexableElement(gsoap_eml2_3::eml23__IndexableElement toMap) const;
 
    private:
        static char citationFormat[];

        std::string uriSource_;

        void setUuid(const std::string & uuid);
    };
 
    template<> DLL_IMPORT_OR_EXPORT int8_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int8_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint8_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint8_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int16_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int16_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint16_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint16_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int32_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int32_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint32_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint32_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int64_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int64_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint64_t AbstractObject::readArrayNdOfIntegerValues(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint64_t* arrayOutput) const;
    
    template<> DLL_IMPORT_OR_EXPORT int8_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int8_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint8_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint8_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int16_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int16_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint16_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint16_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int32_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int32_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint32_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint32_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT int64_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int64_t* arrayOutput) const;
    template<> DLL_IMPORT_OR_EXPORT uint64_t AbstractObject::readArrayNdOfIntegerValues(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint64_t* arrayOutput) const;
}