Trait fj_kernel::builder::ObjectArgument

pub trait ObjectArgument<T>: IntoIterator<Item = T> {
    type SameSize<R>;
    type SizePlusOne<R>;

    fn num_objects(&self) -> usize;
    fn map<F, R>(self, f: F) -> Self::SameSize<R>
    where
        F: FnMut(T) -> R;
    fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>
    where
        F: FnMut(T) -> R;
}

Pass objects to a builder method

Many builder methods receive objects as arguments, and many builder arguments return objects back, based on their input. In the general case, the number of objects passed and returned is usually arbitrary, but many callers pass a specific number of objects, and expect the same number of objects back.

This trait can be used to do exactly that. It is implemented for Vec and arrays. When passing a Vec, a Vec is returned. When passing an array, an array of the same size is returned.

Required Associated Types

type SameSize<R>

The value returned, if the implementing type is passed on an argument

The return value has the same length as the implementing type, but it is not necessarily of the same type. For this reason, this associated type is generic.

type SizePlusOne<R>

A return value that has one more element than the argument

Required Methods

fn num_objects(&self) -> usize

Return the number of objects

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

Create a return value by mapping the implementing type

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

Create a return value with one more element

Implementations on Foreign Types

impl<T> ObjectArgument<T> for Vec<T>

type SameSize<R> = Vec<R, Global>

type SizePlusOne<R> = Vec<R, Global>

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 0]

type SameSize<R> = [R; 0]

type SizePlusOne<R> = [R; 1]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 1]

type SameSize<R> = [R; 1]

type SizePlusOne<R> = [R; 2]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 2]

type SameSize<R> = [R; 2]

type SizePlusOne<R> = [R; 3]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 3]

type SameSize<R> = [R; 3]

type SizePlusOne<R> = [R; 4]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 4]

type SameSize<R> = [R; 4]

type SizePlusOne<R> = [R; 5]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 5]

type SameSize<R> = [R; 5]

type SizePlusOne<R> = [R; 6]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 6]

type SameSize<R> = [R; 6]

type SizePlusOne<R> = [R; 7]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

impl<T> ObjectArgument<T> for [T; 7]

type SameSize<R> = [R; 7]

type SizePlusOne<R> = [R; 8]

fn num_objects(&self) -> usize

fn map<F, R>(self, f: F) -> Self::SameSize<R>where
    F: FnMut(T) -> R,

fn map_plus_one<F, R>(self, item: R, f: F) -> Self::SizePlusOne<R>where
    F: FnMut(T) -> R,

Implementors