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 unsigned int getAliasCount() const;
 
        DLL_IMPORT_OR_EXPORT std::string getAliasAuthorityAtIndex(unsigned int index) const;
 
        DLL_IMPORT_OR_EXPORT std::string getAliasTitleAtIndex(unsigned int index) const;
 
        DLL_IMPORT_OR_EXPORT std::vector<EML2_NS::Activity*> getActivitySet() const;
 
        DLL_IMPORT_OR_EXPORT unsigned int getActivityCount() const;
 
        DLL_IMPORT_OR_EXPORT EML2_NS::Activity* getActivity(unsigned int 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 unsigned int getExtraMetadataCount() const;
 
        DLL_IMPORT_OR_EXPORT std::string getExtraMetadataKeyAtIndex(unsigned int index) const;
 
        DLL_IMPORT_OR_EXPORT std::string getExtraMetadataStringValueAtIndex(unsigned int 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) {}
 
        
        friend bool COMMON_NS::DataObjectRepository::addDataObject(COMMON_NS::AbstractObject* proxy);
        friend COMMON_NS::AbstractObject* COMMON_NS::DataObjectRepository::addOrReplaceDataObject(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);
 
        void cannotBePartial() const;
 
        void readArrayNdOfFloatValues(gsoap_resqml2_0_1::resqml20__AbstractDoubleArray const* arrayInput, float* arrayOutput) const;
 
        void readArrayNdOfFloatValues(gsoap_eml2_3::eml23__AbstractFloatingPointArray const* arrayInput, float* arrayOutput) const;
 
        void readArrayNdOfDoubleValues(gsoap_resqml2_0_1::resqml20__AbstractDoubleArray const* arrayInput, double * arrayOutput) const;
 
        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 (rangeArray->Value + rangeArray->Count > (std::numeric_limits<T>::max)()) {
                    throw std::range_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);
                if (sizeof(constantArray->Value) > sizeof(T) && constantArray->Value > (std::numeric_limits<T>::max)()) {
                    throw std::range_error("The constant integer value is superior to maximum value of read datatype.");
                }
                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__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.");
                }
                for (size_t i = 0; i <= latticeArray->Offset[0]->Count; ++i) {
                    arrayOutput[i] = latticeArray->StartValue + (i * 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 (sizeof(constantArray->Value) > sizeof(T) && constantArray->Value > (std::numeric_limits<T>::max)()) {
                    throw std::range_error("The constant integer value is superior to maximum value of read 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
#if !defined(__GLIBCXX__) || __GLIBCXX__ > 20150623 || __GLIBCXX__ == 20140422 || __GLIBCXX__ == 20140716 || __GLIBCXX__ == 20141030
                std::sregex_token_iterator it(xmlArray->Values.begin(), xmlArray->Values.end(), ws_re, -1);
                std::sregex_token_iterator endToken;
#else
                boost::sregex_token_iterator it(xmlArray->Values.begin(), xmlArray->Values.end(), ws_re, -1);
                boost::sregex_token_iterator endToken;
#endif
                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;
 
        uint8_t readArrayNdOfUInt8Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint8_t * arrayOutput) const;
 
        uint8_t readArrayNdOfUInt8Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint8_t * arrayOutput) const;
 
        uint16_t readArrayNdOfUInt16Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint16_t * arrayOutput) const;
 
        uint16_t readArrayNdOfUInt16Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint16_t * arrayOutput) const;
 
        uint32_t readArrayNdOfUInt32Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint32_t * arrayOutput) const;
 
        uint32_t readArrayNdOfUInt32Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint32_t * arrayOutput) const;
 
        uint64_t readArrayNdOfUInt64Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, uint64_t * arrayOutput) const;
 
        uint64_t readArrayNdOfUInt64Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, uint64_t * arrayOutput) const;
 
        int8_t readArrayNdOfInt8Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int8_t * arrayOutput) const;
 
        int8_t readArrayNdOfInt8Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int8_t * arrayOutput) const;
 
        int16_t readArrayNdOfInt16Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int16_t * arrayOutput) const;
 
        int16_t readArrayNdOfInt16Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int16_t * arrayOutput) const;
 
        int32_t readArrayNdOfInt32Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int32_t * arrayOutput) const;
 
        int32_t readArrayNdOfInt32Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int32_t * arrayOutput) const;
 
        int64_t readArrayNdOfInt64Values(gsoap_resqml2_0_1::resqml20__AbstractValueArray const* arrayInput, int64_t * arrayOutput) const;
 
        int64_t readArrayNdOfInt64Values(gsoap_eml2_3::eml23__AbstractValueArray const* arrayInput, int64_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);
    };
}