compactAllIris method

Implementation

IriCompactionResult compactAllIris(
  RdfGraph graph,
  Map<String, String> customPrefixes, {
  String? baseUri,
}) {
  final prefixCandidates = {
    ..._namespaceMappings.asMap(),
  };
  prefixCandidates
      .removeWhere((key, value) => customPrefixes.values.contains(value));
  prefixCandidates.addAll(customPrefixes);

  final usedPrefixes = <String, String>{};
  final compactIris = <(
    IriTerm iri,
    IriRole role,
  ),
      CompactIri>{};
  // Create an inverted index for quick lookup
  final iriToPrefixMap = {
    for (final e in prefixCandidates.entries) e.value: e.key
  };
  if (iriToPrefixMap.length != prefixCandidates.length) {
    throw ArgumentError(
      'Duplicate namespace URIs found in prefix candidates: $prefixCandidates',
    );
  }
  final List<(IriTerm iri, IriRole role)> iris = graph.triples
      .expand((triple) => <(IriTerm iri, IriRole role)>[
            if (triple.subject is IriTerm)
              (triple.subject as IriTerm, IriRole.subject),
            if (triple.predicate is IriTerm)
              (triple.predicate as IriTerm, IriRole.predicate),
            if (triple.object is IriTerm && triple.predicate == Rdf.type)
              (triple.object as IriTerm, IriRole.type),
            if (triple.object is IriTerm && triple.predicate != Rdf.type)
              (triple.object as IriTerm, IriRole.object),
            if (triple.object is LiteralTerm)
              ((triple.object as LiteralTerm).datatype, IriRole.datatype),
          ])
      .toList();

  for (final (iri, role) in iris) {
    final compacted = compactIri(
        iri, role, baseUri, iriToPrefixMap, prefixCandidates, customPrefixes);
    compactIris[(iri, role)] = compacted;
    if (compacted
        case PrefixedIri(
          prefix: var prefix,
          namespace: var namespace,
        )) {
      // Add the prefix to all relevant maps
      usedPrefixes[prefix] = namespace;
      final oldNamespace = prefixCandidates[prefix];
      final oldPrefix = iriToPrefixMap[namespace];
      if (oldNamespace != null && oldNamespace != namespace) {
        throw ArgumentError(
          'Namespace conflict for prefix "$prefix": '
          'already mapped to "$oldNamespace", cannot map to "$namespace".',
        );
      }
      if (oldPrefix != null && oldPrefix != prefix) {
        throw ArgumentError(
          'Prefix conflict for namespace "$namespace": '
          'already mapped to "$oldPrefix", cannot map to "$prefix".',
        );
      }
      // Update candidates with new prefix
      prefixCandidates[prefix] = namespace;
      iriToPrefixMap[namespace] = prefix; // Update inverse mapping
    }
  }

  return IriCompactionResult(
      prefixes: usedPrefixes, compactIris: compactIris);
}