pub fn latest_version(&self) -> Option<DateTime<Utc>> {

        self.versions.iter().map(|v| &v.date).max().copied()

    }

    pub fn number_of_quads(&self) -> usize {

        sophia::api::prelude::Dataset::quads(&self.data).count()

    }

    pub fn subjects(&self) -> BTreeSet<&IriRef<MownStr>> {

        use dataset::Dataset;

        let subjects: BTreeSet<_> = self

            .data

            .subjects()

            .filter_map(|t| match t {

                Ok(SimpleTerm::Iri(iri)) => Some(iri),

            })

            .collect();

        subjects

    }

    pub fn pos(&self, subject: &str) -> Vec<PredicateObject> {

        use dataset::Dataset;

        let subject = IriRef::new(subject.to_string()).unwrap();

        let pos: Vec<_> = self

            .data

            .quads_matching([subject], Any, Any, Any)

            .filter_map(|t| t.ok())

            .map(|t| (t.1[1], t.1[2]))

            .filter_map(|(p, o)| match p {

                SimpleTerm::Iri(p) => Some(PredicateObject {

                    predicate: p,

                    object_iri: match o {

                        SimpleTerm::Iri(o) => Some(o),

                        _ => None,

                    object_literal: match o {

                        SimpleTerm::LiteralDatatype(value, _) => Some(value),

                        _ => None,

            })

            .collect();

        pos

    }

pub(crate) fn load_datasets<P: AsRef<Path>>(dir: P) -> Result<Vec<Dataset>, Box<dyn Error>> {

    let paths = std::fs::read_dir(dir)?;

    let mut datasets = Vec::new();

    for path in paths.filter_map(|p| p.ok()) {

        if !path.file_type().map(|ft| ft.is_dir()).unwrap_or_default() {

        }

        datasets.push(Dataset {

            id: path.file_name().to_string_lossy().to_string(),

            versions: load_dataset_versions(&path.path())?,

    Ok(datasets)

}

fn load_dataset_versions(dir: &Path) -> Result<Vec<DatasetVersion>, Box<dyn Error>> {

    let mut versions = Vec::new();

    for path in std::fs::read_dir(dir)?.filter_map(|p| p.ok()) {

        if let Ok(index_path) = IndexPath::try_from(path.path()) {

            versions.push(DatasetVersion {

                date: index_path.date(),

                data: load_dataset_version(&index_path)?,

    versions.sort_unstable_by(|a, b| b.date.cmp(&a.date));

    Ok(versions)

}

pub(crate) fn parse_graph(rdf: &str, base: Option<Iri<String>>) -> Result<LightGraph, MyError> {

    let parser = TurtleParser { base: base.clone() };

    let source = parser.parse_str(rdf);

    if let Ok(graph) = LightGraph::from_triple_source(source) {

        return Ok(graph);

}

fn load_dataset_version(dir: &IndexPath) -> Result<FastDataset, Box<dyn Error>> {

    let mut dataset = FastDataset::new();

    for path in dir.file_paths()? {

        let rdf = std::fs::read_to_string(path)?;

        let urn = blob_to_uri(rdf.as_bytes());

        let base_ref = IriRef::new(urn.clone())?;

        let base: Iri<String> = Iri::new(urn)?;

        let graph = parse_graph(&rdf, Some(base))?;

        for t in graph.triples() {

            let t = t?;

            dataset.insert(t.s(), t.p(), t.o(), Some(base_ref.clone()))?;

    Ok(dataset)

}

    Lazy::new(|| Regex::new(r"@prefix\s([a-zA-Z0-9]+):\s+<(.+)>\s\.").unwrap());

pub(crate) fn load_prefixes<P: AsRef<Path>>(dir: P) -> Result<Vec<PrefixMapPair>, Box<dyn Error>> {

    let mut prefixes: HashMap<String, String> = HashMap::new();

    let mut extra_namespace_count = 1;

    let mut paths_dataset: Vec<_> = std::fs::read_dir(dir)?

        .filter_map(|p| p.ok())

        .filter(|p| p.file_type().map(|ft| ft.is_dir()).unwrap_or_default())

        .collect();

    paths_dataset.sort_by_key(|p| p.path());

    for path_dataset in paths_dataset {

        let mut paths_version: Vec<_> = std::fs::read_dir(&path_dataset.path())?

            .filter_map(|p| p.ok())

            .collect();

        paths_version.sort_by_key(|p| p.path());

        for path in &paths_version {

            let path = IndexPath::try_from(path.path())?;

            for path in path.file_paths()? {

                let rdf = std::fs::read_to_string(path)?;

                for (_, [prefix, url]) in PREFIX_RE.captures_iter(&rdf).map(|c| c.extract()) {

                    match prefixes.insert(prefix.to_string(), url.to_string()) {

                        None => (),

                        Some(old_url) => {

                            // If the prefix was previously assigned to a different URL,

                            // assign the previous URL to a new namespace

                            if url != old_url {

                            }

    Ok(prefixes

        .into_iter()

        .map(|(prefix, url)| {

            (

                Prefix::new_unchecked(prefix.into()),

                Iri::new_unchecked(url.into()),

            )

        })

        .collect())

}

pub(crate) fn find_first_label_for_subject<'a>(pos: &'a Vec<PredicateObject<'a>>) -> Option<&str> {

    find_predicate_object_literals_for_subject(pos, LABEL_RDFS_IRI)

        .first()

        .copied()

}

pub(crate) fn find_first_comment_for_subject<'a>(

    pos: &'a Vec<PredicateObject<'a>>,

) -> Option<&str> {

    find_predicate_object_literals_for_subject(pos, COMMENT_RDFS_IRI)

        .first()

        .copied()

}

pub(crate) fn find_predicate_object_literals_for_subject<'a>(

    pos: &'a Vec<PredicateObject<'a>>,

    target: &'a str,

) -> Vec<&'a str> {

    find_predicate_objects_for_subject(pos, target)

        .into_iter()

        .filter(|po| po.object_literal.is_some())

        .map(|po| po.object_literal.unwrap_or_default())

        .collect()

}

pub(crate) fn find_predicate_objects_for_subject<'a>(

    pos: &'a Vec<PredicateObject<'a>>,

    target: &'a str,

) -> Vec<&'a PredicateObject<'a>> {

    pos.into_iter()

        .filter(|po| po.predicate.as_str() == target)

        .collect()

}