GeoJsonObject.h

#pragma once
 
#include <CesiumGeometry/AxisAlignedBox.h>
#include <CesiumVectorData/GeoJsonObjectTypes.h>
#include <CesiumVectorData/VectorStyle.h>
 
#include <array>
#include <vector>
 
namespace CesiumVectorData {
 
struct GeoJsonObjectIterator;
struct ConstGeoJsonObjectIterator;
template <typename TSingle, typename TMulti, typename TValue>
struct ConstGeoJsonPrimitiveIterator;
template <typename TObject> struct ConstGeoJsonObjectTypeIterator;

using ConstGeoJsonPointIterator =
    ConstGeoJsonPrimitiveIterator<GeoJsonPoint, GeoJsonMultiPoint, glm::dvec3>;
using ConstGeoJsonLineStringIterator = ConstGeoJsonPrimitiveIterator<
    GeoJsonLineString,
    GeoJsonMultiLineString,
    std::vector<glm::dvec3>>;
using ConstGeoJsonPolygonIterator = ConstGeoJsonPrimitiveIterator<
    GeoJsonPolygon,
    GeoJsonMultiPolygon,
    std::vector<std::vector<glm::dvec3>>>;

struct GeoJsonObject {
  template <typename TIterator> struct IteratorProvider {
    TIterator begin() { return TIterator(*this->_pObject); }

    TIterator end() { return TIterator(); }
 
  private:
    IteratorProvider(const GeoJsonObject* pObject) : _pObject(pObject) {}
 
    const GeoJsonObject* _pObject;
    friend struct GeoJsonObject;
  };

  GeoJsonObjectIterator begin();
  GeoJsonObjectIterator end();

  ConstGeoJsonObjectIterator begin() const;
  ConstGeoJsonObjectIterator end() const;

  IteratorProvider<ConstGeoJsonPointIterator> points() const;

  IteratorProvider<ConstGeoJsonLineStringIterator> lines() const;

  IteratorProvider<ConstGeoJsonPolygonIterator> polygons() const;

  template <typename TObject>
  IteratorProvider<ConstGeoJsonObjectTypeIterator<TObject>> allOfType() const {
    return IteratorProvider<ConstGeoJsonObjectTypeIterator<TObject>>(this);
  }

  const std::optional<CesiumGeometry::AxisAlignedBox>& getBoundingBox() const;

  std::optional<CesiumGeometry::AxisAlignedBox>& getBoundingBox();

  const CesiumUtility::JsonValue::Object& getForeignMembers() const;

  CesiumUtility::JsonValue::Object& getForeignMembers();

  const std::optional<VectorStyle>& getStyle() const;

  std::optional<VectorStyle>& getStyle();

  GeoJsonObjectType getType() const;

  template <typename T> bool isType() const {
    return std::holds_alternative<T>(this->value);
  }

  template <typename T> const T& get() const {
    return std::get<T>(this->value);
  }

  template <typename T> T& get() { return std::get<T>(this->value); }

  template <typename T> const T* getIf() const {
    return std::get_if<T>(&this->value);
  }

  template <typename T> T* getIf() { return std::get_if<T>(&this->value); }

  template <typename Visitor> decltype(auto) visit(Visitor&& visitor) {
    return std::visit(std::forward<Visitor>(visitor), this->value);
  }

  template <typename Visitor> decltype(auto) visit(Visitor&& visitor) const {
    return std::visit(std::forward<Visitor>(visitor), this->value);
  }

  GeoJsonObjectVariant value;
};

struct GeoJsonObjectIterator {
private:
  static constexpr size_t StackSize = 8;
  struct IteratorStackState {
    GeoJsonObject* pObject;
    int64_t nextPos;
  };
 
public:
  // Ignore Doxygen warnings for iterator tags.
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = GeoJsonObject;
  using pointer = GeoJsonObject*;
  using reference = GeoJsonObject&;

  reference operator*() const { return *_pCurrentObject; }
  pointer operator->() { return _pCurrentObject; }

  GeoJsonObject* getFeature() const {
    for (int64_t i = this->_stackPos; i >= 0; i--) {
      if (this->_stack[(size_t)i].pObject->isType<GeoJsonFeature>()) {
        return this->_stack[(size_t)i].pObject;
      }
    }
 
    return nullptr;
  }

  bool isEnded() const {
    return this->_stackPos == -1 && this->_pCurrentObject == nullptr;
  }

  GeoJsonObjectIterator& operator++() {
    this->iterate();
    return *this;
  }

  GeoJsonObjectIterator operator++(int) {
    GeoJsonObjectIterator tmp = *this;
    this->iterate();
    return tmp;
  }

