Add module url_template

Cargo.lock

  "gl_generator 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "glutin 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "image 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "linked-hash-map 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "osmpbf 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "reqwest 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "toml 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "xdg 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Cargo.toml

 clap = "2.29"
 env_logger = "0.5.0-rc.2"
 gl = "0.10"
+glutin = "0.16"
 image = "0.19"
+lazy_static = "1.0"
 linked-hash-map = "0.5.0"
 log = "0.4"
 osmpbf = "0.1"
+regex = "1.0"
 reqwest = "0.8"
-glutin = "0.16"
 toml = "0.4"
 xdg = "2.1"
 

src/config.rs

                             extension.to_string(),
                             min_zoom as u32,
                             max_zoom as u32,
-                        ),
+                        )?,
                     ));
                 }
                 Ok(())

src/main.rs

 extern crate env_logger;
 extern crate glutin;
 extern crate image;
+#[macro_use]
+extern crate lazy_static;
 extern crate linked_hash_map;
 #[macro_use]
 extern crate log;
+extern crate regex;
 extern crate reqwest;
 extern crate toml;
 extern crate xdg;
 pub mod program;
 pub mod texture;
 pub mod tile;
-pub mod tile_cache;
 pub mod tile_atlas;
+pub mod tile_cache;
 pub mod tile_loader;
 pub mod tile_source;
+pub mod url_template;
 
 use coord::ScreenCoord;
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};

src/tile_source.rs

 use coord::TileCoord;
 use std::path::PathBuf;
+use url_template::UrlTemplate;
 
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct TileSource {
     id: u32,
-    url_template: String,
+    url_template: UrlTemplate,
     directory: PathBuf,
     extension: String,
     min_zoom: u32,
         extension: String,
         min_zoom: u32,
         max_zoom: u32,
-    ) -> Self {
-        TileSource {
+    ) -> Result<Self, String> {
+        Ok(TileSource {
             id,
-            url_template: url_template.into(),
+            url_template: UrlTemplate::new(url_template)?,
             directory: directory.into(),
             extension,
             min_zoom,
             max_zoom,
-        }
+        })
     }
 
     pub fn id(&self) -> TileSourceId {
     }
 
     pub fn remote_tile_url(&self, tile_coord: TileCoord) -> Option<String> {
-        Self::fill_template(&self.url_template, tile_coord)
+        self.url_template.fill(tile_coord)
     }
 
     pub fn min_tile_zoom(&self) -> u32 {
     pub fn max_tile_zoom(&self) -> u32 {
         self.max_zoom
     }
-
-    fn fill_template(template: &str, tile_coord: TileCoord) -> Option<String> {
-        let x_str = tile_coord.x.to_string();
-        let y_str = tile_coord.y.to_string();
-        let z_str = tile_coord.zoom.to_string();
-
-        //TODO use the regex crate for templates or some other more elegant method
-        if template.contains("{quadkey}") {
-            tile_coord.to_quadkey().map(|qk| template.replacen("{quadkey}", &qk, 1))
-        } else {
-            Some(template.replacen("{x}", &x_str, 1)
-                    .replacen("{y}", &y_str, 1)
-                    .replacen("{z}", &z_str, 1)
-                )
-        }
-    }
 }

src/url_template.rs

