# [−][src]Struct plexus::primitive::decompose::Decompose

pub struct Decompose<I, P, Q, R> where    R: IntoIterator<Item = Q>,  { /* fields omitted */ }

## Methods

### impl<I, P, R> Decompose<I, P, P, R> where    I: Iterator<Item = P>,    R: IntoIterator<Item = P>, [src]

#### ⓘImportant traits for Decompose<I, P, Q, R>### Important traits for Decompose<I, P, Q, R> impl<I, P, Q, R> Iterator for Decompose<I, P, Q, R> where    I: Iterator<Item = P>,    R: IntoIterator<Item = Q>,  type Item = Q;pub fn remap(self, n: usize) -> Decompose<impl Iterator<Item = P>, P, P, R>[src]

Reapplies a congruent decomposition.

A decomposition is congruent if its input and output types are the same. This is useful when the number of applications is somewhat large or variable, in which case chaining calls is impractical or impossible.

# Examples

use decorum::N64;
use nalgebra::Point3;
use plexus::index::{Flat4, HashIndexer};
use plexus::prelude::*;
use plexus::primitive::cube::Cube;
use plexus::primitive::generate::Position;

let (indices, positions) = Cube::new()
.polygons::<Position<Point3<N64>>>()
.subdivide()
.remap(7) // 8 subdivision operations are applied.
.index_vertices::<Flat4, _>(HashIndexer::default());

## Trait Implementations

### impl<I, P, Q, R> Iterator for Decompose<I, P, Q, R> where    I: Iterator<Item = P>,    R: IntoIterator<Item = Q>, [src]

#### type Item = Q

The type of the elements being iterated over.

## Blanket Implementations

### impl<I> IntoIterator for I where    I: Iterator, [src]

#### type Item = <I as Iterator>::Item

The type of the elements being iterated over.

#### type IntoIter = I

Which kind of iterator are we turning this into?

### impl<T, U> TryFrom<U> for T where    U: Into<T>, [src]

#### type Error = Infallible

The type returned in the event of a conversion error.

### impl<T, U> TryInto<U> for T where    U: TryFrom<T>, [src]

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

### impl<T> Same<T> for T

#### type Output = T

Should always be Self