Trait PlaceholderValueProvider

pub trait PlaceholderValueProvider<K> {
    type Error;
    type W<'a>: TryWriteable<Error = Self::Error>
       where Self: 'a;
    type L<'a, 'l>: Writeable
       where Self: 'a;

    // Required methods
    fn value_for(&self, key: K) -> Self::W<'_>;
    fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>;
}

Trait implemented on collections that can produce TryWriteables for interpolation.

This trait can add Parts for individual literals or placeholders. The implementations of this trait on standard types do not add any Parts.

This trait has a blanket implementation and is therefore not implementable by user code.

Examples

A custom implementation that adds parts:

use core::str::FromStr;
use icu_pattern::Pattern;
use icu_pattern::DoublePlaceholder;
use icu_pattern::DoublePlaceholderKey;
use icu_pattern::PlaceholderValueProvider;
use writeable::adapters::WithPart;
use writeable::adapters::WriteableAsTryWriteableInfallible;
use writeable::assert_writeable_parts_eq;
use writeable::Part;
use writeable::Writeable;

let pattern = Pattern::<DoublePlaceholder>::try_from_str(
    "Hello, {0} and {1}!",
    Default::default(),
)
.unwrap();

struct ValuesWithParts<'a>(&'a str, &'a str);

const PART_PLACEHOLDER_0: Part = Part {
    category: "custom",
    value: "placeholder0",
};
const PART_PLACEHOLDER_1: Part = Part {
    category: "custom",
    value: "placeholder1",
};
const PART_LITERAL: Part = Part {
    category: "custom",
    value: "literal",
};

impl PlaceholderValueProvider<DoublePlaceholderKey> for ValuesWithParts<'_> {
    type Error = core::convert::Infallible;

    type W<'a> = WriteableAsTryWriteableInfallible<WithPart<&'a str>>
    where
        Self: 'a;

    type L<'a, 'l> = WithPart<&'l str>
    where
        Self: 'a;

    #[inline]
    fn value_for(&self, key: DoublePlaceholderKey) -> Self::W<'_> {
        let writeable = match key {
            DoublePlaceholderKey::Place0 => WithPart {
                writeable: self.0,
                part: PART_PLACEHOLDER_0,
            },
            DoublePlaceholderKey::Place1 => WithPart {
                writeable: self.1,
                part: PART_PLACEHOLDER_1,
            },
        };
        WriteableAsTryWriteableInfallible(writeable)
    }

    #[inline]
    fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l> {
        WithPart {
            writeable: literal,
            part: PART_LITERAL,
        }
    }
}

assert_writeable_parts_eq!(
    pattern.interpolate(ValuesWithParts("Alice", "Bob")),
    "Hello, Alice and Bob!",
    [
        (0, 7, PART_LITERAL),
        (7, 12, PART_PLACEHOLDER_0),
        (12, 17, PART_LITERAL),
        (17, 20, PART_PLACEHOLDER_1),
        (20, 21, PART_LITERAL),
    ]
);

Required Associated Types

type Error

type W<'a>: TryWriteable<Error = Self::Error> where Self: 'a

The type of TryWriteable returned by Self::value_for.

To return a Writeable, wrap it with WriteableAsTryWriteableInfallible.

type L<'a, 'l>: Writeable where Self: 'a

The type of Writeable returned by Self::map_literal.

If you are not adding parts, this can be &'l str.

Required Methods

fn value_for(&self, key: K) -> Self::W<'_>

Returns the TryWriteable to substitute for the given placeholder.

See PatternItem::Placeholder

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

Maps a literal string to a Writeable that could contain parts.

See PatternItem::Literal

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'k, K, W> PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>> for BTreeMap<K, W>

where K: Ord + Borrow<str>, W: Writeable,

type Error = MissingNamedPlaceholderError<'k>

type W<'a> = Result<&'a W, <BTreeMap<K, W> as PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>>>::Error> where Self: 'a

type L<'a, 'l> = &'l str where Self: 'a

fn value_for<'a>(&'a self, key: MultiNamedPlaceholderKey<'k>) -> Self::W<'a>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

impl<K, T> PlaceholderValueProvider<K> for &T

where T: PlaceholderValueProvider<K> + ?Sized,

type Error = <T as PlaceholderValueProvider<K>>::Error

type W<'a> = <T as PlaceholderValueProvider<K>>::W<'a> where Self: 'a

type L<'a, 'l> = <T as PlaceholderValueProvider<K>>::L<'a, 'l> where Self: 'a

fn value_for(&self, key: K) -> Self::W<'_>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

impl<W0, W1> PlaceholderValueProvider<DoublePlaceholderKey> for (W0, W1)

where W0: Writeable, W1: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<Either<&'a W0, &'a W1>> where Self: 'a

type L<'a, 'l> = &'l str where Self: 'a

fn value_for(&self, key: DoublePlaceholderKey) -> Self::W<'_>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

impl<W> PlaceholderValueProvider<DoublePlaceholderKey> for [W; 2]

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where Self: 'a

type L<'a, 'l> = &'l str where Self: 'a

fn value_for(&self, key: DoublePlaceholderKey) -> Self::W<'_>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

impl<W> PlaceholderValueProvider<SinglePlaceholderKey> for [W; 1]

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where Self: 'a

type L<'a, 'l> = &'l str where Self: 'a

fn value_for(&self, _key: SinglePlaceholderKey) -> Self::W<'_>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

impl<W> PlaceholderValueProvider<SinglePlaceholderKey> for (W,)

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where Self: 'a

type L<'a, 'l> = &'l str where Self: 'a

fn value_for(&self, _key: SinglePlaceholderKey) -> Self::W<'_>

fn map_literal<'a, 'l>(&'a self, literal: &'l str) -> Self::L<'a, 'l>

Implementors