[−][src]Trait genco::tokens::Register

pub trait Register<L> where
    L: Lang, {
    fn register(self, tokens: &mut Tokens<L>);
}

Helper trait to convert something into a stream of registrations.

Thanks to this, we can provide a flexible number of arguments to register(), like a tuple.

This is trait is very similar to FormatInto, except that it constrains the types that can be "registered" to only language items. An implementation of register must not be used as a substitute for FormatInto.

Examples

use genco::prelude::*;

let mut tokens = rust::Tokens::new();

let hash_map = rust::import("std::collections", "HashMap");
let btree_map = rust::import("std::collections", "BTreeMap");

tokens.register((hash_map, btree_map));

assert_eq!(
    vec![
        "use std::collections::{BTreeMap, HashMap};",
    ],
    tokens.to_file_vec()?,
);

Required methods

fn register(self, tokens: &mut Tokens<L>)

Convert the type into tokens.

Loading content...

Implementations on Foreign Types

impl<L, T1> Register<L> for (T1,) where
    T1: Register<L>,
    L: Lang, [src]

impl<L, T1, T2> Register<L> for (T1, T2) where
    T1: Register<L>,
    T2: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3> Register<L> for (T1, T2, T3) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3, T4> Register<L> for (T1, T2, T3, T4) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    T4: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3, T4, T5> Register<L> for (T1, T2, T3, T4, T5) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    T4: Register<L>,
    T5: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3, T4, T5, T6> Register<L> for (T1, T2, T3, T4, T5, T6) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    T4: Register<L>,
    T5: Register<L>,
    T6: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3, T4, T5, T6, T7> Register<L> for (T1, T2, T3, T4, T5, T6, T7) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    T4: Register<L>,
    T5: Register<L>,
    T6: Register<L>,
    T7: Register<L>,
    L: Lang, [src]

impl<L, T1, T2, T3, T4, T5, T6, T7, T8> Register<L> for (T1, T2, T3, T4, T5, T6, T7, T8) where
    T1: Register<L>,
    T2: Register<L>,
    T3: Register<L>,
    T4: Register<L>,
    T5: Register<L>,
    T6: Register<L>,
    T7: Register<L>,
    T8: Register<L>,
    L: Lang, [src]

Loading content...

Implementors

impl Register<Csharp> for genco::lang::csharp::Import[src]

impl Register<Dart> for genco::lang::dart::Import[src]

impl Register<Go> for genco::lang::go::Import[src]

impl Register<Java> for genco::lang::java::Import[src]

impl Register<JavaScript> for genco::lang::js::Import[src]

impl Register<Python> for genco::lang::python::Import[src]

impl Register<Python> for ImportModule[src]

impl Register<Rust> for genco::lang::rust::Import[src]

impl Register<Swift> for genco::lang::swift::Import[src]

impl<'a> Register<Csharp> for &'a genco::lang::csharp::Import[src]

impl<'a> Register<Dart> for &'a genco::lang::dart::Import[src]

impl<'a> Register<Go> for &'a genco::lang::go::Import[src]

impl<'a> Register<Java> for &'a genco::lang::java::Import[src]

impl<'a> Register<JavaScript> for &'a genco::lang::js::Import[src]

impl<'a> Register<Python> for &'a genco::lang::python::Import[src]

impl<'a> Register<Python> for &'a ImportModule[src]

impl<'a> Register<Rust> for &'a genco::lang::rust::Import[src]

impl<'a> Register<Swift> for &'a genco::lang::swift::Import[src]

Loading content...