Fix naming

src/io/mod.rs

@@ -15,6 +15,7 @@ pub mod scheduler;
 mod source_client;
 pub mod static_tile_fetcher;
 pub mod tile_cache;
+mod tile_request_state;
 
 pub enum TileFetchResult {
     Unavailable {

src/io/scheduler.rs

@@ -20,6 +20,7 @@ use crate::io::{
 use crate::error::Error;
 use crate::io::geometry_index::{GeometryIndex, IndexGeometry, IndexProcessor, TileIndex};
 use crate::io::source_client::{HttpSourceClient, SourceClient};
+use crate::io::tile_request_state::TileRequestState;
 use crate::tessellation::Tessellated;
 use prost::Message;
 
@@ -308,7 +309,7 @@ impl Scheduler {
         }
     }
 
-    pub fn new_tessellator_state(&self) -> ThreadLocalState {
+    pub fn new_thread_local_state(&self) -> ThreadLocalState {
         ThreadLocalState {
             tile_request_state: self.tile_request_state.clone(),
             tessellate_result_sender: self.tessellate_channel.0.clone(),
@@ -375,47 +376,3 @@ impl Scheduler {
         &self.schedule_method
     }
 }
-
-#[derive(Default)]
-pub struct TileRequestState {
-    current_id: TileRequestID,
-    pending_tile_requests: HashMap<TileRequestID, TileRequest>,
-    pending_coords: HashSet<WorldTileCoords>,
-}
-
-impl TileRequestState {
-    pub fn new() -> Self {
-        Self {
-            current_id: 1,
-            pending_tile_requests: Default::default(),
-            pending_coords: Default::default(),
-        }
-    }
-
-    pub fn is_tile_request_pending(&self, coords: &WorldTileCoords) -> bool {
-        self.pending_coords.contains(coords)
-    }
-
-    pub fn start_tile_request(&mut self, tile_request: TileRequest) -> Option<TileRequestID> {
-        if self.is_tile_request_pending(&tile_request.coords) {
-            return None;
-        }
-
-        self.pending_coords.insert(tile_request.coords);
-        let id = self.current_id;
-        self.pending_tile_requests.insert(id, tile_request);
-        self.current_id += 1;
-        Some(id)
-    }
-
-    pub fn finish_tile_request(&mut self, id: TileRequestID) -> Option<TileRequest> {
-        self.pending_tile_requests.remove(&id).map(|request| {
-            self.pending_coords.remove(&request.coords);
-            request
-        })
-    }
-
-    pub fn get_tile_request(&self, id: TileRequestID) -> Option<&TileRequest> {
-        self.pending_tile_requests.get(&id)
-    }
-}

src/io/tile_request_state.rs

@@ -0,0 +1,47 @@
+use crate::coords::WorldTileCoords;
+use crate::io::{TileRequest, TileRequestID};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Default)]
+pub struct TileRequestState {
+    current_id: TileRequestID,
+    pending_tile_requests: HashMap<TileRequestID, TileRequest>,
+    pending_coords: HashSet<WorldTileCoords>,
+}
+
+impl TileRequestState {
+    pub fn new() -> Self {
+        Self {
+            current_id: 1,
+            pending_tile_requests: Default::default(),
+            pending_coords: Default::default(),
+        }
+    }
+
+    pub fn is_tile_request_pending(&self, coords: &WorldTileCoords) -> bool {
+        self.pending_coords.contains(coords)
+    }
+
+    pub fn start_tile_request(&mut self, tile_request: TileRequest) -> Option<TileRequestID> {
+        if self.is_tile_request_pending(&tile_request.coords) {
+            return None;
+        }
+
+        self.pending_coords.insert(tile_request.coords);
+        let id = self.current_id;
+        self.pending_tile_requests.insert(id, tile_request);
+        self.current_id += 1;
+        Some(id)
+    }
+
+    pub fn finish_tile_request(&mut self, id: TileRequestID) -> Option<TileRequest> {
+        self.pending_tile_requests.remove(&id).map(|request| {
+            self.pending_coords.remove(&request.coords);
+            request
+        })
+    }
+
+    pub fn get_tile_request(&self, id: TileRequestID) -> Option<&TileRequest> {
+        self.pending_tile_requests.get(&id)
+    }
+}

src/platform/noweb/schedule_method.rs

@@ -15,6 +15,6 @@ impl TokioScheduleMethod {
         T: std::future::Future + Send + 'static,
         T::Output: Send + 'static,
     {
-        tokio::task::spawn(future_factory(scheduler.new_tessellator_state()));
+        tokio::task::spawn(future_factory(scheduler.new_thread_local_state()));
     }
 }

src/platform/web/legacy_webworker_fetcher.rs

@@ -39,27 +39,23 @@ extern "C" {
 }
 
 #[wasm_bindgen]
-pub fn new_tessellator_state(scheduler_ptr: *mut Scheduler) -> *mut ThreadLocalState {
+pub fn new_thread_local_state(scheduler_ptr: *mut Scheduler) -> *mut ThreadLocalState {
     let scheduler: Box<Scheduler> = unsafe { Box::from_raw(scheduler_ptr) };
-    let tessellator_state = Box::new(scheduler.new_tessellator_state());
-    let tessellator_state_ptr = Box::into_raw(tessellator_state);
+    let state = Box::new(scheduler.new_thread_local_state());
+    let state_ptr = Box::into_raw(state);
     // Call forget such that scheduler does not get deallocated
     std::mem::forget(scheduler);
-    return tessellator_state_ptr;
+    return state_ptr;
 }
 
 #[wasm_bindgen]
-pub fn tessellate_layers(
-    tessellator_state_ptr: *mut ThreadLocalState,
-    request_id: u32,
-    data: Box<[u8]>,
-) {
-    let tessellator_state: Box<ThreadLocalState> = unsafe { Box::from_raw(tessellator_state_ptr) };
+pub fn tessellate_layers(state_ptr: *mut ThreadLocalState, request_id: u32, data: Box<[u8]>) {
+    let state: Box<ThreadLocalState> = unsafe { Box::from_raw(state_ptr) };
 
-    tessellator_state.process_tile(request_id, data).unwrap();
+    state.process_tile(request_id, data).unwrap();
 
     // Call forget such that scheduler does not get deallocated
-    std::mem::forget(tessellator_state);
+    std::mem::forget(state);
 }
 
 pub fn request_tile(request_id: TileRequestID, coords: TileCoords) {

src/platform/web/schedule_method.rs

@@ -46,7 +46,7 @@ impl WebWorkerPoolScheduleMethod {
         T: std::future::Future + 'static,
         T::Output: Send + 'static,
     {
-        let state = scheduler.new_tessellator_state();
+        let state = scheduler.new_thread_local_state();
         self.pool
             .run(move || {
                 wasm_bindgen_futures::future_to_promise(async move {

web/index.ts

@@ -1,4 +1,4 @@
-import init, {create_pool_scheduler, new_tessellator_state, run} from "./dist/libs/mapr"
+import init, {create_pool_scheduler, new_thread_local_state, run} from "./dist/libs/mapr"
 import {Spector} from "spectorjs"
 import {WebWorkerMessageType} from "./types"
 
@@ -86,14 +86,14 @@ const setupLegacyWebWorker = (schedulerPtr: number, memory:  WebAssembly.Memory)
 
     let workers: [number, Worker][] = Array.from(
         new Array(WORKER_COUNT).keys(),
-        (id) => [new_tessellator_state(schedulerPtr), createWorker(id)]
+        (id) => [new_thread_local_state(schedulerPtr), createWorker(id)]
     )
 
     window.schedule_tile_request = (url: string, request_id: number) => {
-        const [tessellatorState, worker] = workers[Math.floor(Math.random() * workers.length)]
+        const [state, worker] = workers[Math.floor(Math.random() * workers.length)]
         worker.postMessage({
             type: "fetch_tile",
-            tessellatorState: tessellatorState,
+            threadLocalState: state,
             url,
             request_id
         } as WebWorkerMessageType)

web/types.ts

@@ -3,7 +3,7 @@ export type WebWorkerMessageType = {
     memory: WebAssembly.Memory
 } | {
     type: 'fetch_tile',
-    tessellatorState: number,
+    threadLocalState: number,
     url: string,
     request_id: number,
 }

web/worker.ts

@@ -15,7 +15,7 @@ onmessage = async message => {
             module = init(undefined, messageData.memory)
             break
         case "fetch_tile":
-            let {tessellatorState, url, request_id} = messageData
+            let {threadLocalState, url, request_id} = messageData
             await module
 
             console.log("Fetching from " + self.name)
@@ -23,7 +23,7 @@ onmessage = async message => {
             let result = await fetch(url)
             let buffer = await result.arrayBuffer()
 
-            tessellate_layers(tessellatorState, request_id, new Uint8Array(buffer))
+            tessellate_layers(threadLocalState, request_id, new Uint8Array(buffer))
             break
         default:
             console.warn("WebWorker received unknown message!")