Remove Layer suffix from LayerType variants

CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0]
+### Changed
+- `LayerType` variants have been stripped from the `Layer` suffix.
+
 ## [0.10.1]
 ### Added
 - `Loader` type for loading map and tileset files without having to necessarily mention the cache

examples/main.rs

@@ -13,7 +13,7 @@ fn main() {
         print!("Layer \"{}\":\n\t", layer.name);
 
         match layer.layer_type() {
-            tiled::LayerType::TileLayer(layer) => match layer {
+            tiled::LayerType::Tiles(layer) => match layer {
                 tiled::TileLayer::Finite(data) => println!(
                     "Finite tile layer with width = {} and height = {}; ID of tile @ (0,0): {}",
                     data.width(),
@@ -29,10 +29,10 @@ fn main() {
                     )
                 }
             },
-            tiled::LayerType::ObjectLayer(layer) => {
+            tiled::LayerType::Objects(layer) => {
                 println!("Object layer with {} objects", layer.objects().len())
             }
-            tiled::LayerType::ImageLayer(layer) => {
+            tiled::LayerType::Image(layer) => {
                 println!(
                     "Image layer with {}",
                     match &layer.image {
@@ -42,7 +42,7 @@ fn main() {
                     }
                 )
             }
-            tiled::LayerType::GroupLayer(layer) => {
+            tiled::LayerType::Group(layer) => {
                 println!("Group layer with {} sublayers", layer.layers().len())
             }
         }

examples/sfml/main.rs

@@ -44,7 +44,7 @@ impl Level {
         let layers = map
             .layers()
             .filter_map(|layer| match &layer.layer_type() {
-                tiled::LayerType::TileLayer(l) => Some(generate_mesh(
+                tiled::LayerType::Tiles(l) => Some(generate_mesh(
                     match l {
                         tiled::TileLayer::Finite(f) => f,
                         tiled::TileLayer::Infinite(_) => panic!("Infinite maps not supported"),

src/error.rs

@@ -36,19 +36,19 @@ pub enum Error {
         compression: Option<String>,
     },
     /// There was an error parsing the value of a [`PropertyValue`].
-    /// 
+    ///
     /// [`PropertyValue`]: crate::PropertyValue
     InvalidPropertyValue {
         /// A description of the error that occured.
-        description: String
+        description: String,
     },
     /// Found an unknown property value type while parsing a [`PropertyValue`].
-    /// 
+    ///
     /// [`PropertyValue`]: crate::PropertyValue
     UnknownPropertyType {
         /// The name of the type that isn't recognized by the crate.
         /// Supported types are `string`, `int`, `float`, `bool`, `color`, `file` and `object`.
-        type_name: String
+        type_name: String,
     },
 }
 

src/image.rs

@@ -39,7 +39,7 @@ pub struct Image {
     ///     .unwrap()
     ///     .layer_type()
     /// {
-    ///     LayerType::ImageLayer(layer) => layer,
+    ///     LayerType::Image(layer) => layer,
     ///     _ => panic!(),
     /// };
     ///

src/layers/group.rs

@@ -30,7 +30,7 @@ impl GroupLayerData {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::TileLayer,
+                    LayerTag::Tiles,
                     infinite,
                     map_path,
                     &tilesets,
@@ -41,7 +41,7 @@ impl GroupLayerData {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::ImageLayer,
+                    LayerTag::Image,
                     infinite,
                     map_path,
                     &tilesets,
@@ -52,7 +52,7 @@ impl GroupLayerData {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::ObjectLayer,
+                    LayerTag::Objects,
                     infinite,
                     map_path,
                     &tilesets,
@@ -63,7 +63,7 @@ impl GroupLayerData {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::GroupLayer,
+                    LayerTag::Group,
                     infinite,
                     map_path,
                     &tilesets,

src/layers/mod.rs

@@ -2,12 +2,7 @@ use std::path::Path;
 
 use xml::attribute::OwnedAttribute;
 
-use crate::{
-    error::{Result},
-    properties::Properties,
-    util::*,
-    Color, Map, MapTilesetGid,
-};
+use crate::{error::Result, properties::Properties, util::*, Color, Map, MapTilesetGid};
 
 mod image;
 pub use image::*;
@@ -20,18 +15,18 @@ pub use group::*;
 
 #[derive(Clone, PartialEq, Debug)]
 pub(crate) enum LayerDataType {
-    TileLayer(TileLayerData),
-    ObjectLayer(ObjectLayerData),
-    ImageLayer(ImageLayerData),
-    GroupLayer(GroupLayerData),
+    Tiles(TileLayerData),
+    Objects(ObjectLayerData),
+    Image(ImageLayerData),
+    Group(GroupLayerData),
 }
 
 #[derive(Clone, Copy)]
 pub(crate) enum LayerTag {
-    TileLayer,
-    ObjectLayer,
-    ImageLayer,
-    GroupLayer,
+    Tiles,
+    Objects,
+    Image,
+    Group,
 }
 
 /// The raw data of a [`Layer`]. Does not include a reference to its parent [`Map`](crate::Map).
@@ -91,21 +86,21 @@ impl LayerData {
         );
 
         let (ty, properties) = match tag {
-            LayerTag::TileLayer => {
+            LayerTag::Tiles => {
                 let (ty, properties) = TileLayerData::new(parser, attrs, infinite, tilesets)?;
-                (LayerDataType::TileLayer(ty), properties)
+                (LayerDataType::Tiles(ty), properties)
             }
-            LayerTag::ObjectLayer => {
+            LayerTag::Objects => {
                 let (ty, properties) = ObjectLayerData::new(parser, attrs, Some(tilesets))?;
-                (LayerDataType::ObjectLayer(ty), properties)
+                (LayerDataType::Objects(ty), properties)
             }
-            LayerTag::ImageLayer => {
+            LayerTag::Image => {
                 let (ty, properties) = ImageLayerData::new(parser, map_path)?;
-                (LayerDataType::ImageLayer(ty), properties)
+                (LayerDataType::Image(ty), properties)
             }
-            LayerTag::GroupLayer => {
+            LayerTag::Group => {
                 let (ty, properties) = GroupLayerData::new(parser, infinite, map_path, tilesets)?;
-                (LayerDataType::GroupLayer(ty), properties)
+                (LayerDataType::Group(ty), properties)
             }
         };
 
@@ -142,22 +137,22 @@ impl<'map> Layer<'map> {
 #[derive(Debug)]
 pub enum LayerType<'map> {
     /// A tile layer; Also see [`TileLayer`].
-    TileLayer(TileLayer<'map>),
+    Tiles(TileLayer<'map>),
     /// An object layer (also called object group); Also see [`ObjectLayer`].
-    ObjectLayer(ObjectLayer<'map>),
+    Objects(ObjectLayer<'map>),
     /// An image layer; Also see [`ImageLayer`].
-    ImageLayer(ImageLayer<'map>),
+    Image(ImageLayer<'map>),
     /// A group layer; Also see [`GroupLayer`].
-    GroupLayer(GroupLayer<'map>),
+    Group(GroupLayer<'map>),
 }
 
 impl<'map> LayerType<'map> {
     fn new(map: &'map Map, data: &'map LayerDataType) -> Self {
         match data {
-            LayerDataType::TileLayer(data) => Self::TileLayer(TileLayer::new(map, data)),
-            LayerDataType::ObjectLayer(data) => Self::ObjectLayer(ObjectLayer::new(map, data)),
-            LayerDataType::ImageLayer(data) => Self::ImageLayer(ImageLayer::new(map, data)),
-            LayerDataType::GroupLayer(data) => Self::GroupLayer(GroupLayer::new(map, data)),
+            LayerDataType::Tiles(data) => Self::Tiles(TileLayer::new(map, data)),
+            LayerDataType::Objects(data) => Self::Objects(ObjectLayer::new(map, data)),
+            LayerDataType::Image(data) => Self::Image(ImageLayer::new(map, data)),
+            LayerDataType::Group(data) => Self::Group(GroupLayer::new(map, data)),
         }
     }
 }

src/map.rs

@@ -145,7 +145,7 @@ impl Map {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::TileLayer,
+                    LayerTag::Tiles,
                     infinite,
                     map_path,
                     &tilesets,
@@ -156,7 +156,7 @@ impl Map {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::ImageLayer,
+                    LayerTag::Image,
                     infinite,
                     map_path,
                     &tilesets,
@@ -167,7 +167,7 @@ impl Map {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::ObjectLayer,
+                    LayerTag::Objects,
                     infinite,
                     map_path,
                     &tilesets,
@@ -178,7 +178,7 @@ impl Map {
                 layers.push(LayerData::new(
                     parser,
                     attrs,
-                    LayerTag::GroupLayer,
+                    LayerTag::Group,
                     infinite,
                     map_path,
                     &tilesets,

src/parse/xml/map.rs

@@ -1,25 +1,36 @@
-use std::{path::Path};
+use std::path::Path;
 
 use xml::{reader::XmlEvent, EventReader};
 
-use crate::{Error, Map, ResourceCache, Result, ResourceReader};
+use crate::{Error, Map, ResourceCache, ResourceReader, Result};
 
 pub fn parse_map(
     path: &Path,
     reader: &mut impl ResourceReader,
     cache: &mut impl ResourceCache,
 ) -> Result<Map> {
-    let mut parser = EventReader::new(reader.read_from(path).map_err(|err| Error::ResourceLoadingError {
-        path: path.to_owned(),
-        err: Box::new(err),
-    })?);
+    let mut parser =
+        EventReader::new(
+            reader
+                .read_from(path)
+                .map_err(|err| Error::ResourceLoadingError {
+                    path: path.to_owned(),
+                    err: Box::new(err),
+                })?,
+        );
     loop {
         match parser.next().map_err(Error::XmlDecodingError)? {
             XmlEvent::StartElement {
                 name, attributes, ..
             } => {
                 if name.local_name == "map" {
-                    return Map::parse_xml(&mut parser.into_iter(), attributes, path, cache, reader);
+                    return Map::parse_xml(
+                        &mut parser.into_iter(),
+                        attributes,
+                        path,
+                        cache,
+                        reader,
+                    );
                 }
             }
             XmlEvent::EndDocument => {

tests/lib.rs

@@ -6,7 +6,7 @@ use tiled::{
 
 fn as_tile_layer<'map>(layer: Layer<'map>) -> TileLayer<'map> {
     match layer.layer_type() {
-        LayerType::TileLayer(x) => x,
+        LayerType::Tiles(x) => x,
         _ => panic!("Not a tile layer"),
     }
 }
@@ -20,14 +20,14 @@ fn as_finite<'map>(data: TileLayer<'map>) -> FiniteTileLayer<'map> {
 
 fn as_object_layer<'map>(layer: Layer<'map>) -> ObjectLayer<'map> {
     match layer.layer_type() {
-        LayerType::ObjectLayer(x) => x,
+        LayerType::Objects(x) => x,
         _ => panic!("Not an object layer"),
     }
 }
 
 fn as_group_layer<'map>(layer: Layer<'map>) -> GroupLayer<'map> {
     match layer.layer_type() {
-        LayerType::GroupLayer(x) => x,
+        LayerType::Group(x) => x,
         _ => panic!("Not a group layer"),
     }
 }
@@ -161,7 +161,7 @@ fn test_image_layers() {
         .unwrap();
     assert_eq!(r.layers().len(), 2);
     let mut image_layers = r.layers().map(|layer| {
-        if let LayerType::ImageLayer(img) = layer.layer_type() {
+        if let LayerType::Image(img) = layer.layer_type() {
             (img, layer)
         } else {
             panic!("Found layer that isn't an image layer")