+use coord::TileCoord;
+use regex::Regex;
+
+
+/// Kinds of placeholders for a `UrlTemplate`
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
+enum Placeholder {
+    /// Tile x coordinate
+    X,
+    /// Tile y coordinate
+    Y,
+    /// Tile zoom
+    Z,
+    /// Quadkey encoded coord
+    Quadkey
+}
+
+impl Placeholder {
+    /// Returns maximum number of bytes that the value for a placeholder with occupy.
+    fn max_size(&self) -> usize {
+        match *self {
+            Placeholder::X | Placeholder::Y | Placeholder::Z => 11,
+            Placeholder::Quadkey => 30,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UrlTemplate {
+    /// The template string that includes placeholders between static parts
+    template_string: String,
+    /// Ranges into `template_string` for static parts
+    static_parts: Vec<::std::ops::Range<usize>>,
+    /// Kinds of placeholders between the static parts
+    placeholders: Vec<Placeholder>,
+    /// Maximum length in bytes of a filled template
+    max_size: usize,
+}
+
+impl UrlTemplate {
+    pub fn new<S: Into<String>>(template_str: S) -> Result<UrlTemplate, String> {
+        let template_string = template_str.into();
+        let mut static_parts = vec![];
+        let mut placeholders = vec![];
+        let mut max_size = 0;
+
+        lazy_static! {
+            static ref RE: Regex = Regex::new(r"\{([a-z]+)\}").unwrap();
+        }
+
+        let mut offset = 0;
+        for cap in RE.captures_iter(&template_string) {
+            let cap0 = cap.get(0).unwrap();
+            static_parts.push(offset..cap0.start());
+            max_size += cap0.start() - offset;
+
+            {
+                let ph = match cap.get(1).unwrap().as_str() {
+                    "x" => Placeholder::X,
+                    "y" => Placeholder::Y,
+                    "z" => Placeholder::Z,
+                    "quadkey" => Placeholder::Quadkey,
+                    s => return Err(format!("Invalid placeholder in url template: {:?}", s)),
+                };
+                max_size += ph.max_size();
+                placeholders.push(ph);
+            }
+
+            offset = cap0.end();
+        }
+
+        static_parts.push(offset..template_string.len());
+        max_size += template_string.len() - offset;
+
+        let template_valid =
+            placeholders.contains(&Placeholder::Quadkey) ||
+            (placeholders.contains(&Placeholder::X) &&
+             placeholders.contains(&Placeholder::Y) &&
+             placeholders.contains(&Placeholder::Z));
+
+        if !template_valid {
+            return Err(format!(
+                "template is not valid because one or multiple placeholders are missing: {:?}",
+                template_string)
+            );
+        }
+
+        Ok(UrlTemplate {
+            template_string,
+            static_parts,
+            placeholders,
+            max_size,
+        })
+    }
+
+    pub fn fill(&self, tile_coord: TileCoord) -> Option<String> {
+        let mut ret = String::with_capacity(self.max_size);
+
+        if let Some(prefix) = self.static_parts.first() {
+            ret += &self.template_string[prefix.start..prefix.end];
+        }
+
+        for (i, static_part) in self.static_parts.iter().skip(1).enumerate() {
+            let dyn_part = match self.placeholders[i] {
+                Placeholder::X => tile_coord.x.to_string(),
+                Placeholder::Y => tile_coord.y.to_string(),
+                Placeholder::Z => tile_coord.zoom.to_string(),
+                Placeholder::Quadkey => {
+                    match tile_coord.to_quadkey() {
+                        Some(q) => q,
+                        None => return None,
+                    }
+                }
+            };
+            ret += &dyn_part;
+            ret += &self.template_string[static_part.start..static_part.end];;
+        }
+        Some(ret)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use url_template::*;
+
+    fn check_templ(templ_str: &str, coord: TileCoord, result: &str) {
+        let t = UrlTemplate::new(templ_str).unwrap();
+        assert_eq!(t.fill(coord), Some(result.to_string()));
+    }
+
+    #[test]
+    fn check_new() {
+        assert!(UrlTemplate::new("").is_err());
+        assert!(UrlTemplate::new("abc").is_err());
+        assert!(UrlTemplate::new("{x}").is_err());
+        assert!(UrlTemplate::new("{z}{y}").is_err());
+        assert!(UrlTemplate::new("{x}{z}{y}").is_ok());
+        assert!(UrlTemplate::new("{quadkey}").is_ok());
+        assert!(UrlTemplate::new("{x}{quadkey}").is_ok());
+    }
+
+    #[test]
+    fn check_fill() {
+        check_templ("https://tiles.example.com/{z}/{x}/{y}.png",
+                    TileCoord::new(2, 1, 0),
+                    "https://tiles.example.com/2/1/0.png");
+        check_templ("{z}{x}{y}",
+                    TileCoord::new(2, 1, 0),
+                    "210");
+        check_templ("{quadkey}",
+                    TileCoord::new(3, 1, 0),
+                    "001");
+        check_templ("{x}{x}{y}{z}",
+                    TileCoord::new(2, 1, 0),
+                    "1102");
+        check_templ("a{quadkey}b{z}c",
+                    TileCoord::new(1, 0, 0),
+                    "a0b1c");
+    }
+}