Trait icu::pattern::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.

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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

where T: PlaceholderValueProvider<K> + ?Sized,

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

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

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

fn value_for(&self, key: K) -> <&'b T as PlaceholderValueProvider<K>>::W<'_>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <&'b T as PlaceholderValueProvider<K>>::L<'a, 'l>

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 BTreeMap<K, W>: 'a

type L<'a, 'l> = &'l str where BTreeMap<K, W>: 'a

fn value_for<'a>( &'a self, key: MultiNamedPlaceholderKey<'k>, ) -> <BTreeMap<K, W> as PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>>>::W<'a>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <BTreeMap<K, W> as PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>>>::L<'a, 'l>

impl<'k, K, W, S> PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>> for LiteMap<K, W, S>

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

type Error = MissingNamedPlaceholderError<'k>

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

type L<'a, 'l> = &'l str where LiteMap<K, W, S>: 'a

fn value_for<'a>( &'a self, key: MultiNamedPlaceholderKey<'k>, ) -> <LiteMap<K, W, S> as PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>>>::W<'a>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <LiteMap<K, W, S> as PlaceholderValueProvider<MultiNamedPlaceholderKey<'k>>>::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 (W0, W1): 'a

type L<'a, 'l> = &'l str where (W0, W1): 'a

fn value_for( &self, key: DoublePlaceholderKey, ) -> <(W0, W1) as PlaceholderValueProvider<DoublePlaceholderKey>>::W<'_>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <(W0, W1) as PlaceholderValueProvider<DoublePlaceholderKey>>::L<'a, 'l>

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

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where [W; 2]: 'a

type L<'a, 'l> = &'l str where [W; 2]: 'a

fn value_for( &self, key: DoublePlaceholderKey, ) -> <[W; 2] as PlaceholderValueProvider<DoublePlaceholderKey>>::W<'_>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <[W; 2] as PlaceholderValueProvider<DoublePlaceholderKey>>::L<'a, 'l>

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

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where [W; 1]: 'a

type L<'a, 'l> = &'l str where [W; 1]: 'a

fn value_for( &self, _key: SinglePlaceholderKey, ) -> <[W; 1] as PlaceholderValueProvider<SinglePlaceholderKey>>::W<'_>

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <[W; 1] as PlaceholderValueProvider<SinglePlaceholderKey>>::L<'a, 'l>

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

where W: Writeable,

type Error = Infallible

type W<'a> = WriteableAsTryWriteableInfallible<&'a W> where (W,): 'a

type L<'a, 'l> = &'l str where (W,): 'a

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

fn map_literal<'a, 'l>( &'a self, literal: &'l str, ) -> <(W,) as PlaceholderValueProvider<SinglePlaceholderKey>>::L<'a, 'l>

Implementors