vendor/icu_provider_adapters/src/either.rs

   1 // This file is part of ICU4X. For terms of use, please see the file
   2 // called LICENSE at the top level of the ICU4X source tree
   3 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
   4
   5 //! Helpers for switching between multiple providers.
   6
   7 use icu_provider::prelude::*;
   8
   9 #[cfg(feature = "datagen")]
  10 use icu_provider::datagen;
  11
  12 /// A provider that is one of two types determined at runtime.
  13 ///
  14 /// Data provider traits implemented by both `P0` and `P1` are implemented on
  15 /// `EitherProvider<P0, P1>`.
  16 #[allow(clippy::exhaustive_enums)] // this is stable
  17 pub enum EitherProvider<P0, P1> {
  18     /// A value of type `P0`.
  19     A(P0),
  20     /// A value of type `P1`.
  21     B(P1),
  22 }
  23
  24 impl<P0: AnyProvider, P1: AnyProvider> AnyProvider for EitherProvider<P0, P1> {
  25     #[inline]
  26     fn load_any(&self, key: DataKey, req: DataRequest) -> Result<AnyResponse, DataError> {
  27         use EitherProvider::*;
  28         match self {
  29             A(p) => p.load_any(key, req),
  30             B(p) => p.load_any(key, req),
  31         }
  32     }
  33 }
  34
  35 impl<P0: BufferProvider, P1: BufferProvider> BufferProvider for EitherProvider<P0, P1> {
  36     #[inline]
  37     fn load_buffer(
  38         &self,
  39         key: DataKey,
  40         req: DataRequest,
  41     ) -> Result<DataResponse<BufferMarker>, DataError> {
  42         use EitherProvider::*;
  43         match self {
  44             A(p) => p.load_buffer(key, req),
  45             B(p) => p.load_buffer(key, req),
  46         }
  47     }
  48 }
  49
  50 impl<M: DataMarker, P0: DynamicDataProvider<M>, P1: DynamicDataProvider<M>> DynamicDataProvider<M>
  51     for EitherProvider<P0, P1>
  52 {
  53     #[inline]
  54     fn load_data(&self, key: DataKey, req: DataRequest) -> Result<DataResponse<M>, DataError> {
  55         use EitherProvider::*;
  56         match self {
  57             A(p) => p.load_data(key, req),
  58             B(p) => p.load_data(key, req),
  59         }
  60     }
  61 }
  62
  63 impl<M: KeyedDataMarker, P0: DataProvider<M>, P1: DataProvider<M>> DataProvider<M>
  64     for EitherProvider<P0, P1>
  65 {
  66     #[inline]
  67     fn load(&self, req: DataRequest) -> Result<DataResponse<M>, DataError> {
  68         use EitherProvider::*;
  69         match self {
  70             A(p) => p.load(req),
  71             B(p) => p.load(req),
  72         }
  73     }
  74 }
  75
  76 #[cfg(feature = "datagen")]
  77 impl<
  78         M: DataMarker,
  79         P0: datagen::IterableDynamicDataProvider<M>,
  80         P1: datagen::IterableDynamicDataProvider<M>,
  81     > datagen::IterableDynamicDataProvider<M> for EitherProvider<P0, P1>
  82 {
  83     #[inline]
  84     fn supported_locales_for_key(
  85         &self,
  86         key: DataKey,
  87     ) -> Result<alloc::vec::Vec<DataLocale>, DataError> {
  88         use EitherProvider::*;
  89         match self {
  90             A(p) => p.supported_locales_for_key(key),
  91             B(p) => p.supported_locales_for_key(key),
  92         }
  93     }
  94 }
  95
  96 #[cfg(feature = "datagen")]
  97 impl<
  98         M: KeyedDataMarker,
  99         P0: datagen::IterableDataProvider<M>,
 100         P1: datagen::IterableDataProvider<M>,
 101     > datagen::IterableDataProvider<M> for EitherProvider<P0, P1>
 102 {
 103     #[inline]
 104     fn supported_locales(&self) -> Result<alloc::vec::Vec<DataLocale>, DataError> {
 105         use EitherProvider::*;
 106         match self {
 107             A(p) => p.supported_locales(),
 108             B(p) => p.supported_locales(),
 109         }
 110     }
 111 }