Trait yamlette::orchestra::chord::Chord

pub trait Chord {
    fn chord_size(&self) -> usize;
    fn play(
        self,
        orchestra: &Orchestra,
        level: usize,
        alias: Option<Cow<'static, str>>,
        cs: CommonStyles,
        vs: &mut [&mut dyn Style]
    ) -> Result<(), OrchError>;
}

Required Methods

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

Implementations on Foreign Types

impl Chord for bool

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for char

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for &'static str

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for String

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for u8

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for i8

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for u16

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for i16

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for u32

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for i32

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for u64

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for i64

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for usize

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for isize

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for BigUint

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for BigInt

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for f32

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for f64

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for Fraction

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for BigFraction

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl Chord for ()

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for Vec<T>where
    T: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for VecDeque<T>where
    T: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for LinkedList<T>where
    T: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for BinaryHeap<T>where
    T: Chord + Ord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<K, V> Chord for HashMap<K, V>where
    K: Chord + Eq + Hash,
    V: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<K, V> Chord for BTreeMap<K, V>where
    K: Chord,
    V: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for HashSet<T>where
    T: Chord + Eq + Hash,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

impl<T> Chord for BTreeSet<T>where
    T: Chord,

fn chord_size(&self) -> usize

fn play(
    self,
    orchestra: &Orchestra,
    level: usize,
    alias: Option<Cow<'static, str>>,
    cs: CommonStyles,
    vs: &mut [&mut dyn Style]
) -> Result<(), OrchError>

Implementors

impl Chord for IncognitumValue

impl Chord for BinaryValue

impl Chord for EmptyDict

impl Chord for EmptyList

impl<K, V> Chord for Omap<BTreeMap<K, V>>where
    K: Chord,
    V: Chord,

impl<K, V> Chord for Omap<Vec<(K, V)>>where
    K: Chord,
    V: Chord,

impl<K, V> Chord for Pairs<BTreeMap<K, V>>where
    K: Chord,
    V: Chord,

impl<K, V> Chord for Pairs<Vec<(K, V)>>where
    K: Chord,
    V: Chord,

impl<T> Chord for Set<BTreeSet<T>>where
    T: Chord,

impl<T> Chord for Set<Vec<T>>where
    T: Chord,

impl<T> Chord for Set<HashSet<T>>where
    T: Chord + Eq + Hash,