Struct galileo::LayerCollection

pub struct LayerCollection(/* private fields */);

Collection of layers with some meta-information.

When a map is rendered, it draws all visible layers in the order they are stored in the collection. Any layer can be temporary hidden with the LayerCollection::hide or LayerCollection::show_by methods. These layers will be ignored by the renderer, but retain their place in the collection.

Since a map should be able to render anything implementing the Layer trait, this collection stores layers as trait objects. You can use downcasting through Any trait to obtain a concrete layer type you work with.

use galileo::layer::{RasterTileLayer, VectorTileLayer};
use galileo::layer::data_provider::FileCacheController;
use galileo::layer::data_provider::UrlDataProvider;
use galileo::layer::vector_tile_layer::tile_provider::ThreadedProvider;
use galileo::layer::vector_tile_layer::tile_provider::VtProcessor;
use galileo::LayerCollection;
use galileo::MapBuilder;
use galileo::tile_scheme::TileIndex;

let raster_tiles = MapBuilder::create_raster_tile_layer(|index| format!("url from {index:?}"), todo!());
let vector_tiles = MapBuilder::create_vector_tile_layer(|index| format!("url from {index:?}"), todo!(), todo!());

let mut collection = LayerCollection::default();
collection.push(raster_tiles);
collection.push(vector_tiles);

assert!(collection[1].as_any().downcast_ref::<VectorTileLayer<ThreadedProvider<UrlDataProvider<TileIndex, VtProcessor, FileCacheController>>>>().is_some());

Implementations

impl LayerCollection

pub fn truncate(&mut self, length: usize)

Shortens the collection, keeping the first length layers and dropping the rest. If the length of the collection is less than length does nothing.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.truncate(3);
assert_eq!(collection.len(), 2);
collection.truncate(1);
assert_eq!(collection.len(), 1);
assert_eq!(collection[0].as_any().downcast_ref(), Some(&TestLayer("Layer A")));

pub fn clear(&mut self)

Removes all layers from the collection.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.clear();
assert_eq!(collection.len(), 0);

pub fn swap_remove(&mut self, index: usize) -> Box<dyn Layer>

Removes a layer from the collection and returns it. The removed element is replaced by the last layer in the collection.

Panics

Panics if index equals or greater then collection length.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

