currency_engineering/fred_api - Change T44AFTDLSOJ7GS4CIZLVNJCX4F5GJSGFUXBI6OBLHNILYQLZCFWQC

Handle response errors.

Created by efindlay on April 26, 2021

T44AFTDLSOJ7GS4CIZLVNJCX4F5GJSGFUXBI6OBLHNILYQLZCFWQC

Dependencies

In channels

main

Change contents

Replacement in src/lib.rs at line 19 [3.21264]

B:BD[3.21703] → [3.21703:21800]

    pub fn category(category_id: usize) -> Categories { 
        serde_json::from_str(&response(

[3.21703]

[3.21800]

    /// ```
    /// for i in 0..100 {
    ///     match Fred::category(i) {
    ///         Ok(category) => println!("{}\n{}", i, category),
    ///         Err(json_err) => {},
    ///     }
    /// }
    /// ```
    pub fn category(category_id: usize) -> Result<Categories, String> { 
        let response = response(

Replacement in src/lib.rs at line 33 [3.21264]

B:BD[3.21912] → [3.21912:21932]

        )).unwrap()

[3.21912]

[3.21932]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 38 [3.21264]

B:BD[3.22073] → [3.22073:22178]

    pub fn category_children(category_id: usize) -> Categories {
        serde_json::from_str(&response(

[3.22073]

[3.22178]

    pub fn category_children(category_id: usize) -> Result<Categories, String> {
        let response = response(

Replacement in src/lib.rs at line 44 [3.21264]

B:BD[3.22299] → [3.22299:22319]

        )).unwrap()

[3.22299]

[3.22319]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 49 [3.21264]

B:BD[3.22448] → [3.22448:22552]

    pub fn category_related(category_id: usize) -> Categories {
        serde_json::from_str(&response(

[3.22448]

[3.22552]

    pub fn category_related(category_id: usize) -> Result<Categories, String> {
        let response = response(

Replacement in src/lib.rs at line 55 [3.21264]

B:BD[3.22672] → [3.22672:22692]

        )).unwrap()

[3.22672]

[3.22692]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 60 [3.21264]

B:BD[3.22807] → [3.22807:22914]

    pub fn category_series(category_id: usize) -> CategorySeries {
        serde_json::from_str(&response(

[3.22807]

[3.22914]

    /// ```
    /// match Fred::category_series(9) {
    ///     Ok(category_series) => println!("{}", category_series),
    ///     Err(serde_err) => println!("{}", serde_err),
    /// };
    /// ```
    pub fn category_series(category_id: usize) -> Result<CategorySeries, String> {
        let response = response(

Replacement in src/lib.rs at line 72 [3.21264]

B:BD[3.23033] → [3.23033:23053]

        )).unwrap()

[3.23033]

[3.23053]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 77 [3.21264]

B:BD[3.23165] → [3.23165:23268]

    pub fn category_tags(category_id: usize) -> CategoryTags {
        serde_json::from_str(&response(

[3.23165]

[3.23268]

    pub fn category_tags(category_id: usize) -> Result<CategoryTags, String> {
        let response = response(

Replacement in src/lib.rs at line 83 [3.21264]

B:BD[3.23385] → [3.23385:23405]

        )).unwrap()

[3.23385]

[3.23405]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 88 [3.21264]

B:BD[3.23533] → [3.23533:23668]

    pub fn category_related_tags(category_id: usize, tag_names: &str) -> CategoryRelatedTags {
        serde_json::from_str(&response(

[3.23533]

[3.23668]

    pub fn category_related_tags(category_id: usize, tag_names: &str) -> Result<CategoryRelatedTags, String> {
        let response = response(

Replacement in src/lib.rs at line 95 [3.21264]

B:BD[3.23846] → [3.23846:23866]

        )).unwrap()

[3.23846]

[3.23866]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 100 [3.21264]

B:BD[3.23975] → [3.23975:24052]

    pub fn releases() -> Releases { 
        serde_json::from_str(&response(

[3.23975]

[3.24052]

    pub fn releases() -> Result<Releases, String> { 
        let response = response(

Replacement in src/lib.rs at line 104 [3.21264]

B:BD[3.24100] → [3.24100:24120]

        )).unwrap()

[3.24100]

[3.24120]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 109 [3.21264]

B:BD[3.24253] → [3.24253:24340]

    pub fn releases_dates() -> ReleaseDates { 
        serde_json::from_str(&response(

[3.24253]

[3.24340]

    pub fn releases_dates() -> Result<ReleaseDates, String> { 
        let response = response(

Replacement in src/lib.rs at line 113 [3.21264]

B:BD[3.24394] → [3.24394:24414]

        )).unwrap()

[3.24394]

[3.24414]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 118 [3.21264]

B:BD[3.24519] → [3.24519:24611]

    pub fn release(release_id: usize) -> Release { 
        serde_json::from_str(&response(

[3.24519]

[3.24611]

    pub fn release(release_id: usize) -> Result<Release, String> { 
        let response = response(

Replacement in src/lib.rs at line 124 [3.21264]

B:BD[3.24720] → [3.24720:24740]

        )).unwrap()

[3.24720]

[3.24740]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 129 [3.21264]

B:BD[3.24869] → [3.24869:24972]

    pub fn release_dates(release_id: usize) -> ReleaseDates { 
        serde_json::from_str(&response(

[3.24869]

[3.24972]

    pub fn release_dates(release_id: usize) -> Result<ReleaseDates, String> { 
        let response = response(

Replacement in src/lib.rs at line 135 [3.21264]

B:BD[3.25087] → [3.25087:25107]

        )).unwrap()

[3.25087]

[3.25107]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 140 [3.21264]

B:BD[3.25233] → [3.25233:25338]

    pub fn release_series(release_id: usize) -> ReleaseSeries { 
        serde_json::from_str(&response(

[3.25233]

[3.25338]

    pub fn release_series(release_id: usize) -> Result<ReleaseSeries, String> { 
        let response = response(

Replacement in src/lib.rs at line 146 [3.21264]

B:BD[3.25454] → [3.25454:25474]

        )).unwrap()

[3.25454]

[3.25474]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 151 [3.21264]

B:BD[3.25603] → [3.25603:25710]

    pub fn release_sources(release_id: usize) -> ReleaseSources { 
        serde_json::from_str(&response(

[3.25603]

[3.25710]

    pub fn release_sources(release_id: usize) -> Result<ReleaseSources, String> { 
        let response = response(

Replacement in src/lib.rs at line 157 [3.21264]

B:BD[3.25827] → [3.25827:25847]

        )).unwrap()

[3.25827]

[3.25847]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 162 [3.21264]

B:BD[3.25953] → [3.25953:26054]

    pub fn release_tags(release_id: usize) -> ReleaseTags { 
        serde_json::from_str(&response(

[3.25953]

[3.26054]

    pub fn release_tags(release_id: usize) -> Result<ReleaseTags, String> { 
        let response = response(

Replacement in src/lib.rs at line 168 [3.21264]

B:BD[3.26168] → [3.26168:26188]

        )).unwrap()

[3.26168]

[3.26188]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 173 [3.21264]

B:BD[3.26310] → [3.26310:26443]

    pub fn release_related_tags(release_id: usize, tag_names: &str) -> ReleaseRelatedTags { 
        serde_json::from_str(&response(

[3.26310]

[3.26443]

    pub fn release_related_tags(release_id: usize, tag_names: &str) -> Result<ReleaseRelatedTags, String> { 
        let response = response(

Replacement in src/lib.rs at line 180 [3.21264]

B:BD[3.26618] → [3.26618:26638]

        )).unwrap()

[3.26618]

[3.26638]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 185 [3.21264]

B:BD[3.26762] → [3.26762:26867]

    pub fn release_tables(release_id: usize) -> ReleaseTables { 
        serde_json::from_str(&response(

[3.26762]

[3.26867]

    pub fn release_tables(release_id: usize) -> Result<ReleaseTables, String> { 
        let response = response(

Replacement in src/lib.rs at line 191 [3.21264]

B:BD[3.26983] → [3.26983:27003]

        )).unwrap()

[3.26983]

[3.27003]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 196 [3.21264]

B:BD[3.27104] → [3.27104:27192]

    pub fn series(series_id: &str) -> Series { 
        serde_json::from_str(&response(

[3.27104]

[3.27192]

    pub fn series(series_id: &str) -> Result<Series, String> { 
        let response = response(

Replacement in src/lib.rs at line 202 [3.21264]

B:BD[3.27298] → [3.27298:27318]

        )).unwrap()

[3.27298]

[2.3795]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 207 [3.21264]

B:BD[2.3846] → [2.3846:3916]

    pub fn series_json(series_id: &str) -> String {
        response(

[2.3846]

[2.3916]

    pub fn series_json(series_id: &str) -> Result<String, String> {
        let response = response(

Replacement in src/lib.rs at line 213 [3.21264]

B:BD[2.4022] → [2.4022:4032]

[2.4022]

[3.27318]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 218 [3.21264]

B:BD[3.27449] → [3.27449:27552]

    pub fn series_categories(series_id: &str) -> Categories { 
        serde_json::from_str(&response(

[3.27449]

[3.27552]

    pub fn series_categories(series_id: &str) -> Result<Categories, String> { 
        let response = response(

Replacement in src/lib.rs at line 224 [3.21264]

B:BD[3.27669] → [3.27669:27689]

        )).unwrap()

[3.27669]

[3.27689]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 229 [3.21264]

B:BD[3.27839] → [3.27839:27952]

    pub fn series_observations(series_id: &str) -> SeriesObservations { 
        serde_json::from_str(&response(

[3.27839]

[3.27952]

    pub fn series_observations(series_id: &str) -> Result<SeriesObservations, String> { 
        let response = response(

Replacement in src/lib.rs at line 235 [3.21264]

B:BD[3.28071] → [3.28071:28091]

        )).unwrap()

[3.28071]

[3.28091]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 240 [3.21264]

B:BD[2.4090] → [2.4090:4173]

    pub fn series_observations_json(series_id: &str) -> String {
        response(

[2.4090]

[2.4173]

    pub fn series_observations_json(series_id: &str) -> Result<String, String> {
        let response = response(

Replacement in src/lib.rs at line 246 [3.21264]

B:BD[2.4292] → [2.4292:4302]

[2.4292]

[2.4302]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 251 [3.21264]

B:BD[3.28217] → [3.28217:28320]

    pub fn series_release(series_id: &str) -> SeriesRelease { 
        serde_json::from_str(&response(

[3.28217]

[3.28320]

    pub fn series_release(series_id: &str) -> Result<SeriesRelease, String> { 
        let response = response(

Replacement in src/lib.rs at line 257 [3.21264]

B:BD[3.28434] → [3.28434:28454]

        )).unwrap()

[3.28434]

[3.28454]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 262 [3.21264]

B:BD[3.28579] → [3.28579:28682]

    pub fn series_search(search_text: &str) -> SeriesSearch { 
        serde_json::from_str(&response(

[3.28579]

[3.28682]

    pub fn series_search(search_text: &str) -> Result<SeriesSearch, String> { 
        let response = response(

Replacement in src/lib.rs at line 268 [3.21264]

B:BD[3.28799] → [3.28799:28819]

        )).unwrap()

[3.28799]

[3.28819]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 273 [3.21264]

B:BD[3.28937] → [3.28937:29056]

    pub fn series_search_tags(series_search_text: &str) -> SeriesSearchTags { 
        serde_json::from_str(&response(

[3.28937]

[3.29056]

    pub fn series_search_tags(series_search_text: &str) -> Result<SeriesSearchTags, String> { 
        let response = response(

Replacement in src/lib.rs at line 279 [3.21264]

B:BD[3.29192] → [3.29192:29212]

        )).unwrap()

[3.29192]

[3.29212]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 284 [3.21264]

B:BD[3.29346] → [3.29346:29497]

    pub fn series_search_related_tags(series_search_text: &str, tag_names: &str) -> SeriesSearchRelatedTags { 
        serde_json::from_str(&response(

[3.29346]

[3.29497]

    pub fn series_search_related_tags(series_search_text: &str, tag_names: &str) -> Result<SeriesSearchRelatedTags, String> { 
        let response = response(

Replacement in src/lib.rs at line 291 [3.21264]

B:BD[3.29694] → [3.29694:29714]

        )).unwrap()

[3.29694]

[3.29714]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 296 [3.21264]

B:BD[3.29833] → [3.29833:29930]

    pub fn series_tags(series_id: &str) -> SeriesTags { 
        serde_json::from_str(&response(

[3.29833]

[3.29930]

    /// ```
    /// match Fred::series_tags("JPNCPIALLMINMEI") {
    ///     Ok(series_tags) => println!("{}", series_tags),
    ///     Err(json_err) => println!("{}", json_err),
    /// }
    /// ```
    pub fn series_tags(series_id: &str) -> Result<SeriesTags, String> { 
        let response = response(

Replacement in src/lib.rs at line 308 [3.21264]

B:BD[3.30041] → [3.30041:30061]

        )).unwrap()

[3.30041]

[3.30061]

        );
        serde_json::from_str(&response).map_err(|_| response)

Insertion in src/lib.rs at line 311 [3.21264]
[3.30067]
[3.30067]

Replacement in src/lib.rs at line 313 [3.21264]

B:BD[3.30228] → [3.30228:30316]

    pub fn series_updates() -> SeriesUpdates { 
        serde_json::from_str(&response(

[3.30228]

[3.30316]

    pub fn series_updates() -> Result<SeriesUpdates, String> { 
        let response = response(

Replacement in src/lib.rs at line 317 [3.21264]

B:BD[3.30370] → [3.30370:30390]

        )).unwrap()

[3.30370]

[3.30390]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 322 [3.21264]

B:BD[3.30574] → [3.30574:30687]

    pub fn series_vintagedates(series_id: &str) -> SeriesVintageDates { 
        serde_json::from_str(&response(

[3.30574]

[3.30687]

    pub fn series_vintagedates(series_id: &str) -> Result<SeriesVintageDates, String> { 
        let response = response(

Replacement in src/lib.rs at line 328 [3.21264]

B:BD[3.30806] → [3.30806:30826]

        )).unwrap()

[3.30806]

[3.30826]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 333 [3.21264]

B:BD[3.30933] → [3.30933:31008]

    pub fn sources() -> Sources { 
        serde_json::from_str(&response(

[3.30933]

[3.31008]

    pub fn sources() -> Result<Sources, String> { 
        let response = response(

Replacement in src/lib.rs at line 337 [3.21264]

B:BD[3.31055] → [3.31055:31075]

        )).unwrap()

[3.31055]

[3.31075]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 342 [3.21264]

B:BD[3.31178] → [3.31178:31275]

    pub fn source(source_id: usize) -> ReleaseSources { 
        serde_json::from_str(&response(

[3.31178]

[3.31275]

    pub fn source(source_id: usize) -> Result<ReleaseSources, String> { 
        let response = response(

Replacement in src/lib.rs at line 348 [3.21264]

B:BD[3.31381] → [3.31381:31401]

        )).unwrap()

[3.31381]

[3.31401]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 352 [3.21264]

B:BD[3.31512] → [3.31512:31618]

    pub fn source_releases(source_id: usize) -> SourceReleases { 
        serde_json::from_str(&response(

[3.31512]

[3.31618]

    pub fn source_releases(source_id: usize) -> Result<SourceReleases, String> { 
        let response = response(

Replacement in src/lib.rs at line 358 [3.21264]

B:BD[3.31733] → [3.31733:31753]

        )).unwrap()

[3.31733]

[3.31753]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 363 [3.21264]

B:BD[3.31875] → [3.31875:31944]

    pub fn tags() -> Tags { 
        serde_json::from_str(&response(

[3.31875]

[3.31944]

    pub fn tags() -> Result<Tags, String> { 
        let response = response(

Replacement in src/lib.rs at line 367 [3.21264]

B:BD[3.31988] → [3.31988:32008]

        )).unwrap()

[3.31988]

[3.32008]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 372 [3.21264]

B:BD[3.32129] → [3.32129:32221]

    pub fn related_tags(tag_names: &str) -> Tags { 
        serde_json::from_str(&response(

[3.32129]

[3.32221]

    pub fn related_tags(tag_names: &str) -> Result<Tags, String> { 
        let response = response(

Replacement in src/lib.rs at line 378 [3.21264]

B:BD[3.32333] → [3.32333:32353]

        )).unwrap()

[3.32333]

[3.32353]

        );
        serde_json::from_str(&response).map_err(|_| response)

Replacement in src/lib.rs at line 383 [3.21264]

B:BD[3.32460] → [3.32460:32557]

    pub fn tags_series(tag_names: &str) -> TagsSeries { 
        serde_json::from_str(&response(

[3.32460]

[3.32557]

    /// ```
    /// match Fred::tags_series("korea") {
    ///     Ok(tags_series) => println!("{}", tags_series),
    ///     Err(json_err) => println!("{}", json_err),
    /// };
    /// ```
    pub fn tags_series(tag_names: &str) -> Result<TagsSeries, String> { 
        let response = response(

Replacement in src/lib.rs at line 395 [3.21264]

B:BD[3.32668] → [3.32668:32688]

        )).unwrap()

[3.32668]

[3.32688]

        );
        serde_json::from_str(&response).map_err(|_| response)