/// <summary>Parses the authority for the pre-parsed given Url.</summary> /// <remarks>Parses the authority for the pre-parsed given Url.</remarks> /// <param name="parsed">the pre-parsed Url.</param> private static void ParseAuthority(Url parsed) { // parse authority for unparsed relative network-path reference if (parsed.href.IndexOf(":") == -1 && parsed.href.IndexOf("//") == 0 && string.Empty .Equals(parsed.host)) { // must parse authority from pathname parsed.pathname = JavaCompat.Substring(parsed.pathname, 2); var idx = parsed.pathname.IndexOf("/"); if (idx == -1) { parsed.authority = parsed.pathname; parsed.pathname = string.Empty; } else { parsed.authority = JavaCompat.Substring(parsed.pathname, 0, idx); parsed.pathname = JavaCompat.Substring(parsed.pathname, idx); } } else { // construct authority parsed.authority = parsed.host; if (!string.Empty.Equals(parsed.auth)) { parsed.authority = parsed.auth + "@" + parsed.authority; } } }
/// <exception cref="JsonLD.Core.JsonLdError"></exception> private void AdvanceLineNumber() { var match = Regex.NextEoln.Matcher(line); if (match.Find()) { var split = match.Group(0).Split(string.Empty + Regex.Eoln); lineNumber += split.Length - 1; linePosition += split[split.Length - 1].Length; line = JavaCompat.Substring(line, match.Group(0).Length); } }
public void update(int foo) { /* * byte[] b = JavaCompat.GetBytesBig(foo); * Console.Error.Write("HMAC: "); * for (int i = 0; i < b.Length; i++) * { * Console.Error.Write(b[i].ToString("X2")); * } * Console.Error.WriteLine(" (" + foo.ToString() + ")");*/ cs.Write(JavaCompat.GetBytesBig(foo)); }
private string UnquoteString(string value) { if (value.StartsWith("\"\"\"") || value.StartsWith("'''")) { return(JavaCompat.Substring(value, 3, value.Length - 3)); } if (value.StartsWith("\"") || value.StartsWith("'")) { return(JavaCompat.Substring(value, 1, value.Length - 1)); } return(value); }
/// <summary> /// checks the URI for a prefix, and if one is found, set used prefixes to /// true /// </summary> /// <param name="predicate"></param> /// <returns></returns> private string GetURI(string uri) { // check for bnode if (uri.StartsWith("_:")) { return(uri); } foreach (var prefix in availableNamespaces.Keys) { if (uri.StartsWith(prefix)) { usedNamespaces.Add(prefix); // return the prefixed URI return(availableNamespaces[prefix] + ":" + JavaCompat.Substring(uri, prefix.Length)); } } // return the full URI return("<" + uri + ">"); }
/// <summary>A helper class to sha1 hash all the strings in a collection</summary> /// <param name="nquads"></param> /// <returns></returns> private static string Sha1hash(ICollection <string> nquads) { #if !PORTABLE try { // create SHA-1 digest var md = MessageDigest.GetInstance("SHA-1"); foreach (var nquad in nquads) { md.Update(JavaCompat.GetBytesForString(nquad, "UTF-8")); } return(EncodeHex(md.Digest())); } catch { throw; } #else throw new PlatformNotSupportedException(); #endif }
/// <exception cref="JsonLD.Core.JsonLdError"></exception> public virtual void AdvanceLinePosition(int len) { if (len > 0) { linePosition += len; line = JavaCompat.Substring(line, len); } while (!string.Empty.Equals(line)) { // clear any whitespace var match = Regex.CommentOrWs.Matcher(line); if (match.Find() && match.Group(0).Length > 0) { var eoln = Regex.Eoln.Matcher(match.Group(0)); var end = 0; while (eoln.Find()) { lineNumber += 1; end = eoln.End(); } linePosition = match.Group(0).Length - end; line = JavaCompat.Substring(line, match.Group(0).Length); } else { break; } } if (string.Empty.Equals(line) && !EndIsOK()) { throw new JsonLdError(JsonLdError.Error.ParseError, "Error while parsing Turtle; unexpected end of input. {line: " + lineNumber + ", position:" + linePosition + "}"); } }
public static string RemoveBase(JToken baseobj, string iri) { if (baseobj.IsNull()) { return(iri); } Url @base; if (baseobj.Type == JTokenType.String) { @base = Parse((string)baseobj); } else { throw new Exception("Arrgggghhh!"); } // establish base root var root = string.Empty; if (!string.Empty.Equals(@base.href)) { root += @base.protocol + "//" + @base.authority; } else { // support network-path reference with empty base if (iri.IndexOf("//") != 0) { root += "//"; } } // IRI not relative to base if (iri.IndexOf(root) != 0) { return(iri); } // remove root from IRI and parse remainder var rel = Parse(JavaCompat.Substring(iri, root.Length)); // remove path segments that match IList <string> baseSegments = new List <string>(@base .normalizedPath.Split("/").ToList()); baseSegments = baseSegments.Where(seg => seg != "").ToList(); if (@base.normalizedPath.EndsWith("/")) { baseSegments.Add(string.Empty); } IList <string> iriSegments = new List <string>(rel.normalizedPath .Split("/").ToList()); iriSegments = iriSegments.Where(seg => seg != "").ToList(); if (rel.normalizedPath.EndsWith("/")) { iriSegments.Add(string.Empty); } while (baseSegments.Count > 0 && iriSegments.Count > 0) { if (!baseSegments[0].Equals(iriSegments[0])) { break; } if (baseSegments.Count > 0) { baseSegments.RemoveAt(0); } if (iriSegments.Count > 0) { iriSegments.RemoveAt(0); } } // use '../' for each non-matching base segment var rval = string.Empty; if (baseSegments.Count > 0) { // don't count the last segment if it isn't a path (doesn't end in // '/') // don't count empty first segment, it means base began with '/' if ([email protected]("/") || string.Empty.Equals(baseSegments[0])) { baseSegments.RemoveAt(baseSegments.Count - 1); } for (var i = 0; i < baseSegments.Count; ++i) { rval += "../"; } } // prepend remaining segments if (iriSegments.Count > 0) { rval += iriSegments[0]; } for (var i_1 = 1; i_1 < iriSegments.Count; i_1++) { rval += "/" + iriSegments[i_1]; } // add query and hash if (!string.Empty.Equals(rel.query)) { rval += "?" + rel.query; } if (!string.Empty.Equals(rel.hash)) { rval += rel.hash; } if (string.Empty.Equals(rval)) { rval = "./"; } return(rval); }
public void update(int foo) { cs.Write(JavaCompat.GetBytesBig(foo)); }
/// <summary> /// Produces a hash for the paths of adjacent bnodes for a bnode, /// incorporating all information about its subgraph of bnodes. /// </summary> /// <remarks> /// Produces a hash for the paths of adjacent bnodes for a bnode, /// incorporating all information about its subgraph of bnodes. This method /// will recursively pick adjacent bnode permutations that produce the /// lexicographically-least 'path' serializations. /// </remarks> /// <param name="id">the ID of the bnode to hash paths for.</param> /// <param name="bnodes">the map of bnode quads.</param> /// <param name="namer">the canonical bnode namer.</param> /// <param name="pathNamer">the namer used to assign names to adjacent bnodes.</param> /// <param name="callback">(err, result) called once the operation completes.</param> private static HashResult HashPaths(string id, IDictionary <string, IDictionary <string, object> > bnodes, UniqueNamer namer, UniqueNamer pathNamer) { #if !PORTABLE MessageDigest md = null; try { // create SHA-1 digest md = MessageDigest.GetInstance("SHA-1"); var groups = new JObject(); IList <string> groupHashes; var quads = (IList <RdfDataset.Quad>)bnodes[id]["quads"]; for (var hpi = 0;; hpi++) { if (hpi == quads.Count) { // done , hash groups groupHashes = new List <string>(groups.GetKeys()); ((List <string>)groupHashes).Sort(StringComparer.CurrentCultureIgnoreCase); for (var hgi = 0;; hgi++) { if (hgi == groupHashes.Count) { var res = new HashResult(); res.hash = EncodeHex(md.Digest()); res.pathNamer = pathNamer; return(res); } // digest group hash var groupHash = groupHashes[hgi]; md.Update(JavaCompat.GetBytesForString(groupHash, "UTF-8")); // choose a path and namer from the permutations string chosenPath = null; UniqueNamer chosenNamer = null; var permutator = new Permutator((JArray)groups[groupHash]); while (true) { var contPermutation = false; var breakOut = false; var permutation = permutator.Next(); var pathNamerCopy = pathNamer.Clone(); // build adjacent path var path = string.Empty; var recurse = new JArray(); foreach (string bnode in permutation) { // use canonical name if available if (namer.IsNamed(bnode)) { path += namer.GetName(bnode); } else { // recurse if bnode isn't named in the path // yet if (!pathNamerCopy.IsNamed(bnode)) { recurse.Add(bnode); } path += pathNamerCopy.GetName(bnode); } // skip permutation if path is already >= chosen // path if (chosenPath != null && path.Length >= chosenPath.Length && string.CompareOrdinal(path, chosenPath) > 0) { // return nextPermutation(true); if (permutator.HasNext()) { contPermutation = true; } else { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } } // if we should do the next permutation if (contPermutation) { continue; } // if we should stop processing this group if (breakOut) { break; } // does the next recursion for (var nrn = 0;; nrn++) { if (nrn == recurse.Count) { // return nextPermutation(false); if (chosenPath == null || string.CompareOrdinal(path, chosenPath) < 0) { chosenPath = path; chosenNamer = pathNamerCopy; } if (!permutator.HasNext()) { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } // do recursion var bnode_1 = (string)recurse[nrn]; var result = HashPaths(bnode_1, bnodes, namer, pathNamerCopy); path += pathNamerCopy.GetName(bnode_1) + "<" + result.hash + ">"; pathNamerCopy = result.pathNamer; // skip permutation if path is already >= chosen // path if (chosenPath != null && path.Length >= chosenPath.Length && string.CompareOrdinal(path, chosenPath) > 0) { // return nextPermutation(true); if (!permutator.HasNext()) { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } } // do next recursion // if we should stop processing this group if (breakOut) { break; } } } } // get adjacent bnode var quad = (IDictionary <string, object>)quads[hpi]; var bnode_2 = GetAdjacentBlankNodeName((IDictionary <string, object>)quad["subject" ], id); string direction = null; if (bnode_2 != null) { // normal property direction = "p"; } else { bnode_2 = GetAdjacentBlankNodeName((IDictionary <string, object>)quad["object"], id ); if (bnode_2 != null) { direction = "r"; } } if (bnode_2 != null) { // get bnode name (try canonical, path, then hash) string name; if (namer.IsNamed(bnode_2)) { name = namer.GetName(bnode_2); } else { if (pathNamer.IsNamed(bnode_2)) { name = pathNamer.GetName(bnode_2); } else { name = HashQuads(bnode_2, bnodes, namer); } } // hash direction, property, end bnode name/hash using (var md1 = MessageDigest.GetInstance("SHA-1")) { // String toHash = direction + (String) ((Map<String, // Object>) quad.get("predicate")).get("value") + name; md1.Update(JavaCompat.GetBytesForString(direction, "UTF-8")); md1.Update(JavaCompat.GetBytesForString((string)((IDictionary <string, object>)quad["predicate"])["value"], "UTF-8")); md1.Update(JavaCompat.GetBytesForString(name, "UTF-8")); var groupHash = EncodeHex(md1.Digest()); if (groups.ContainsKey(groupHash)) { ((JArray)groups[groupHash]).Add(bnode_2); } else { var tmp = new JArray(); tmp.Add(bnode_2); groups[groupHash] = tmp; } } } } } catch { // TODO: i don't expect that SHA-1 is even NOT going to be // available? // look into this further throw; } finally { md?.Dispose(); } #else throw new PlatformNotSupportedException(); #endif }
/// <summary>Removes a base IRI from the given absolute IRI.</summary> /// <remarks>Removes a base IRI from the given absolute IRI.</remarks> /// <param name="base">the base IRI.</param> /// <param name="iri">the absolute IRI.</param> /// <returns>the relative IRI if relative to base, otherwise the absolute IRI.</returns> private static string RemoveBase(JToken baseobj, string iri) { Url @base; if (IsString(baseobj)) { @base = Url.Parse((string)baseobj); } else { @base = baseobj.Value <Url>(); } // establish base root var root = string.Empty; if (!string.Empty.Equals(@base.href)) { root += @base.protocol + "//" + @base.authority; } else { // support network-path reference with empty base if (iri.IndexOf("//") != 0) { root += "//"; } } // IRI not relative to base if (iri.IndexOf(root) != 0) { return(iri); } // remove root from IRI and parse remainder var rel = Url.Parse(JavaCompat.Substring(iri, root.Length)); // remove path segments that match var baseSegments = _split(@base.normalizedPath, "/"); var iriSegments = _split(rel.normalizedPath, "/"); while (baseSegments.Count > 0 && iriSegments.Count > 0) { if (!baseSegments[0].Equals(iriSegments[0])) { break; } if (baseSegments.Count > 0) { baseSegments.RemoveAt(0); } if (iriSegments.Count > 0) { iriSegments.RemoveAt(0); } } // use '../' for each non-matching base segment var rval = string.Empty; if (baseSegments.Count > 0) { // don't count the last segment if it isn't a path (doesn't end in // '/') // don't count empty first segment, it means base began with '/' if ([email protected]("/") || string.Empty.Equals(baseSegments[0])) { baseSegments.RemoveAt(baseSegments.Count - 1); } for (var i = 0; i < baseSegments.Count; ++i) { rval += "../"; } } // prepend remaining segments rval += _join(iriSegments, "/"); // add query and hash if (!string.Empty.Equals(rel.query)) { rval += "?" + rel.query; } if (!string.Empty.Equals(rel.hash)) { rval += rel.hash; } if (string.Empty.Equals(rval)) { rval = "./"; } return(rval); }
/// <summary>Prepends a base IRI to the given relative IRI.</summary> /// <remarks>Prepends a base IRI to the given relative IRI.</remarks> /// <param name="base">the base IRI.</param> /// <param name="iri">the relative IRI.</param> /// <returns> /// the absolute IRI. /// TODO: the Url class isn't as forgiving as the Node.js url parser, /// we may need to re-implement the parser here to support the /// flexibility required /// </returns> private static string PrependBase(JToken baseobj, string iri) { // already an absolute IRI if (iri.IndexOf(":") != -1) { return(iri); } // parse base if it is a string Url @base; if (IsString(baseobj)) { @base = Url.Parse((string)baseobj); } else { @base = baseobj.Value <Url>(); } var rel = Url.Parse(iri); // start hierarchical part var hierPart = @base.protocol; if (!string.Empty.Equals(rel.authority)) { hierPart += "//" + rel.authority; } else { if (!string.Empty.Equals(@base.href)) { hierPart += "//" + @base.authority; } } // per RFC3986 normalize string path; // IRI represents an absolute path if (rel.pathname.IndexOf("/") == 0) { path = rel.pathname; } else { path = @base.pathname; // append relative path to the end of the last directory from base if (!string.Empty.Equals(rel.pathname)) { path = JavaCompat.Substring(path, 0, path.LastIndexOf("/") + 1); if (path.Length > 0 && !path.EndsWith("/")) { path += "/"; } path += rel.pathname; } } // remove slashes anddots in path path = Url.RemoveDotSegments(path, !string.Empty.Equals(hierPart)); // add query and hash if (!string.Empty.Equals(rel.query)) { path += "?" + rel.query; } if (!string.Empty.Equals(rel.hash)) { path += rel.hash; } var rval = hierPart + path; if (string.Empty.Equals(rval)) { return("./"); } return(rval); }
public static string Unescape(string str) { var rval = str; if (str != null) { var m = UcharMatched.Matcher(str); while (m.Find()) { var uni = m.Group(0); if (m.Group(1) == null) { var hex = m.Group(2) != null?m.Group(2) : m.Group(3); var v = Convert.ToInt32(hex, 16); // hex = // hex.replaceAll("^(?:00)+", // ""); if (v > 0xFFFF) { // deal with UTF-32 // Integer v = Integer.parseInt(hex, 16); var vt = v - 0x10000; var vh = vt >> 10; var v1 = vt & 0x3FF; var w1 = 0xD800 + vh; var w2 = 0xDC00 + v1; var b = new StringBuilder(); b.AppendCodePoint(w1); b.AppendCodePoint(w2); uni = b.ToString(); } else { uni = char.ToString((char)v); } } else { var c = m.Group(1)[0]; switch (c) { case 'b': { uni = "\b"; break; } case 'n': { uni = "\n"; break; } case 't': { uni = "\t"; break; } case 'f': { uni = "\f"; break; } case 'r': { uni = "\r"; break; } case '\'': { uni = "'"; break; } case '\"': { uni = "\""; break; } case '\\': { uni = "\\"; break; } default: { // do nothing continue; } } } var pat = Pattern.Quote(m.Group(0)); var x = JavaCompat.ToHexString(uni[0]); rval = rval.Replace(pat, uni); } } return(rval); }