1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

//! Empty data provider implementations.
//!
//! Use [`EmptyDataProvider`] as a stand-in for a provider that always fails.

use alloc::collections::BTreeSet;
#[cfg(feature = "export")]
use icu_provider::export::ExportableProvider;
use icu_provider::prelude::*;

/// A data provider that always returns an error.
///
/// The returned error kind is configurable.
///
/// # Examples
///
/// ```
/// use icu_provider::hello_world::HelloWorldV1Marker;
/// use icu_provider::prelude::*;
/// use icu_provider_adapters::empty::EmptyDataProvider;
///
/// let provider = EmptyDataProvider::new();
///
/// assert!(matches!(
///     provider.load_any(HelloWorldV1Marker::INFO, Default::default()),
///     Err(DataError {
///         kind: DataErrorKind::MarkerNotFound,
///         ..
///     })
/// ));
/// ```
#[derive(Debug)]
pub struct EmptyDataProvider {
    error_kind: DataErrorKind,
}

impl Default for EmptyDataProvider {
    fn default() -> Self {
        Self::new()
    }
}

impl EmptyDataProvider {
    /// Creates a data provider that always returns [`DataErrorKind::MarkerNotFound`].
    pub fn new() -> Self {
        Self {
            error_kind: DataErrorKind::MarkerNotFound,
        }
    }

    /// Creates a data provider that always returns the specified error kind.
    pub fn new_with_error_kind(error_kind: DataErrorKind) -> Self {
        Self { error_kind }
    }
}

impl AnyProvider for EmptyDataProvider {
    fn load_any(
        &self,
        marker: DataMarkerInfo,
        base_req: DataRequest,
    ) -> Result<AnyResponse, DataError> {
        Err(self.error_kind.with_req(marker, base_req))
    }
}

impl<M> DynamicDataProvider<M> for EmptyDataProvider
where
    M: DynamicDataMarker,
{
    fn load_data(
        &self,
        marker: DataMarkerInfo,
        base_req: DataRequest,
    ) -> Result<DataResponse<M>, DataError> {
        Err(self.error_kind.with_req(marker, base_req))
    }
}

impl<M> DataProvider<M> for EmptyDataProvider
where
    M: DataMarker,
{
    fn load(&self, base_req: DataRequest) -> Result<DataResponse<M>, DataError> {
        Err(self.error_kind.with_req(M::INFO, base_req))
    }
}

impl<M> IterableDataProvider<M> for EmptyDataProvider
where
    M: DataMarker,
{
    fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
        Ok(Default::default())
    }
}

impl<M> IterableDynamicDataProvider<M> for EmptyDataProvider
where
    M: DynamicDataMarker,
{
    fn iter_ids_for_marker(
        &self,
        _: DataMarkerInfo,
    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
        Ok(Default::default())
    }
}

#[cfg(feature = "export")]
impl ExportableProvider for EmptyDataProvider {
    fn supported_markers(&self) -> std::collections::HashSet<DataMarkerInfo> {
        Default::default()
    }
}