public OntologyProperty GetProperty(String propertyName) { OntologyProperty retval = null; // find it if we can... foreach (OntologyProperty op in this.properties) { if (op.GetNameStr(false).ToLower().Equals(propertyName.ToLower())) { retval = op; break; } } return(retval); }
public OntologyProperty GetInheritedPropertyByKeyName(OntologyClass ontClass, String propName) { OntologyProperty retval = null; List <OntologyProperty> props = this.GetInheritedProperies(ontClass); foreach (OntologyProperty i in props) { if (i.GetNameStr(true).Equals(propName)) { retval = i; break; } } return(retval); }
public void AddJson(JsonObject encodedOInfo) { // check the version: long version = 0; if (encodedOInfo.ContainsKey("version")) { version = (long)encodedOInfo.GetNamedNumber("version"); } // check the version information now if (version > OntologyInfo.JSON_VERSION) { // fail gracelessly throw new Exception("Can't decode OntologyInfo JSON with newer version > " + OntologyInfo.JSON_VERSION + " : found " + version); } // get the connection, if it exists and we care. if (encodedOInfo.ContainsKey("sparqlConn")) { // set it up. JsonObject connObj = encodedOInfo.GetNamedObject("sparqlConn"); SparqlConnection connVal = new SparqlConnection(connObj.ToString()); this.modelConnnection = connVal; } // get the oInfo block if (!encodedOInfo.ContainsKey("ontologyInfo")) { // panic throw new Exception("encoded group does not include the ontologyInfo block and cannot be used."); } JsonObject oInfoBlock = encodedOInfo.GetNamedObject("ontologyInfo"); // unpack the prefixews Dictionary <String, String> prefixHash = new Dictionary <String, String>(); JsonArray prefixes = oInfoBlock.GetNamedArray("prefixes"); for (int i = 0; i < prefixes.Count; i++) { JsonObject currPrefix = prefixes.GetObjectAt((uint)i); prefixHash.Add(currPrefix.GetNamedString("prefixId"), currPrefix.GetNamedString("prefix")); } // unpack everything else. this is a little different than in the java because we do not have to use the table load // logic. as a result, this may be more straightforward. // unpack the classes: JsonArray classArr = oInfoBlock.GetNamedArray("classList"); for (int m = 0; m < classArr.Count; m++) { // get each class and add them... and related values... JsonObject currClass = classArr.GetObjectAt((uint)m); String fullUri = Utility.Utility.UnPrefixUri(currClass.GetNamedString("fullUri"), prefixHash); JsonArray subC = currClass.GetNamedArray("subClasses"); JsonArray superC = currClass.GetNamedArray("superClasses"); JsonArray comments = currClass.GetNamedArray("comments"); JsonArray labels = currClass.GetNamedArray("labels"); JsonArray direct = currClass.GetNamedArray("directConnections"); // find or create the class. OntologyClass curr = null; if (this.classHash.ContainsKey(fullUri)) { // get that one. curr = classHash[fullUri]; } else { // create a new one curr = new OntologyClass(fullUri); this.classHash.Add(fullUri, curr); } // create the List of parent names for (int pi = 0; pi < superC.Count; pi++) { // check and add the superclasses String pn = Utility.Utility.UnPrefixUri(superC.GetStringAt((uint)pi), prefixHash); // check that the parent exists. if not, make it. if (!this.classHash.ContainsKey(pn)) { OntologyClass parentClass = new OntologyClass(pn); classHash.Add(pn, parentClass); } // add the parent. curr.AddParentName(pn); } // get the comments. for (int com = 0; com < comments.Count; com++) { String c = comments.GetStringAt((uint)com); curr.AddAnnotationComment(c); } // get the labels. for (int lab = 0; lab < labels.Count; lab++) { String l = labels.GetStringAt((uint)lab); curr.AddAnnotationLabel(l); } // add the subclasses as well... List <OntologyClass> children = new List <OntologyClass>(); for (int h = 0; h < subC.Count; h++) { // check and add the subclasses String cn = Utility.Utility.UnPrefixUri(subC.GetStringAt((uint)h), prefixHash); OntologyClass child = null; // check that it exists. if not, make it. if (!this.classHash.ContainsKey(cn)) { OntologyClass childClass = new OntologyClass(cn); classHash.Add(cn, childClass); child = childClass; } else { child = this.classHash[cn]; } children.Add(child); } // if there were any entries, add this. if (children.Count > 0) { this.subclassHash.Add(fullUri, children); } // handle the connections. List <OntologyPath> paths = new List <OntologyPath>(); for (int b = 0; b < direct.Count; b++) { // all the one-hop connections. JsonObject jdir = direct.GetObjectAt((uint)b); String destinationClassUri = Utility.Utility.UnPrefixUri(jdir.GetNamedString("destinationClass"), prefixHash); String predicateUri = Utility.Utility.UnPrefixUri(jdir.GetNamedString("predicate"), prefixHash); String startClassUri = Utility.Utility.UnPrefixUri(jdir.GetNamedString("startClass"), prefixHash); OntologyPath op = new OntologyPath(startClassUri); op.AddTriple(startClassUri, predicateUri, destinationClassUri); // add to the list paths.Add(op); } if (paths.Count > 0) { // we have some paths. add it. this.connHash.Add(fullUri, paths); } // done with the classes. } // unpack the properties: JsonArray propertyArr = oInfoBlock.GetNamedArray("propertyList"); for (int j = 0; j < propertyArr.Count; j++) { // add each entry to the property list. JsonObject currPropJson = propertyArr.GetObjectAt((uint)j); String fullUri = Utility.Utility.UnPrefixUri(currPropJson.GetNamedString("fullUri"), prefixHash); JsonArray comments = currPropJson.GetNamedArray("comments"); JsonArray labels = currPropJson.GetNamedArray("labels"); JsonArray domain = currPropJson.GetNamedArray("domain"); JsonArray range = currPropJson.GetNamedArray("range"); // get the (currently) single range. String rangeUri = Utility.Utility.UnPrefixUri(range.GetStringAt(0), prefixHash); // create the property OntologyProperty oProp = new OntologyProperty(fullUri, rangeUri); for (int di = 0; di < domain.Count; di++) { // get the domain info and add it. String domainUri = Utility.Utility.UnPrefixUri(domain.GetStringAt((uint)di), prefixHash); // get the class in the domain. OntologyClass domClass = this.classHash[domainUri]; domClass.AddProperty(oProp); } // add the labels. for (int li = 0; li < labels.Count; li++) { String label = labels.GetStringAt((uint)li); oProp.AddAnnotationLabel(label); } // add the comments for (int ci = 0; ci < comments.Count; ci++) { String comment = comments.GetStringAt((uint)ci); oProp.AddAnnotationComment(comment); } this.propertyHash.Add(fullUri, oProp); } // add the enumerations JsonArray enumerationArr = oInfoBlock.GetNamedArray("enumerations"); for (int ei = 0; ei < enumerationArr.Count; ei++) { JsonObject enumVal = enumerationArr.GetObjectAt((uint)ei); String fullUri = Utility.Utility.UnPrefixUri(enumVal.GetNamedString("fullUri"), prefixHash); JsonArray children = enumVal.GetNamedArray("enumeration"); List <String> childUris = new List <String>(); for (int ci = 0; ci < children.Count; ci++) { childUris.Add(Utility.Utility.UnPrefixUri(children.GetStringAt((uint)ci), prefixHash)); } // add the list if (childUris.Count > 0) { this.enumerationHash.Add(fullUri, childUris); } } }
// -------------------------------------------------------------------------------------- serialize and deserialize json representation. /* the To and From json methods are adapted from the java code in oInfo. the operative mechanism is different as this code does not * have to be compatible with the loading from sparql methods. instead this goes further, taking advantage of the one-hop information * and the sub-class/super-class info buried in the exported json. */ public JsonObject ToJson() { // based on th advanced client json in the java version. // return the advanced client Json format... JsonObject retval = new JsonObject(); // create all the prefix information... Dictionary <String, String> prefixes = new Dictionary <String, String>(); // create the enumeration information JsonArray enumerations = new JsonArray(); foreach (String key in this.enumerationHash.Keys) { // find each and add them as needed. String uri = Utility.Utility.PrefixUri(key, prefixes); JsonObject currEnumeration = new JsonObject(); JsonArray values = new JsonArray(); // get all the values. foreach (String k in this.enumerationHash[key]) // get eh enumerations we care about. { String kUri = Utility.Utility.PrefixUri(k, prefixes); values.Add(JsonValue.CreateStringValue(kUri)); } currEnumeration.Add("fullUri", JsonValue.CreateStringValue(uri)); currEnumeration.Add("enumeration", values); enumerations.Add(currEnumeration); } // create the propertyList information: JsonArray propertyList = new JsonArray(); foreach (String key in this.propertyHash.Keys) { String uri = Utility.Utility.PrefixUri(key, prefixes); JsonObject currProperty = new JsonObject(); JsonArray domain = new JsonArray(); JsonArray range = new JsonArray(); JsonArray labels = new JsonArray(); JsonArray comments = new JsonArray(); OntologyProperty currProp = this.propertyHash[key]; // get the domain: foreach (String oClassKey in this.classHash.Keys) { // get the classes which are in the domain OntologyClass oClass = this.classHash[oClassKey]; if (oClass.GetProperty(key) != null) { // we found one. as a result, this will be prefixed and added. OntologyProperty currPropInstance = oClass.GetProperty(key); String classId = Utility.Utility.PrefixUri(oClassKey, prefixes); domain.Add(JsonValue.CreateStringValue(classId)); } } // get the range. right now, SemTK core only supports a single value for a range, so it may seems silly/wasteful/stupid // to support these as an array but we intend on changing this limitation one day, so better to be prepared. String rangeId = Utility.Utility.PrefixUri(currProp.GetRange().GetFullName(), prefixes); range.Add(JsonValue.CreateStringValue(rangeId)); // add the labels. foreach (String label in currProp.GetAnnotationLabels()) { labels.Add(JsonValue.CreateStringValue(label)); } // add the comments foreach (String comment in currProp.GetAnnotationComments()) { comments.Add(JsonValue.CreateStringValue(comment)); } // add all the subcomponents of the current property currProperty.Add("fullUri", JsonValue.CreateStringValue(uri)); currProperty.Add("domain", domain); currProperty.Add("range", range); currProperty.Add("labels", labels); currProperty.Add("comments", comments); // add to the outgoing list propertyList.Add(currProperty); } // create the classList information. JsonArray classList = new JsonArray(); foreach (String key in this.classHash.Keys) { String uri = Utility.Utility.PrefixUri(key, prefixes); JsonObject currClass = new JsonObject(); OntologyClass oClass = this.classHash[key]; JsonArray labels = new JsonArray(); JsonArray comments = new JsonArray(); JsonArray superClasses = new JsonArray(); JsonArray subClasses = new JsonArray(); JsonArray directConnections = new JsonArray(); // labels foreach (String label in oClass.GetAnnotationLabels()) { labels.Add(JsonValue.CreateStringValue(label)); } // comments foreach (String comment in oClass.GetAnnotationComments()) { comments.Add(JsonValue.CreateStringValue(comment)); } // superclasses foreach (String parent in oClass.GetParentNameStrings(false)) { String prefixedParent = Utility.Utility.PrefixUri(parent, prefixes); superClasses.Add(JsonValue.CreateStringValue(prefixedParent)); } // subclasses if (this.subclassHash.ContainsKey(key)) { // only do this if any exist. List <OntologyClass> myChildren = this.subclassHash[key]; foreach (OntologyClass currChild in myChildren) { String childId = Utility.Utility.PrefixUri(currChild.GetNameString(false), prefixes); subClasses.Add(JsonValue.CreateStringValue(childId)); } } // direct connections -- generate the connections. foreach (OntologyPath currPath in this.GetConnList(key)) { JsonObject pathJsonObject = new JsonObject(); pathJsonObject.Add("startClass", JsonValue.CreateStringValue(Utility.Utility.PrefixUri(currPath.GetTriple(0).GetSubject(), prefixes))); pathJsonObject.Add("predicate", JsonValue.CreateStringValue(Utility.Utility.PrefixUri(currPath.GetTriple(0).GetPredicate(), prefixes))); pathJsonObject.Add("destinationClass", JsonValue.CreateStringValue(Utility.Utility.PrefixUri(currPath.GetTriple(0).GetObject(), prefixes))); directConnections.Add(pathJsonObject); } // full uri information currClass.Add("fullUri", JsonValue.CreateStringValue(uri)); // add everything else to the outgoing structure. currClass.Add("superClasses", superClasses); currClass.Add("subClasses", subClasses); currClass.Add("comments", comments); currClass.Add("labels", labels); currClass.Add("directConnections", directConnections); classList.Add(currClass); } // create the prefix array JsonArray prefixList = new JsonArray(); foreach (String k in prefixes.Keys) { JsonObject pref = new JsonObject(); pref.Add("prefixId", JsonValue.CreateStringValue(prefixes[k])); pref.Add("prefix", JsonValue.CreateStringValue(k)); } String creationTime = DateTime.Now.ToString("yyyyMMdd_HHmmss"); retval.Add("version", JsonValue.CreateNumberValue(OntologyInfo.JSON_VERSION)); retval.Add("generated", JsonValue.CreateStringValue(creationTime)); if (this.modelConnnection != null) { retval.Add("sparqlConn", this.modelConnnection.ToJson()); } JsonObject jsonOInfo = new JsonObject(); jsonOInfo.Add("prefixes", prefixList); jsonOInfo.Add("enumerations", enumerations); jsonOInfo.Add("propertyList", propertyList); jsonOInfo.Add("classList", classList); // add the oInfo serialization to the outgoing object. retval.Add("ontologyInfo", jsonOInfo); // ship it out. return(retval); }
public void AddProperty(OntologyProperty op) { this.properties.Add(op); }