  friend bool
  operator==(const GeoJsonObjectIterator& a, const GeoJsonObjectIterator& b) {
    if (a._pCurrentObject != b._pCurrentObject || a._stackPos != b._stackPos) {
      return false;
    }
 
    if (a._stackPos >= 0 && b._stackPos >= 0) {
      if (a._stack[(size_t)a._stackPos].nextPos !=
          b._stack[(size_t)b._stackPos].nextPos) {
        return false;
      }
      if (a._stack[(size_t)a._stackPos].pObject !=
          b._stack[(size_t)b._stackPos].pObject) {
        return false;
      }
    }
 
    return true;
  }

  friend bool
  operator!=(const GeoJsonObjectIterator& a, const GeoJsonObjectIterator& b) {
    return !(a == b);
  }

  GeoJsonObjectIterator(GeoJsonObject& rootObject)
      : _stackPos(0), _pCurrentObject(nullptr) {
    this->_stack[0].pObject = &rootObject;
    this->_stack[0].nextPos = -1;
    this->iterate();
  }

  GeoJsonObjectIterator() : _stackPos(-1), _pCurrentObject(nullptr) {}
 
private:
  void handleChild(GeoJsonObject& child) {
    this->_pCurrentObject = &child;
 
    if ((this->_stackPos - 1) <= (int64_t)StackSize &&
        (child.isType<GeoJsonGeometryCollection>() ||
         child.isType<GeoJsonFeatureCollection>() ||
         child.isType<GeoJsonFeature>())) {
 
      ++this->_stackPos;
      this->_stack[(size_t)this->_stackPos].pObject = &child;
      this->_stack[(size_t)this->_stackPos].nextPos = 0;
    }
  }
 
  void iterate() {
    this->_pCurrentObject = nullptr;
    while (this->_stackPos >= 0 && this->_stackPos < (int64_t)StackSize &&
           this->_pCurrentObject == nullptr) {
      IteratorStackState& stackState = this->_stack[(size_t)this->_stackPos];
      GeoJsonObject* pNext = stackState.pObject;
      if (stackState.nextPos == -1) {
        this->_pCurrentObject = pNext;
        ++stackState.nextPos;
        continue;
      } else if (
          GeoJsonGeometryCollection* pCollection =
              std::get_if<GeoJsonGeometryCollection>(&pNext->value)) {
        if ((size_t)stackState.nextPos >= pCollection->geometries.size()) {
          // No children left
          --this->_stackPos;
          continue;
        }
 
        GeoJsonObject& child =
            pCollection->geometries[(size_t)stackState.nextPos];
        ++stackState.nextPos;
        this->handleChild(child);
        continue;
      } else if (
          GeoJsonFeatureCollection* pFeatureCollection =
              std::get_if<GeoJsonFeatureCollection>(&pNext->value)) {
        if ((size_t)stackState.nextPos >= pFeatureCollection->features.size()) {
          // No children left
          --this->_stackPos;
          continue;
        }
 
        GeoJsonObject& child =
            pFeatureCollection->features[(size_t)stackState.nextPos];
        ++stackState.nextPos;
        this->handleChild(child);
        continue;
      } else if (
          GeoJsonFeature* pFeature =
              std::get_if<GeoJsonFeature>(&pNext->value)) {
        const size_t expectedSize = pFeature->geometry == nullptr ? 0 : 1;
        if ((size_t)stackState.nextPos >= expectedSize) {
          // Feature only has zero or one child
          --this->_stackPos;
          continue;
        }
 
        ++stackState.nextPos;
        this->handleChild(*pFeature->geometry);
        continue;
      } else {
        // This object was a dud, try another
        --this->_stackPos;
      }
    }
  }
 
  std::array<IteratorStackState, StackSize> _stack;
  int64_t _stackPos = -1;
  GeoJsonObject* _pCurrentObject;
 
  friend struct ConstGeoJsonObjectIterator;
};

struct ConstGeoJsonObjectIterator {
  // Ignore Doxygen warnings for iterator tags.
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = GeoJsonObject;
  using pointer = const GeoJsonObject*;
  using reference = const GeoJsonObject&;

  reference operator*() const { return *this->_it; }
  pointer operator->() { return this->_it._pCurrentObject; }

  const GeoJsonObject* getFeature() { return this->_it.getFeature(); }

  bool isEnded() const { return this->_it.isEnded(); }

  ConstGeoJsonObjectIterator& operator++() {
    ++this->_it;
    return *this;
  }

  ConstGeoJsonObjectIterator operator++(int) {
    ConstGeoJsonObjectIterator tmp = *this;
    ++this->_it;
    return tmp;
  }

