#[derive(Debug)]

    // DataSpec::from_file("source_data.keytree").write(&root_dir);
    // let series_obs = Fred::series_observations("NORURTOTADSMEI").unwrap();
    // let () = series_obs;
    // Get series_spec using series_id    

    let data_spec = DataSpec::from_file("source_data.keytree").unwrap();
    let ts_spec = TSSpec::from_file("ts_spec.keytree");

    let series_spec = SeriesSpec::from_series_id("NORURTOTADSMEI", "source_data.keytree").unwrap();

    let ts_json = ts_spec.into_json(&data_spec, &root_dir);

//! let source = DataSpec::from_file("source_data.keytree");
//! source.write("/full/path/to/data");

//! DataSpec::from_file("source_data.keytree")
//!     .unwrap()
//!     .write("/full/path/to/data");

//! source.resume_write(Series::new("GBRURNAA"), "/full/path/to/data")

//! DataSpec::from_file("source_data.keytree")
//!     .unwrap()
//!     .resume_write("NORURTOTADSMEI", "/full/path/to/data");

//! let data_spec = DataSpec::from_file("source_data.keytree").into_indexed();

//! let data_spec = DataSpec::from_file("source_data.keytree")
//!     .unwrap();

//! let data_spec = DataSpec::from_file("checked_data.keytree").into_indexed();

//! let data_spec = DataSpec::from_file("source_data.keytree").unwrap();

//! let ts_json = ts_spec.into_json(data_spec, "/full/path/to/data");

//! let ts_json = ts_spec.into_json(&data_spec, "/full/path/to/data");

// Its better for DataSpec to be a Vec, but we need to index into the Vec, so
// we wrap it with an index.

// `DataSpec` is set up in what seems like an overly complex way in order to maintain
// the order is which data is `DataSelector` orders the series. We want to maintain an 
// ordering by (DataType, Country). But sometimes we also need to search by SeriesId so also need a
// reverse lookup.

    /// Test if a key `(DataType, Country)` has a `SeriesId`.
    pub fn key_has_series_id(&self, key: (DataType, Country), series_id: &SeriesId) -> Result<bool, Error> {

        let series_specs = match self.map.get(&key) {
            Some(series_specs) => series_specs,
            None => { return Err(key_not_in_dataspec(&key.0.to_string(), &key.1.to_string())) },
        };
        Ok(series_specs.iter().any(|series| &series.series_id == series_id))
    }

    pub fn resume_write(&self, series_id: SeriesId, root_path: &str) {
        for (series_id, _) in self.reverse.iter().skip_while(|(id, _)| id != &&series_id) {
            let series_spec = self.get_series_spec(series_id);
            series_spec.write_data(root_path);
            series_spec.write_meta(root_path); 

    pub fn resume_write(&self, series_id: &str, root_path: &str) {
        let sid = SeriesId::new(series_id);
        for ((data_type, country), series_specs) in self
            .map
            .iter()
            .skip_while(|((data_type, country), series_specs)| {
                 match self.key_has_series_id((*data_type, *country), &sid) {
                    Err(err) => {
                        println!("{}", err);
                        panic!();
                    },
                    Ok(is_true) => !is_true,
                }
            })
        {
            for series_spec in series_specs {
                series_spec.write_data(root_path);
                series_spec.write_meta(root_path); 
            }