File indexing completed on 2024-05-12 03:50:14

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2008 Patrick Spendrin <ps_ml@gmx.de>
 //
 
 
 #include "GeoDataMultiGeometry.h"
 #include "GeoDataMultiGeometry_p.h"
 
 #include "GeoDataLineString.h"
 #include "GeoDataLinearRing.h"
 #include "GeoDataPoint.h"
 #include "GeoDataPolygon.h"
 #include "GeoDataTypes.h"
 
 #include "MarbleDebug.h"
 
 #include <QDataStream>
 
 
 namespace Marble
 {
 
 GeoDataMultiGeometry::GeoDataMultiGeometry()
     : GeoDataGeometry( new GeoDataMultiGeometryPrivate )
 {
 }
 
 GeoDataMultiGeometry::GeoDataMultiGeometry( const GeoDataGeometry& other )
     : GeoDataGeometry( other )
 {
 }
 
 GeoDataMultiGeometry::~GeoDataMultiGeometry()
 {
 }
 
 const char *GeoDataMultiGeometry::nodeType() const
 {
     return GeoDataTypes::GeoDataMultiGeometryType;
 }
 
 EnumGeometryId GeoDataMultiGeometry::geometryId() const
 {
     return GeoDataMultiGeometryId;
 }
 
 GeoDataGeometry *GeoDataMultiGeometry::copy() const
 {
     return new GeoDataMultiGeometry(*this);
 }
 
 bool GeoDataMultiGeometry::operator==(const GeoDataMultiGeometry &other) const
 {
     Q_D(const GeoDataMultiGeometry);
     const GeoDataMultiGeometryPrivate *const other_d = other.d_func();
     QVector<GeoDataGeometry*>::const_iterator thisBegin = d->m_vector.constBegin();
     QVector<GeoDataGeometry*>::const_iterator thisEnd = d->m_vector.constEnd();
     QVector<GeoDataGeometry*>::const_iterator otherBegin = other_d->m_vector.constBegin();
     QVector<GeoDataGeometry*>::const_iterator otherEnd = other_d->m_vector.constEnd();
 
     for (; thisBegin != thisEnd && otherBegin != otherEnd; ++thisBegin, ++otherBegin) {
         if (**thisBegin != **otherBegin) {
             return false;
         }
     }
 
     return true;
 }
 
 const GeoDataLatLonAltBox& GeoDataMultiGeometry::latLonAltBox() const
 {
     Q_D(const GeoDataMultiGeometry);
 
     QVector<GeoDataGeometry*>::const_iterator it = d->m_vector.constBegin();
     QVector<GeoDataGeometry*>::const_iterator end = d->m_vector.constEnd();
 
     d->m_latLonAltBox.clear();
     for (; it != end; ++it) {
         if ( !(*it)->latLonAltBox().isEmpty() ) {
             if ( d->m_latLonAltBox.isEmpty() ) {
                 d->m_latLonAltBox = (*it)->latLonAltBox();
             }
             else {
                 d->m_latLonAltBox |= (*it)->latLonAltBox();
             }
         }
     }
     return d->m_latLonAltBox;
 }
 
 int GeoDataMultiGeometry::size() const
 {
     Q_D(const GeoDataMultiGeometry);
     return d->m_vector.size();
 }
 
 QVector<GeoDataGeometry *> GeoDataMultiGeometry::vector()
 {
     Q_D(const GeoDataMultiGeometry);
 
     return d->m_vector;
 }
 
 GeoDataGeometry& GeoDataMultiGeometry::at( int pos )
 {
     mDebug() << "detaching!";
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return *(d->m_vector[pos]);
 }
 
 const GeoDataGeometry& GeoDataMultiGeometry::at( int pos ) const
 {
     Q_D(const GeoDataMultiGeometry);
     return *(d->m_vector.at(pos));
 }
 
 GeoDataGeometry& GeoDataMultiGeometry::operator[]( int pos )
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return *(d->m_vector[pos]);
 }
 
 const GeoDataGeometry& GeoDataMultiGeometry::operator[]( int pos ) const
 {
     Q_D(const GeoDataMultiGeometry);
     return *(d->m_vector[pos]);
 }
 
 GeoDataGeometry& GeoDataMultiGeometry::last()
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return *(d->m_vector.last());
 }
 
 GeoDataGeometry& GeoDataMultiGeometry::first()
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return *(d->m_vector.first());
 }
 
 const GeoDataGeometry& GeoDataMultiGeometry::last() const
 {
     Q_D(const GeoDataMultiGeometry);
     return *(d->m_vector.last());
 }
 
 const GeoDataGeometry& GeoDataMultiGeometry::first() const
 {
     Q_D(const GeoDataMultiGeometry);
     return *(d->m_vector.first());
 }
 
 QVector<GeoDataGeometry*>::Iterator GeoDataMultiGeometry::begin()
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return d->m_vector.begin();
 }
 
 QVector<GeoDataGeometry*>::Iterator GeoDataMultiGeometry::end()
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return d->m_vector.end();
 }
 
 QVector<GeoDataGeometry*>::ConstIterator GeoDataMultiGeometry::constBegin() const
 {
     Q_D(const GeoDataMultiGeometry);
     return d->m_vector.constBegin();
 }
 
 QVector<GeoDataGeometry*>::ConstIterator GeoDataMultiGeometry::constEnd() const
 {
     Q_D(const GeoDataMultiGeometry);
     return d->m_vector.constEnd();
 }
 
 /**
  * @brief  returns the requested child item
  */
 GeoDataGeometry* GeoDataMultiGeometry::child( int i )
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     return d->m_vector.at(i);
 }
 
 const GeoDataGeometry* GeoDataMultiGeometry::child( int i ) const
 {
     Q_D(const GeoDataMultiGeometry);
     return d->m_vector.at(i);
 }
 
 /**
  * @brief returns the position of an item in the list
  */
 int GeoDataMultiGeometry::childPosition( const GeoDataGeometry *object ) const
 {
     Q_D(const GeoDataMultiGeometry);
     for (int i = 0; i < d->m_vector.size(); ++i) {
         if (d->m_vector.at(i) == object) {
             return i;
         }
     }
     return -1;
 }
 
 /**
 * @brief add an element
 */
 void GeoDataMultiGeometry::append( GeoDataGeometry *other )
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     other->setParent( this );
     d->m_vector.append(other);
 }
 
 
 GeoDataMultiGeometry& GeoDataMultiGeometry::operator << ( const GeoDataGeometry& value )
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     GeoDataGeometry *g = value.copy();
     g->setParent( this );
     d->m_vector.append(g);
     return *this;
 }
 
 void GeoDataMultiGeometry::clear()
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     qDeleteAll(d->m_vector);
     d->m_vector.clear();
 }
 
 void GeoDataMultiGeometry::pack( QDataStream& stream ) const
 {
     Q_D(const GeoDataMultiGeometry);
 
     GeoDataGeometry::pack( stream );
 
     stream << d->m_vector.size();
 
     for( QVector<GeoDataGeometry*>::const_iterator iterator
           = d->m_vector.constBegin();
          iterator != d->m_vector.constEnd();
          ++iterator ) {
         const GeoDataGeometry *geometry = *iterator;
         stream << geometry->geometryId();
         geometry->pack( stream );
     }
 }
 
 void GeoDataMultiGeometry::unpack( QDataStream& stream )
 {
     detach();
 
     Q_D(GeoDataMultiGeometry);
     GeoDataGeometry::unpack( stream );
 
     int size = 0;
     
     stream >> size;
     
     for( int i = 0; i < size; i++ ) {
         int geometryId;
         stream >> geometryId;
         switch( geometryId ) {
             case InvalidGeometryId:
                 break;
             case GeoDataPointId:
                 {
                 GeoDataPoint *point = new GeoDataPoint;
                 point->unpack( stream );
                 d->m_vector.append(point);
                 }
                 break;
             case GeoDataLineStringId:
                 {
                 GeoDataLineString *lineString = new GeoDataLineString;
                 lineString->unpack( stream );
                 d->m_vector.append(lineString);
                 }
                 break;
             case GeoDataLinearRingId:
                 {
                 GeoDataLinearRing *linearRing = new GeoDataLinearRing;
                 linearRing->unpack( stream );
                 d->m_vector.append(linearRing);
                 }
                 break;
             case GeoDataPolygonId:
                 {
                 GeoDataPolygon *polygon = new GeoDataPolygon;
                 polygon->unpack( stream );
                 d->m_vector.append(polygon);
                 }
                 break;
             case GeoDataMultiGeometryId:
                 {
                 GeoDataMultiGeometry *multiGeometry = new GeoDataMultiGeometry;
                 multiGeometry->unpack( stream );
                 d->m_vector.append(multiGeometry);
                 }
                 break;
             case GeoDataModelId:
                 break;
             default: break;
         };
     }
 }
 
 }