let removed = collection.swap_remove(0);
assert_eq!(removed.as_any().downcast_ref(), Some(&TestLayer("Layer A")));
assert_eq!(collection[0].as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn insert(&mut self, index: usize, layer: impl Layer + 'static)

Inserts a layer at position index, shifting all layers after it to the right.

Panics

Panics if index > len

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.insert(1, TestLayer("Layer C"));
assert_eq!(collection.len(), 3);
assert_eq!(collection[1].as_any().downcast_ref(), Some(&TestLayer("Layer C")));
assert_eq!(collection[2].as_any().downcast_ref(), Some(&TestLayer("Layer B")));

pub fn remove(&mut self, index: usize) -> Box<dyn Layer>

Removes a layer at index, shifting all layers after it to the left and returning the removed layer.

Panics

Panics if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

let removed = collection.remove(1);
assert_eq!(removed.as_any().downcast_ref(), Some(&TestLayer("Layer B")));
assert_eq!(collection.len(), 2);
assert_eq!(collection[1].as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&dyn Layer) -> bool,

Retains only the layers specified by the predicate. In other words, remove all layers l for which f(&l) returns false.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

collection.retain(|layer| !layer.as_any().downcast_ref::<TestLayer>().is_some_and(|l| l.0.ends_with("A")));

assert_eq!(collection.len(), 2);
assert_eq!(collection[0].as_any().downcast_ref(), Some(&TestLayer("Layer B")));
assert_eq!(collection[1].as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn push(&mut self, layer: impl Layer + 'static)

Adds the layer to the end of the collection.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.push(TestLayer("Layer C"));

assert_eq!(collection.len(), 3);
assert_eq!(collection[2].as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn pop(&mut self) -> Option<Box<dyn Layer>>

Removes the last layer from the collection and returns it. Returns None if the collection is empty.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

let removed = collection.pop();

assert_eq!(collection.len(), 2);
assert_eq!(removed.unwrap().as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn drain<R>( &mut self, range: R ) -> impl Iterator<Item = Box<dyn Layer>> + '_

where R: RangeBounds<usize>,

Removes the specified range of layers from the collection in bulk, returning all removed layers in an iterator. If the iterator is dropped before being fully consumed, it drops the remaining removed layers.

Panics

Panics if the starting point is greater than the end point and if the end point is greater that the length of the collection.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

let drained: Vec<_> = collection.drain(0..2).collect();
assert_eq!(drained.len(), 2);
assert_eq!(drained[1].as_any().downcast_ref(), Some(&TestLayer("Layer B")));

assert_eq!(collection.len(), 1);
assert_eq!(collection[0].as_any().downcast_ref(), Some(&TestLayer("Layer C")));

pub fn len(&self) -> usize

Returns the count of layers in the collection.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

assert_eq!(collection.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the collection contains zero layers.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::default();
assert!(collection.is_empty());

collection.push(TestLayer("Layer A"));
assert!(!collection.is_empty());

pub fn get(&self, index: usize) -> Option<&dyn Layer>

Returns a layer at index, or None if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

assert_eq!(collection.get(1).and_then(|layer| layer.as_any().downcast_ref()), Some(&TestLayer("Layer B")));
assert!(collection.get(2).is_none());

pub fn get_mut(&mut self, index: usize) -> Option<&mut Box<dyn Layer>>

Returns a mutable reference to a layer at index, or None if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

assert_eq!(collection.get_mut(1).and_then(|layer| layer.as_any_mut().downcast_ref()), Some(&TestLayer("Layer B")));
assert!(collection.get(2).is_none());

pub fn swap(&mut self, a: usize, b: usize)

Swaps two layers in the collection.

Panics

Panics if a or b are out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

collection.swap(1, 2);

assert_eq!(collection[1].as_any().downcast_ref(), Some(&TestLayer("Layer C")));
assert_eq!(collection[2].as_any().downcast_ref(), Some(&TestLayer("Layer B")));

pub fn iter(&self) -> impl Iterator<Item = &dyn Layer> + '_

Iterates over all layers in the collection.

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

let mut iterator = collection.iter();
assert_eq!(iterator.next().and_then(|layer| layer.as_any().downcast_ref()), Some(&TestLayer("Layer A")));
assert_eq!(iterator.next().and_then(|layer| layer.as_any().downcast_ref()), Some(&TestLayer("Layer B")));
assert!(iterator.next().is_none());

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn Layer>> + '_

Iterates over mutable references to all layers in the collection.

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

let mut iterator = collection.iter_mut();
assert_eq!(iterator.next().and_then(|layer| layer.as_any_mut().downcast_ref()), Some(&TestLayer("Layer A")));
assert_eq!(iterator.next().and_then(|layer| layer.as_any_mut().downcast_ref()), Some(&TestLayer("Layer B")));
assert!(iterator.next().is_none());

pub fn hide(&mut self, index: usize)

Sets the layer at index as invisible. The hidden layer can be later shown with LayerCollection::show.

Hidden layers are stored in the layer collection, but are not rendered to a map.

Panics

Panics if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.hide(1);
assert!(!collection.is_visible(1));

pub fn show(&mut self, index: usize)

Sets the layer at index as visible.

Hidden layers are stored in the layer collection, but are not rendered to a map.

Panics

Panics if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

collection.hide(1);
collection.show(1);
assert!(collection.is_visible(1));

pub fn show_by<F>(&mut self, f: F)

where F: FnMut(&dyn Layer) -> bool,

Sets all layers for which the predicate returns true as visible. The rest of layers are set as hidden.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

collection.show_by(|layer| layer.as_any().downcast_ref::<TestLayer>().unwrap().0.ends_with("B"));

assert!(!collection.is_visible(0));
assert!(collection.is_visible(1));
assert!(!collection.is_visible(2));

pub fn is_visible(&self, index: usize) -> bool

Returns true, if the layer at index is not hidden.

Hidden layers are stored in the layer collection, but are not rendered to a map.

Panics

Panics if index is out of bounds.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
]);

assert!(collection.is_visible(1));
collection.hide(1);
assert!(!collection.is_visible(1));
collection.show(1);
assert!(collection.is_visible(1));

pub fn iter_visible(&self) -> impl Iterator<Item = &dyn Layer> + '_

Iterates over all visible layers in the collection.

Examples

use galileo::LayerCollection;
use galileo::layer::TestLayer;

let mut collection = LayerCollection::from(vec![
    TestLayer("Layer A"),
    TestLayer("Layer B"),
    TestLayer("Layer C"),
]);

collection.hide(1);

let mut iterator = collection.iter_visible();
assert_eq!(iterator.next().and_then(|layer| layer.as_any().downcast_ref()), Some(&TestLayer("Layer A")));
assert_eq!(iterator.next().and_then(|layer| layer.as_any().downcast_ref()), Some(&TestLayer("Layer C")));
assert!(iterator.next().is_none());

Trait Implementations

impl Default for LayerCollection

fn default() -> LayerCollection

Returns the “default value” for a type.

impl<L: Into<LayerEntry>, T: IntoIterator<Item = L>> From<T> for LayerCollection

fn from(value: T) -> Self

Converts to this type from the input type.

impl Index<usize> for LayerCollection

type Output = dyn Layer

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for LayerCollection

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.