Run clippy

src/io/mod.rs

@@ -1,10 +1,10 @@
 //! Handles IO related processing as well as multithreading.
 
-use crate::coords::{TileCoords, WorldTileCoords};
-use crate::error::Error;
+use crate::coords::{WorldTileCoords};
+
 use crate::render::ShaderVertex;
 use crate::tessellation::{IndexDataType, OverAlignedVertexBuffer};
-use async_trait::async_trait;
+
 use std::collections::HashSet;
 use std::fmt;
 use vector_tile::tile::Layer;

src/io/scheduler.rs

@@ -1,22 +1,22 @@
 use std::collections::{HashMap, HashSet};
-use std::fmt::{Debug, Formatter};
-use std::sync::mpsc::{channel, Receiver, RecvError, SendError, Sender};
+
+use std::sync::mpsc::{channel, Receiver, SendError, Sender};
 use std::sync::{Arc, Mutex};
 
 //use crossbeam_channel::{unbounded as channel, Receiver, RecvError, SendError, Sender};
-use log::{error, info, warn};
+use log::{info, warn};
 
 use style_spec::source::TileAdressingScheme;
 use vector_tile::parse_tile_bytes;
-use vector_tile::tile::Layer;
+
 
 /// Describes through which channels work-requests travel. It describes the flow of work.
 use crate::coords::{TileCoords, WorldTileCoords};
 use crate::io::tile_cache::TileCache;
 use crate::io::{LayerResult, TileRequest, TileRequestID, TileResult};
 
-use crate::render::ShaderVertex;
-use crate::tessellation::{IndexDataType, OverAlignedVertexBuffer, Tessellated};
+
+use crate::tessellation::{Tessellated};
 
 pub enum ScheduleMethod {
     #[cfg(not(any(
@@ -64,14 +64,14 @@ impl ThreadLocalTessellatorState {
         request_id: TileRequestID,
         data: Box<[u8]>,
     ) -> Result<(), SendError<LayerResult>> {
-        if let Ok(mut tile_request_state) = self.tile_request_state.lock() {
+        if let Ok(tile_request_state) = self.tile_request_state.lock() {
             if let Some(tile_request) = tile_request_state.finish_tile_request(request_id) {
                 self.tessellate_layers_with_request(
                     TileResult::Tile {
                         coords: tile_request.coords,
                         data,
                     },
-                    &tile_request,
+                    tile_request,
                 )
             } else {
                 Ok(())
@@ -238,7 +238,7 @@ impl TileRequestState {
             return None;
         }
 
-        self.pending_coords.insert(tile_request.coords.clone());
+        self.pending_coords.insert(tile_request.coords);
         let id = self.current_id;
         self.pending_tile_requests.insert(id, tile_request);
         self.current_id += 1;

src/platform/generic.rs

@@ -3,10 +3,10 @@
 use crate::io::scheduler::{IOScheduler, ScheduleMethod};
 use crate::main_loop;
 use crate::platform::TokioScheduleMethod;
-use log::error;
+
 pub use std::time::Instant;
-use tokio::runtime::Handle;
-use tokio::task;
+
+
 use winit::event_loop::EventLoop;
 use winit::window::WindowBuilder;
 
@@ -23,7 +23,7 @@ pub async fn mapr_generic_main() {
         .build(&event_loop)
         .unwrap();
 
-    let mut scheduler = IOScheduler::new(ScheduleMethod::Tokio(TokioScheduleMethod::new(
+    let scheduler = IOScheduler::new(ScheduleMethod::Tokio(TokioScheduleMethod::new(
         "/tmp/mapr_cache".to_string(),
     )));
 

src/platform/noweb/mod.rs

@@ -1,7 +1,7 @@
 //! Module which is used target platform is not web related.
 
 use crate::coords::TileCoords;
-use async_trait::async_trait;
+
 use reqwest::{Client, StatusCode};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use reqwest_middleware_cache::managers::CACacheManager;
@@ -9,7 +9,7 @@ use reqwest_middleware_cache::{Cache, CacheMode};
 
 use crate::error::Error;
 use crate::io::scheduler::IOScheduler;
-use crate::io::{TileRequest, TileRequestID};
+use crate::io::{TileRequestID};
 
 impl From<reqwest::Error> for Error {
     fn from(err: reqwest::Error) -> Self {