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.

Implementations on Foreign Types

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

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

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

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

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

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

Implementors

impl Register<Csharp> for genco::lang::csharp::Import

impl Register<Dart> for genco::lang::dart::Import

impl Register<Go> for genco::lang::go::Import

impl Register<Java> for genco::lang::java::Import

impl Register<JavaScript> for genco::lang::js::Import

impl Register<Python> for genco::lang::python::Import

impl Register<Python> for ImportModule

impl Register<Rust> for genco::lang::rust::Import

impl Register<Swift> for genco::lang::swift::Import

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

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

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

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

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

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

impl<'a> Register<Python> for &'a ImportModule

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

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