  friend bool operator==(
      const ConstGeoJsonObjectIterator& a,
      const ConstGeoJsonObjectIterator& b) {
    return a._it == b._it;
  }

  friend bool operator!=(
      const ConstGeoJsonObjectIterator& a,
      const ConstGeoJsonObjectIterator& b) {
    return a._it != b._it;
  }

  ConstGeoJsonObjectIterator(const GeoJsonObject& rootObject)
      : _it(const_cast<GeoJsonObject&>(rootObject)) {}

  ConstGeoJsonObjectIterator() = default;
 
private:
  GeoJsonObjectIterator _it;
};

template <typename TSingle, typename TMulti, typename TValue>
struct ConstGeoJsonPrimitiveIterator {
  // Ignore Doxygen warnings for iterator tags.
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = TValue;
  using pointer = const TValue*;
  using reference = const TValue&;

  reference operator*() const {
    const TMulti* pMultiPoint = (*this->_it).template getIf<TMulti>();
    if (pMultiPoint) {
      return pMultiPoint->coordinates[this->_currentMultiIdx];
    }
 
    return (*this->_it).template get<TSingle>().coordinates;
  }

  pointer operator->() { return &**this; }

  ConstGeoJsonPrimitiveIterator& operator++() {
    this->iterate();
    return *this;
  }

  ConstGeoJsonPrimitiveIterator operator++(int) {
    ConstGeoJsonPrimitiveIterator tmp = *this;
    this->iterate();
    return tmp;
  }

  friend bool operator==(
      const ConstGeoJsonPrimitiveIterator& a,
      const ConstGeoJsonPrimitiveIterator& b) {
    return a._it == b._it;
  }

  friend bool operator!=(
      const ConstGeoJsonPrimitiveIterator& a,
      const ConstGeoJsonPrimitiveIterator& b) {
    return a._it != b._it;
  }

  ConstGeoJsonPrimitiveIterator(const GeoJsonObject& rootObject)
      : _it(const_cast<GeoJsonObject&>(rootObject)) {
    if (!_it.isEnded() &&
        !(_it->template isType<TSingle>() || _it->template isType<TMulti>())) {
      this->iterate();
    }
  }

  ConstGeoJsonPrimitiveIterator() = default;
 
private:
  void iterate() {
    if (!this->_it.isEnded() && this->_it->template isType<TMulti>()) {
      const TMulti& multi = this->_it->template get<TMulti>();
      if ((int64_t)this->_currentMultiIdx <
          ((int64_t)multi.coordinates.size() - 1)) {
        ++this->_currentMultiIdx;
        return;
      }
    }
 
    this->_currentMultiIdx = 0;
    do {
      ++this->_it;
    } while (!this->_it.isEnded() &&
             !(this->_it->template isType<TSingle>() ||
               (this->_it->template isType<TMulti>() &&
                !this->_it->template get<TMulti>().coordinates.empty())));
  }
 
  GeoJsonObjectIterator _it;
  size_t _currentMultiIdx = 0;
};

template <typename TObject> struct ConstGeoJsonObjectTypeIterator {
  // Ignore Doxygen warnings for iterator tags.
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = TObject;
  using pointer = const TObject*;
  using reference = const TObject&;

  reference operator*() const { return (*this->_it).template get<TObject>(); }
  pointer operator->() { return &**this; }

  ConstGeoJsonObjectTypeIterator& operator++() {
    this->iterate();
    return *this;
  }

  ConstGeoJsonObjectTypeIterator operator++(int) {
    ConstGeoJsonObjectTypeIterator tmp = *this;
    this->iterate();
    return tmp;
  }

  friend bool operator==(
      const ConstGeoJsonObjectTypeIterator& a,
      const ConstGeoJsonObjectTypeIterator& b) {
    return a._it == b._it;
  }

  friend bool operator!=(
      const ConstGeoJsonObjectTypeIterator& a,
      const ConstGeoJsonObjectTypeIterator& b) {
    return a._it != b._it;
  }

  ConstGeoJsonObjectTypeIterator(const GeoJsonObject& rootObject)
      : _it(const_cast<GeoJsonObject&>(rootObject)) {
    if (!this->_it.isEnded() && !this->_it->template isType<TObject>()) {
      this->iterate();
    }
  }

  ConstGeoJsonObjectTypeIterator() = default;
 
private:
  void iterate() {
    do {
      ++this->_it;
    } while (!this->_it.isEnded() && !this->_it->template isType<TObject>());
  }
 
  ConstGeoJsonObjectIterator _it;
  size_t _currentMultiPointIdx = 0;
};
} // namespace CesiumVectorData