Struct plexus::index::LruIndexer

pub struct LruIndexer<T, K> where
    T: Topological,
    K: Clone + PartialEq,  { /* private fields */ }

LRU caching vertex indexer.

This indexer uses a least recently used (LRU) cache to form an index. To function correctly, an adequate cache capacity is necessary. If the capacity is insufficient, then redundant vertex data may be emitted. See LruIndexer::with_capacity.

This indexer is useful if the vertex key data does not implement Hash. If the key data can be hashed, prefer HashIndexer instead.

Examples

use nalgebra::Point3;
use plexus::index::{Flat3, LruIndexer};
use plexus::prelude::*;
use plexus::primitive::generate::Position;
use plexus::primitive::sphere::UvSphere;

let (indices, positions) = UvSphere::new(8, 8)
    .polygons::<Position<Point3<f64>>>()
    .triangulate()
    .index_vertices::<Flat3, _>(LruIndexer::with_capacity(64));

Implementations

impl<T, K> LruIndexer<T, K> where
    T: Topological,
    K: Clone + PartialEq, 

pub fn new() -> Self

Creates a new LruIndexer with a default capacity.

pub fn with_capacity(capacity: usize) -> Self

Creates a new LruIndexer with the specified capacity.

The capacity of the cache must be sufficient in order to generate a unique set of index and vertex data.

Trait Implementations

impl<T, K> Default for LruIndexer<T, K> where
    T: Topological,
    K: Clone + PartialEq, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, K> Indexer<T, K> for LruIndexer<T, K> where
    T: Topological,
    K: Clone + PartialEq, 

fn index<F>(&mut self, input: T::Vertex, f: F) -> (usize, Option<T::Vertex>) where
    F: Fn(&T::Vertex) -> &K, 

Indexes a vertex using a keying function.