Deduplicate foward/reverse geometries

Changes the internal representation of compressed geometries to be a
single array shared between forward and reverse geometries that can be
read in either direction. Includes a change on
extractor::OriginalEdgeData to store via_geometry ids that indicate
which direction to read the geometry for that edge based edge.

Closes #2592

include/util/shared_memory_vector_wrapper.hpp

@@ -46,6 +46,34 @@ template <typename DataT> class ShMemIterator : public std::iterator<std::input_
     DataT &operator*() { return *p; }
 };
 
+template <typename DataT> class ShMemReverseIterator : public std::iterator<std::input_iterator_tag, DataT>
+{
+    DataT *p;
+
+  public:
+    explicit ShMemReverseIterator(DataT *x) : p(x) {}
+    ShMemReverseIterator(const ShMemReverseIterator &mit) : p(mit.p) {}
+    ShMemReverseIterator &operator++()
+    {
+        --p;
+        return *this;
+    }
+    ShMemReverseIterator operator++(int)
+    {
+        ShMemReverseIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
+    ShMemReverseIterator operator+(std::ptrdiff_t diff)
+    {
+        ShMemReverseIterator tmp(p - diff);
+        return tmp;
+    }
+    bool operator==(const ShMemReverseIterator &rhs) { return p == rhs.p; }
+    bool operator!=(const ShMemReverseIterator &rhs) { return p != rhs.p; }
+    DataT &operator*() { return *p; }
+};
+
 template <typename DataT> class SharedMemoryWrapper
 {
   private:
@@ -71,6 +99,10 @@ template <typename DataT> class SharedMemoryWrapper
 
     ShMemIterator<DataT> end() const { return ShMemIterator<DataT>(m_ptr + m_size); }
 
+    ShMemReverseIterator<DataT> rbegin() const { return ShMemReverseIterator<DataT>(m_ptr + m_size - 1); }
+
+    ShMemReverseIterator<DataT> rend() const { return ShMemReverseIterator<DataT>(m_ptr - 1); }
+
     std::size_t size() const { return m_size; }
 
     bool empty() const { return 0 == size(); }

include/util/typedefs.hpp

@@ -77,6 +77,7 @@ static const EntryClassID INVALID_ENTRY_CLASSID = std::numeric_limits<EntryClass
 
 static const NodeID SPECIAL_NODEID = std::numeric_limits<NodeID>::max();
 static const NodeID SPECIAL_SEGMENTID = std::numeric_limits<NodeID>::max() >> 1;
+static const NodeID SPECIAL_GEOMETRYID = std::numeric_limits<NodeID>::max() >> 1;
 static const EdgeID SPECIAL_EDGEID = std::numeric_limits<EdgeID>::max();
 static const NameID INVALID_NAMEID = std::numeric_limits<NameID>::max();
 static const NameID EMPTY_NAMEID = 0;
@@ -96,6 +97,22 @@ struct SegmentID
     std::uint32_t enabled : 1;
 };
 
+/* We need to bit pack here because the index for the via_node
+ * is given to us without knowing whether the geometry should
+ * be read forward or in reverse. The extra field `forward`
+ * indicates that to the routing engine
+ */
+struct GeometryID
+{
+    GeometryID(const NodeID id_, const bool forward_) : id{id_}, forward{forward_} {}
+
+    GeometryID() : id(std::numeric_limits<unsigned>::max() >> 1), forward(false) {}
+
+    NodeID id : 31;
+    std::uint32_t forward : 1;
+};
+
+
 static_assert(sizeof(SegmentID) == 4, "SegmentID needs to be 4 bytes big");
 
 #endif /* TYPEDEFS_H */