StreamlinesRepresentation.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 "AbstractRepresentation.h"
 
namespace RESQML2_NS
{
    class AbstractGridRepresentation;
 
    class StreamlinesRepresentation : public AbstractRepresentation
    {
    public:
 
        StreamlinesRepresentation() {}
 
        DLL_IMPORT_OR_EXPORT StreamlinesRepresentation(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : AbstractRepresentation(partialObject) {}
 
        StreamlinesRepresentation(gsoap_resqml2_0_1::_resqml20__StreamlinesRepresentation* fromGsoap): AbstractRepresentation(fromGsoap) {}
 
        StreamlinesRepresentation(gsoap_eml2_3::_resqml22__StreamlinesRepresentation* fromGsoap) : AbstractRepresentation(fromGsoap) {}
 
        virtual ~StreamlinesRepresentation() = default;
 
        DLL_IMPORT_OR_EXPORT virtual uint32_t getLineCount() const = 0;
        
        //********************************
        //****  WELLBORE INFO ************
        //********************************
 
        DLL_IMPORT_OR_EXPORT virtual uint16_t getWellboreTrajectoryCount() const = 0;
 
        DLL_IMPORT_OR_EXPORT RESQML2_NS::WellboreTrajectoryRepresentation* getWellboreTrajectory(uint16_t index) const;
 
        virtual COMMON_NS::DataObjectReference getWellboreTrajectoryDor(uint16_t index) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual uint32_t getInjectorPerLine(uint32_t* injectorPerLine) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual uint32_t getProducerPerLine(uint32_t* producerPerLine) const = 0;
 
        void virtual setWellboreInformation(uint32_t const* injectorPerLine, uint32_t const* producerPerLine, const std::vector<RESQML2_NS::WellboreTrajectoryRepresentation*> & wellboreTrajectories,
            uint32_t nullValue = (std::numeric_limits<uint32_t>::max)(), EML2_NS::AbstractHdfProxy* hdfProxy = nullptr) = 0;
 
        //********************************
        //********** GEOMETRY ************
        //********************************
 
        DLL_IMPORT_OR_EXPORT virtual void getNodeCountPerLine(uint32_t * nodeCountPerPolyline) const = 0;
 
        DLL_IMPORT_OR_EXPORT uint64_t getXyzPointCountOfPatch(unsigned int patchIndex) const final {
            if (patchIndex > 0) {
                throw std::out_of_range("The patch index is out of range and should only be zero.");
            }
 
            const uint32_t lineCount = getLineCount();
            std::unique_ptr<uint32_t[]> nodeCountPerPolyline(new uint32_t[lineCount]);
            getNodeCountPerLine(nodeCountPerPolyline.get());
 
            uint64_t result = 0;
            for (uint32_t lineIndex = 0; lineIndex < lineCount; ++lineIndex) {
                result += nodeCountPerPolyline[lineIndex];
            }
            return result;
        }
 
        DLL_IMPORT_OR_EXPORT void getIntervalCountPerLine(uint32_t * intervalCountPerPolyline) const {
            getNodeCountPerLine(intervalCountPerPolyline);
 
            const uint32_t lineCount = getLineCount();
            for (uint32_t lineIndex = 0; lineIndex < lineCount; ++lineIndex) {
                intervalCountPerPolyline[lineIndex] -= 1;
            }
        }
 
        DLL_IMPORT_OR_EXPORT uint64_t getIntervalCount() const {
            const uint32_t lineCount = getLineCount();
            std::unique_ptr<uint32_t[]> intervalCountPerPolyline(new uint32_t[lineCount]);
            getIntervalCountPerLine (intervalCountPerPolyline.get());
 
            uint64_t result = 0;
            for (uint32_t lineIndex = 0; lineIndex < lineCount; ++lineIndex) {
                result += intervalCountPerPolyline[lineIndex];
            }
            return result;
        }
 
        DLL_IMPORT_OR_EXPORT virtual void setGeometry(
            uint32_t const * nodeCountPerPolyline, double const * xyzPoints,
            EML2_NS::AbstractHdfProxy* hdfProxy = nullptr, RESQML2_NS::AbstractLocal3dCrs* localCrs = nullptr) = 0;
 
        //********************************
        //*******  GRID INFO *************
        //********************************
 
        DLL_IMPORT_OR_EXPORT virtual void setIntervalGridCells(uint16_t const* gridIndices, uint16_t gridIndicesNullValue,
            int64_t const* cellIndices,
            uint8_t const* localFacePairPerCellIndices, uint8_t localFacePairPerCellIndicesNullValue,
            const std::vector<RESQML2_NS::AbstractGridRepresentation*> & supportingGrids,
            EML2_NS::AbstractHdfProxy * hdfProxy = nullptr) = 0;
 
        DLL_IMPORT_OR_EXPORT virtual uint16_t getGridIndices(uint16_t * gridIndices) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual int64_t getCellIndices(int64_t * cellIndices) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual uint8_t getLocalFacePairPerCellIndices(uint8_t * localFacePairPerCellIndices) const = 0;
 
        DLL_IMPORT_OR_EXPORT virtual uint16_t getGridRepresentationCount() const = 0;
 
        DLL_IMPORT_OR_EXPORT RESQML2_NS::AbstractGridRepresentation* getGridRepresentation(uint16_t index) const;
 
        virtual COMMON_NS::DataObjectReference getGridRepresentationDor(uint16_t index) const = 0;
 
        DLL_IMPORT_OR_EXPORT unsigned int getPatchCount() const final { return 1; }
 
        void loadTargetRelationships() final;
 
        DLL_IMPORT_OR_EXPORT static const char* XML_TAG;
 
        DLL_IMPORT_OR_EXPORT virtual std::string getXmlTag() const final { return XML_TAG; }
    };
}