partial implementation of new datastore functions

DataStructures/SharedMemoryVectorWrapper.h

@@ -128,6 +128,64 @@ public:
     }
 };
 
+template<>
+class SharedMemoryWrapper<bool> {
+private:
+    unsigned * m_ptr;
+    std::size_t m_size;
+
+public:
+    SharedMemoryWrapper() :
+        m_ptr(NULL),
+        m_size(0)
+    { }
+
+    SharedMemoryWrapper(unsigned * ptr, std::size_t size) :
+        m_ptr(ptr),
+        m_size(size)
+    { }
+
+    void swap( SharedMemoryWrapper<bool> & other ) {
+        BOOST_ASSERT_MSG(m_size != 0 || other.size() != 0, "size invalid");
+        std::swap( m_size, other.m_size);
+        std::swap( m_ptr , other.m_ptr );
+    }
+
+    // void SetData(const DataT * ptr, const std::size_t size) {
+    //     BOOST_ASSERT_MSG( 0 == m_size, "vector not empty");
+    //     BOOST_ASSERT_MSG( 0 < size   , "new vector empty");
+    //     m_ptr.reset(ptr);
+    //     m_size = size;
+    // }
+
+    bool at(const std::size_t index) const {
+        BOOST_ASSERT_MSG(index < m_size, "invalid size");
+        const unsigned bucket = index / 32;
+        const unsigned offset = index % 32;
+        return m_ptr[bucket] & (1 << offset);
+    }
+
+    // ShMemIterator<DataT> begin() const {
+    //     return ShMemIterator<DataT>(m_ptr);
+    // }
+
+    // ShMemIterator<DataT> end() const {
+    //     return ShMemIterator<DataT>(m_ptr+m_size);
+    // }
+
+    std::size_t size() const { return m_size; }
+
+    bool empty() const { return 0 == size(); }
+
+    bool operator[](const unsigned index) {
+        BOOST_ASSERT_MSG(index < m_size, "invalid size");
+        const unsigned bucket = index / 32;
+        const unsigned offset = index % 32;
+        return m_ptr[bucket] & (1 << offset);
+    }
+};
+
+
 template<typename DataT, bool UseSharedMemory>
 struct ShM {
     typedef typename boost::conditional<

Server/DataStructures/SharedDataFacade.h

@@ -209,10 +209,18 @@ private:
 
     void LoadGeometries()
     {
+        unsigned * geometries_compressed_ptr = (unsigned *)(
+            shared_memory + data_layout->GetGeometriesCompressedOffset()
+        );
+        typename ShM<bool, true>::vector egde_is_compressed(
+            geometries_compressed_ptr,
+            data_layout->geometries_index_list_size
+        );
+        m_egde_is_compressed.swap(egde_is_compressed);
+
         unsigned * geometries_index_ptr = (unsigned *)(
             shared_memory + data_layout->GetGeometriesIndicesOffset()
         );
-
         typename ShM<unsigned, true>::vector geometry_begin_indices(
             geometries_index_ptr,
             data_layout->geometries_index_list_size

Server/DataStructures/SharedDataType.h

@@ -58,6 +58,7 @@ struct SharedDataLayout {
     uint64_t r_search_tree_size;
     uint64_t geometries_index_list_size;
     uint64_t geometries_list_size;
+    uint64_t geometries_compression;
 
     unsigned checksum;
     unsigned timestamp_length;
@@ -76,6 +77,7 @@ struct SharedDataLayout {
         r_search_tree_size(0),
         geometries_index_list_size(0),
         geometries_list_size(0),
+        geometries_compression(0),
         checksum(0),
         timestamp_length(0)
 
@@ -95,6 +97,7 @@ struct SharedDataLayout {
         SimpleLogger().Write(logDEBUG) << "coordinate_list_size:       " << coordinate_list_size;
         SimpleLogger().Write(logDEBUG) << "turn_instruction_list_size: " << turn_instruction_list_size;
         SimpleLogger().Write(logDEBUG) << "r_search_tree_size:         " << r_search_tree_size;
+        SimpleLogger().Write(logDEBUG) << "geometries_compression:     " << geometries_compression;
         SimpleLogger().Write(logDEBUG) << "geometries_index_list_size: " << geometries_index_list_size;
         SimpleLogger().Write(logDEBUG) << "geometry_list_size:         " << geometries_list_size;
         SimpleLogger().Write(logDEBUG) << "sizeof(checksum):           " << sizeof(checksum);
@@ -218,6 +221,24 @@ struct SharedDataLayout {
             (r_search_tree_size         * sizeof(RTreeNode)            );
         return result;
     }
+
+    uint64_t GetGeometriesCompressedOffset() const
+    {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)             ) +
+            (name_char_list_size        * sizeof(char)                 ) +
+            (name_id_list_size          * sizeof(unsigned)             ) +
+            (via_node_list_size         * sizeof(NodeID)               ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode) ) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge) ) +
+            (timestamp_length           * sizeof(char)                 ) +
+            (coordinate_list_size       * sizeof(FixedPointCoordinate) ) +
+            (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
+            (r_search_tree_size         * sizeof(RTreeNode)            ) +
+            (geometries_compression/32) + 1;
+        return result;
+    }
+
     uint64_t GetGeometryListOffset() const {
         uint64_t result =
             (name_index_list_size       * sizeof(unsigned)             ) +
@@ -230,6 +251,7 @@ struct SharedDataLayout {
             (coordinate_list_size       * sizeof(FixedPointCoordinate) ) +
             (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
             (r_search_tree_size         * sizeof(RTreeNode)            ) +
+            (geometries_compression/32) + 1                              +
             (geometries_index_list_size * sizeof(unsigned)             );
         return result;
     }
@@ -245,6 +267,7 @@ struct SharedDataLayout {
             (coordinate_list_size       * sizeof(FixedPointCoordinate) ) +
             (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
             (r_search_tree_size         * sizeof(RTreeNode)            ) +
+            (geometries_compression/32) + 1                              +
             (geometries_index_list_size * sizeof(unsigned)             ) +
             (geometries_list_size       * sizeof(unsigned)             );
         return result;