currency_engineering/fred_api - Change 4CQS5CR3KBOZ2GIUQJ5AZQMZ44TLYZHIWEIYN3SHCUJE43E4TIGQC

Added observation iterator.

Created by efindlay on April 16, 2021

4CQS5CR3KBOZ2GIUQJ5AZQMZ44TLYZHIWEIYN3SHCUJE43E4TIGQC

Dependencies

In channels

main

Change contents

Insertion in src/response.rs at line 5 [3.2643]
[3.2754]
[3.2754]
```
use std::iter::Iterator;
```
Deletion in src/response.rs at line 45 [3.2643]
B:BD[2.564] → [2.564:566]

Insertion in src/response.rs at line 55 [3.2643]

[3.3644]

}
pub struct SeriesItemsIter<'a> {
    data: &'a SeriesItems,
    count: usize, 
}
impl<'a> Iterator for SeriesItemsIter<'a> {
    type Item = &'a SeriesItem;
    fn next(&mut self) -> Option<Self::Item> {
        if self.count == self.data.0.len() {
            None
        } else {
            self.count += 1;
            Some(&self.data.0[self.count - 1])
        }
    }
}
#[derive(Debug, Deserialize)]
pub struct SeriesItems(Vec<SeriesItem>);
impl SeriesItems {
    pub fn iter<'a>(&'a self) -> SeriesItemsIter {
        SeriesItemsIter {
            data: &self,
            count: 0,
        }
    }
    /// Include only series with series equal to title.
    pub fn equals_one_of(&self, titles: Vec<&str>) -> SeriesItems {
        let mut v = Vec::new();
        for series in self.iter() {
            if titles.iter().any(|title| *title == series.title) {
                v.push(series.clone());
            }
        }
        SeriesItems(v)
    }
    /// Exclude if includes phrase.
    pub fn exclude_phrases(&self, phrases: Vec<&str>) -> SeriesItems {
        let mut v = Vec::new();
        for series in self.iter() {
            if !phrases.iter().any(|title| series.title.contains(title)) {
                v.push(series.clone());
            }
        }
        SeriesItems(v)
    }
    /// Only include if includes phrase.
    pub fn only_include(&self, phrases: Vec<&str>) -> SeriesItems {
        let mut v = Vec::new();
        for series in &self.0 {
            if phrases.iter().any(|title| series.title.contains(title)) {
                v.push(series.clone());
            }
        }
        SeriesItems(v)
    }
    pub fn inner(&self) -> Vec<SeriesItem> {
        (*self.0).to_vec()
    }

Insertion in src/response.rs at line 125 [3.2643]

[3.3647]

impl fmt::Display for SeriesItems {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        for (i, series) in self.0.iter().enumerate() {
            s.push_str(&format!("Series {}\n", i));
            s.push_str(&series.to_string());
            s.push('\n');
        };
        write!(f, "{}", s)
    }
}

Replacement in src/response.rs at line 146 [3.2643]

B:BD[3.3984] → [3.3984:4037]

    pub seriess:                    Vec<SeriesItem>,

[3.3984]

[3.4037]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 152 [3.2643]

B:BD[2.704] → [2.704:765]

        for (i, series) in self.seriess.iter().enumerate() {

[2.704]

[2.765]

        for (i, series) in self.seriess.0.iter().enumerate() {

Replacement in src/response.rs at line 288 [3.2643]

B:BD[3.8545] → [3.8545:8598]

    pub seriess:                    Vec<SeriesItem>,

[3.8545]

[3.8598]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 390 [3.2643]

B:BD[3.11966] → [3.11966:12019]

    pub seriess:                    Vec<SeriesItem>,

[3.11966]

[3.12019]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 400 [3.2643]
B:BD[3.12243] → [3.12243:12279]
```
        for item in &self.seriess {
```
[3.12243]
[3.12279]
```
        for item in &self.seriess.0 {
```
Replacement in src/response.rs at line 407 [3.2643]
B:BD[3.12368] → [3.12368:12398]
```
#[derive(Debug, Deserialize)]
```
[3.12368]
[3.12398]
```
#[derive(Clone, Debug, Deserialize)]
```

Insertion in src/response.rs at line 454 [3.2643]

[3.13887]

#[derive(Debug, Deserialize)]
pub struct Observations(Vec<Observation>);
impl Observations {
    pub fn iter<'a>(&'a self) -> ObservationsIter {
        ObservationsIter {
            data: &self,
            count: 0,
        }
    }
}
impl fmt::Display for Observations {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        for obs in self.iter() {
            s.push_str(&obs.to_string());
            s.push('\n');
        }
        s.pop();
        write!(f, "{}", s)
    }
}
pub struct ObservationsIter<'a> {
    data: &'a Observations,
    count: usize, 
}
impl<'a> Iterator for ObservationsIter<'a> {
    type Item = &'a Observation;
    fn next(&mut self) -> Option<Self::Item> {
        if self.count == self.data.0.len() {
            None
        } else {
            self.count += 1;
            Some(&self.data.0[self.count - 1])
        }
    }
}

Replacement in src/response.rs at line 511 [3.2643]

B:BD[3.14601] → [3.14601:14655]

    pub observations:               Vec<Observation>,

[3.14601]

[3.14655]

    pub observations:               Observations,

Insertion in src/response.rs at line 521 [3.2643]

[3.15009]

}
impl fmt::Display for Observation {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}, {}", self.date, self.value)
    }

Replacement in src/response.rs at line 547 [3.2643]

B:BD[3.15792] → [3.15792:15845]

    pub seriess:                    Vec<SeriesItem>,

[3.15792]

[3.15845]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 613 [3.2643]

B:BD[3.17919] → [3.17919:17972]

    pub seriess:                    Vec<SeriesItem>,

[3.17919]

[3.17972]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 693 [3.2643]

B:BD[3.20827] → [3.20827:20880]

    pub seriess:                    Vec<SeriesItem>,

[3.20827]

[3.20880]

    pub seriess:                    SeriesItems,

Replacement in src/response.rs at line 699 [3.2643]
B:BD[2.1807] → [2.1807:1845]
```
        for series in &self.seriess {
```
[2.1807]
[2.1845]
```
        for series in &self.seriess.0 {
```

Replacement in src/response.rs at line 710 [3.2643]

B:BD[3.21021] → [3.21021:21077]

        for (i, s) in self.seriess.iter().enumerate() {

[3.21021]

[3.21077]

        for (i, s) in self.seriess.0.iter().enumerate() {

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

[3.27318]

    }
    /// Return the series request as JSON. 
    pub fn series_json(series_id: &str) -> String {
        response(
            "series",
            vec!(
                format!("series_id={}", series_id)
            ),
        )

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

[3.28098]

    /// Return the series_observations request as JSON. 
    pub fn series_observations_json(series_id: &str) -> String {
        response(
            "series/observations",
            vec!(
                format!("series_id={}", series_id)
            ),
        )
    }