/// <summary> /// Appends all the annotations present in the annotMan to the annotations currently loaded in this annotation Manager. /// </summary> /// <param name="annotMan"></param> public void appendAnnotations(AnnotationManager annotMan) { if (annotMan == null) { return; } foreach (var ann in annotMan.GetAnnotationSubjects()) { appendAnnotations(ann.Key, ann.Value, annotMan.GetAnnotations(ann.Key)); } }
/// <summary> /// Compare the annotations loaded in this annotation manager to the annotations loaded in the annotNew. /// </summary> /// <param name="annotNew">Manager to which you want to compare the current annotations</param> /// <returns>An annotations manager diff structure which contains the difference between the two annotation managers</returns> public AnnotationManagerDiff Compare(AnnotationManager annotNew) { AnnotationManagerDiff diffMan = new AnnotationManagerDiff(); // get the difference between the keys of the two managers. var keysInRef = new HashSet <string>(this.GetAnnotationSubjects().Select(x => x.Key).ToList()); var keysInNew = new HashSet <string>(annotNew.GetAnnotationSubjects().Select(x => x.Key).ToList()); // all keys present in annotReference and not in annotNew should be added in removedAnnotations var keysInRefNotInNew = keysInRef.Except(keysInNew); foreach (var annKey in keysInRefNotInNew) { diffMan.RemovedAnnotations.Add(new Tuple <string, string>(annKey, this.subjectType[annKey]), this.GetAnnotations(annKey)); } // all keys present in annotNew and not in annotReference should be added in addedAnnotations var keysInNewNotInRef = keysInNew.Except(keysInRef); foreach (var annKey in keysInNewNotInRef) { diffMan.AddedAnnotations.Add(new Tuple <string, string>(annKey, annotNew.subjectType[annKey]), annotNew.GetAnnotations(annKey)); } // if they have both the same key --> check if each annotation is the same var keysInBoth = keysInRef.Intersect(keysInNew); foreach (var annKey in keysInBoth) { var annInRef = new HashSet <W3CAnnotation>(this.GetAnnotations(annKey)); var annInNew = new HashSet <W3CAnnotation>(annotNew.GetAnnotations(annKey)); var annInRefNotInNew = annInRef.Except(annInNew, new W3CAnnotation(true)).ToList(); if (annInRefNotInNew.Count > 0) { diffMan.RemovedAnnotations.Add(new Tuple <string, string>(annKey, this.subjectType[annKey]), annInRefNotInNew); } var annInNewNotInRef = annInNew.Except(annInRef, new W3CAnnotation(true)).ToList(); if (annInNewNotInRef.Count > 0) { diffMan.AddedAnnotations.Add(new Tuple <string, string>(annKey, annotNew.subjectType[annKey]), annInNewNotInRef); } } return(diffMan); }
/// <summary> /// Loads the W3CAnnotations found in the line. By default the annotationManager is using DL internally if the text you are giving is not in DL, use the inputTranslator argument /// If the subject of an annotation is a Statement, then the Statement is expected to be written like: "statement where quote is ''" /// </summary> /// <param name="line"></param> /// <param name="append">Decides if the text should be appended to the annotationManager or not</param> /// <param name="inputTranslator">Used internally to translate for CNL to DL. Use it if the input is not in DL. From ENCNL, the translator is: x => Ontorion.CNL.EN.ENNameingConvention.ToDL(new Ontorion.CNL.EN.EnName() { id = x }, Ontorion.CNL.EN.endict.WordKind.NormalForm).id </param> /// <returns></returns> public void loadW3CAnnotationsFromText(string line, bool append = false, Func <string, string> inputTranslator = null) { if (String.IsNullOrEmpty(line) || String.IsNullOrWhiteSpace(line) || !line.Contains(":")) { return; } var localAnnotationManager = new AnnotationManager(); var dp = 0; if (line.Contains(ANNOTATION_START)) { dp = line.IndexOf(':') + 1; } bool newAnnotationSubjects = false; var refs = w3cAnnotRg.Matches(line.Substring(dp).Trim()); foreach (Match match in refs) { string annotated = match.Groups["annotated"].Value; string type = match.Groups["type"].Value; string val = match.Groups["value"].Value; string kind = match.Groups["annotatedKind"].Value; // if one of these values are null this means that something went wrong during parsing... someone changed it manually? // in this case we skip this line. if (String.IsNullOrWhiteSpace(annotated) || String.IsNullOrWhiteSpace(type) || String.IsNullOrWhiteSpace(val) || String.IsNullOrWhiteSpace(kind)) { continue; } var res = ParseSubjectKind(kind); annotated = annotated.Trim(); type = type.Trim(); if (inputTranslator != null) { if (res != ARS.EntityKind.Statement && !CNLTools.isSurelyDLEntity(annotated, res)) { annotated = inputTranslator(annotated); } if (!CNLTools.isSurelyDLEntity(type, ARS.EntityKind.Role)) { type = inputTranslator(type); } } // if the subject is a statement, then the annotation manager keeps it internally as: statement with quotes inside (no quotes around!) if (res == ARS.EntityKind.Statement && annotated.StartsWith("\"") && annotated.EndsWith("\"")) { annotated = annotated.Substring(1, annotated.Length - 2).Replace("\''", "\""); } else if (res == ARS.EntityKind.Statement && !annotated.StartsWith("\"") && !annotated.EndsWith("\"")) //statement should be quoted! If not, continue. { continue; } if (!localAnnotationManager.ContainsAnnotationSubject(annotated.Trim())) { newAnnotationSubjects = true; } localAnnotationManager.appendAnnotations(annotated.Trim(), kind.Trim(), new List <W3CAnnotation>() { new W3CAnnotation(true) { Type = type.Trim(), Value = val.Trim(), Language = match.Groups["language"].Value } }); } if (newAnnotationSubjects && NewAnnotationSubject != null && FireNewSubjectEvent) { NewAnnotationSubject(this); } if (!append) { this.clearAnnotations(); } appendAnnotations(localAnnotationManager); if (!append) { this.AssumeNotModifiedNow(); } }