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 <unordered_map>
#include <vector>
#include <stdexcept>
 
#include "DataObjectRepository.h"
 
namespace COMMON_NS
{
    class AbstractObject
    {
    private:
        static char citationFormat[];
 
        void setUuid(const std::string & uuid);
 
    protected:
        gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject;
 
        gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* gsoapProxy2_0_1;
 
        gsoap_eml2_1::eml21__AbstractObject* gsoapProxy2_1;
 
        gsoap_eml2_2::eml22__AbstractObject* gsoapProxy2_2;
 
        gsoap_eml2_3::eml23__AbstractObject* gsoapProxy2_3;
 
        COMMON_NS::DataObjectRepository* repository;
 
        AbstractObject() :
            partialObject(nullptr), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
 
        AbstractObject(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject_) :
            partialObject(partialObject_), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
        AbstractObject(const DataObjectReference& dor) :
            partialObject(dor.toDor20()), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
 
        AbstractObject(gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* proxy) :
            partialObject(nullptr), gsoapProxy2_0_1(proxy),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
 
        AbstractObject(gsoap_eml2_1::eml21__AbstractObject* proxy) :
            partialObject(nullptr), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(proxy),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
 
        AbstractObject(gsoap_eml2_2::eml22__AbstractObject* proxy) :
            partialObject(nullptr), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(proxy),
            gsoapProxy2_3(nullptr),
            repository(nullptr) {}
 
        AbstractObject(gsoap_eml2_3::eml23__AbstractObject* proxy) :
            partialObject(nullptr), gsoapProxy2_0_1(nullptr),
            gsoapProxy2_1(nullptr),
            gsoapProxy2_2(nullptr),
            gsoapProxy2_3(proxy),
            repository(nullptr) {}
 
        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 changeToPartialObject();
 
        void readArrayNdOfDoubleValues(gsoap_resqml2_0_1::resqml20__AbstractDoubleArray * arrayInput, double * arrayOutput) const;
 
        void readArrayNdOfDoubleValues(gsoap_eml2_3::eml23__AbstractFloatingPointArray * arrayInput, double * arrayOutput) const;
 
        template <class T>
        void readArrayNdOfNonHdf5IntegerValues(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray 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 unsigned int maximum value.");
                }
                for (unsigned int i = 0; i < static_cast<T>(rangeArray->Count); ++i) {
                    arrayOutput[i] = i + static_cast<T>(rangeArray->Value);
                }
                break;
            }
            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 (constantArray->Value > (std::numeric_limits<T>::max)()) {
                    throw std::range_error("The constant integer value is superior to unsigned int maximum value.");
                }
                for (size_t i = 0; i < constantArray->Count; ++i) {
                    arrayOutput[i] = static_cast<T>(constantArray->Value);
                }
                break;
            }
            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);
                }
                break;
            }
            default:
                throw std::invalid_argument("The integer array type is not supported yet.");
            }
        }
 
        template <class T>
        void readArrayNdOfNonHdf5IntegerValues(gsoap_eml2_3::eml23__AbstractIntegerArray const * arrayInput, T * arrayOutput) const {
            switch (arrayInput->soap_type()) {
            case SOAP_TYPE_gsoap_eml2_3_eml23__IntegerRangeArray:
            {
                gsoap_eml2_3::eml23__IntegerRangeArray const* rangeArray = static_cast<gsoap_eml2_3::eml23__IntegerRangeArray const*>(arrayInput);
                if (rangeArray->Value + rangeArray->Count > (std::numeric_limits<T>::max)()) {
                    throw std::range_error("The range integer values are superior to unsigned int maximum value.");
                }
                for (unsigned int i = 0; i < static_cast<T>(rangeArray->Count); ++i) {
                    arrayOutput[i] = i + static_cast<T>(rangeArray->Value);
                }
                break;
            }
            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 (constantArray->Value > (std::numeric_limits<T>::max)()) {
                    throw std::range_error("The constant integer value is superior to unsigned int maximum value.");
                }
                std::fill(arrayOutput, arrayOutput + constantArray->Count, static_cast<T>(constantArray->Value));
                break;
            }
            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.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);
                }
                break;
            }
            default: throw std::invalid_argument("The integer array type is not supported yet.");
            }
        }
 
        uint8_t readArrayNdOfUInt8Values(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray const * arrayInput, uint8_t * arrayOutput) const;
 
        uint8_t readArrayNdOfUInt8Values(gsoap_eml2_3::eml23__AbstractIntegerArray const * arrayInput, uint8_t * arrayOutput) const;
 
        uint16_t readArrayNdOfUInt16Values(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray const * arrayInput, uint16_t * arrayOutput) const;
 
        uint16_t readArrayNdOfUInt16Values(gsoap_eml2_3::eml23__AbstractIntegerArray const * arrayInput, uint16_t * arrayOutput) const;
 
        uint32_t readArrayNdOfUInt32Values(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray const * arrayInput, uint32_t * arrayOutput) const;
 
        uint32_t readArrayNdOfUInt32Values(gsoap_eml2_3::eml23__AbstractIntegerArray const * arrayInput, uint32_t * arrayOutput) const;
 
        uint64_t readArrayNdOfUInt64Values(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray const * arrayInput, uint64_t * arrayOutput) const;
 
        uint64_t readArrayNdOfUInt64Values(gsoap_eml2_3::eml23__AbstractIntegerArray const * arrayInput, uint64_t * arrayOutput) const;
 
        uint64_t getCountOfIntegerArray(gsoap_resqml2_0_1::resqml20__AbstractIntegerArray * arrayInput) const;
 
        uint64_t getCountOfIntegerArray(gsoap_eml2_3::eml23__AbstractIntegerArray * 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.");
                }
            }
            getRepository()->addRelationship(this, targetObj);
        }
 
        EML2_NS::AbstractHdfProxy* getHdfProxyFromDataset(gsoap_resqml2_0_1::eml20__Hdf5Dataset const * dataset, bool throwException = true) const;
 
        EML2_NS::AbstractHdfProxy* getHdfProxyFromDataset(gsoap_eml2_3::eml23__ExternalDatasetPart const * dataset, bool throwException = true) const;
 
        std::string getHdfGroup() const {
            return "/" + getXmlNamespace() + "/" + getUuid();
        }
 
        gsoap_resqml2_0_1::resqml20__IndexableElements mapIndexableElement(gsoap_eml2_3::resqml22__IndexableElement toMap) const;
 
    public:
 
        enum hdfDatatypeEnum { UNKNOWN = 0, DOUBLE = 1, FLOAT = 2, LONG_64 = 3, ULONG_64 = 4, INT = 5, UINT = 6, SHORT = 7, USHORT = 8, CHAR = 9, UCHAR = 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);
 
        void setGsoapProxy(gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* gsoapProxy) { gsoapProxy2_0_1 = gsoapProxy; }
 
        void setGsoapProxy(gsoap_eml2_1::eml21__AbstractObject* gsoapProxy) { gsoapProxy2_1 = gsoapProxy; }
 
        gsoap_resqml2_0_1::eml20__AbstractCitedDataObject* getEml20GsoapProxy() const { return gsoapProxy2_0_1; }
 
        gsoap_eml2_1::eml21__AbstractObject* getEml21GsoapProxy() const { return gsoapProxy2_1; }
 
        gsoap_eml2_2::eml22__AbstractObject* getEml22GsoapProxy() const { return gsoapProxy2_2; }
        void setGsoapProxy(gsoap_eml2_2::eml22__AbstractObject* gsoapProxy) { gsoapProxy2_2 = 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;
 
        DLL_IMPORT_OR_EXPORT gsoap_eml2_1::eml21__DataObjectReference* newEmlReference() const;
 
        gsoap_eml2_2::eml22__DataObjectReference* newEml22Reference() 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;
        
        virtual void loadTargetRelationships() = 0;
    };
}