// generates unique and duplicate hashes for bnodes
/// <exception cref="JsonLD.Core.JsonLdError"></exception>
public virtual object HashBlankNodes(IEnumerable <string> unnamed_)
{
#if !PORTABLE
IList <string> unnamed = new List <string>(unnamed_);
IList <string> nextUnnamed = new List <string>();
IDictionary <string, IList <string> > duplicates = new Dictionary <string, IList <string
> >();
IDictionary <string, string> unique = new Dictionary <string, string>();
// NOTE: not using the same structure as javascript here to avoid
// possible stack overflows
// hash quads for each unnamed bnode
for (int hui = 0; ; hui++)
{
if (hui == unnamed.Count)
{
// done, name blank nodes
bool named = false;
IList <string> hashes = new List <string>(unique.Keys);
hashes.SortInPlace();
foreach (string hash in hashes)
{
string bnode = unique[hash];
namer.GetName(bnode);
named = true;
}
// continue to hash bnodes if a bnode was assigned a name
if (named)
{
// this resets the initial variables, so it seems like it
// has to go on the stack
// but since this is the end of the function either way, it
// might not have to
// hashBlankNodes(unnamed);
hui = -1;
unnamed = nextUnnamed;
nextUnnamed = new List <string>();
duplicates = new Dictionary <string, IList <string> >();
unique = new Dictionary <string, string>();
continue;
}
else
{
// name the duplicate hash bnods
// names duplicate hash bnodes
// enumerate duplicate hash groups in sorted order
hashes = new List <string>(duplicates.Keys);
hashes.SortInPlace();
// process each group
for (int pgi = 0; ; pgi++)
{
if (pgi == hashes.Count)
{
// done, create JSON-LD array
// return createArray();
IList <string> normalized = new List <string>();
// Note: At this point all bnodes in the set of RDF
// quads have been
// assigned canonical names, which have been stored
// in the 'namer' object.
// Here each quad is updated by assigning each of
// its bnodes its new name
// via the 'namer' object
// update bnode names in each quad and serialize
for (int cai = 0; cai < quads.Count; ++cai)
{
RDFDataset.Quad quad = quads[cai];
foreach (string attr in new string[] { "subject", "object", "name" })
{
if (quad.ContainsKey(attr))
{
IDictionary <string, object> qa = (IDictionary <string, object>)quad[attr];
if (qa != null && (string)qa["type"] == "blank node" && ((string)qa["value"]).IndexOf
("_:c14n") != 0)
{
qa["value"] = namer.GetName((string)qa["value"]);
}
}
}
normalized.Add(RDFDatasetUtils.ToNQuad(quad, quad.ContainsKey("name"
) && !(quad["name"] == null) ? (string)((IDictionary <string, object>)((IDictionary <string, object>)quad)["name"])["value"] : null));
}
// sort normalized output
normalized.SortInPlace();
// handle output format
if (options.format != null)
{
if ("application/nquads".Equals(options.format))
{
string rval = string.Empty;
foreach (string n in normalized)
{
rval += n;
}
return(rval);
}
else
{
throw new JsonLdError(JsonLdError.Error.UnknownFormat, options.format);
}
}
string rval_1 = string.Empty;
foreach (string n_1 in normalized)
{
rval_1 += n_1;
}
return(RDFDatasetUtils.ParseNQuads(rval_1));
}
// name each group member
IList <string> group = duplicates[hashes[pgi]];
IList <NormalizeUtils.HashResult> results = new List <NormalizeUtils.HashResult>();
for (int n_2 = 0; ; n_2++)
{
if (n_2 == group.Count)
{
// name bnodes in hash order
results.SortInPlace(new _IComparer_145());
foreach (NormalizeUtils.HashResult r in results)
{
// name all bnodes in path namer in
// key-entry order
// Note: key-order is preserved in
// javascript
foreach (string key in r.pathNamer.Existing().GetKeys())
{
namer.GetName(key);
}
}
// processGroup(i+1);
break;
}
else
{
// skip already-named bnodes
string bnode = group[n_2];
if (namer.IsNamed(bnode))
{
continue;
}
// hash bnode paths
UniqueNamer pathNamer = new UniqueNamer("_:b");
pathNamer.GetName(bnode);
NormalizeUtils.HashResult result = HashPaths(bnode, bnodes, namer, pathNamer);
results.Add(result);
}
}
}
}
}
// hash unnamed bnode
string bnode_1 = unnamed[hui];
string hash_1 = HashQuads(bnode_1, bnodes, namer);
// store hash as unique or a duplicate
if (duplicates.ContainsKey(hash_1))
{
duplicates[hash_1].Add(bnode_1);
nextUnnamed.Add(bnode_1);
}
else
{
if (unique.ContainsKey(hash_1))
{
IList <string> tmp = new List <string>();
tmp.Add(unique[hash_1]);
tmp.Add(bnode_1);
duplicates[hash_1] = tmp;
nextUnnamed.Add(unique[hash_1]);
nextUnnamed.Add(bnode_1);
JsonLD.Collections.Remove(unique, hash_1);
}
else
{
unique[hash_1] = bnode_1;
}
}
}
#else
throw new PlatformNotSupportedException();
#endif
}
/*
* STATUS : working on it
*/
private string hashFirstDegreeQuads(string id)
{
IDictionary <string, IList <Object> > info = this.blankNodeInfo[id];
if (info.ContainsKey("hash"))
{
return(info["hash"].ToString());
}
// 1) Initialize nquads to an empty list. It will be used to store quads
// in N-Quads format.
IList <string> nquads = new List <string>();
// 2) Get the list of quads quads associated with the reference blank
// node identifier in the blank node to quads map.
IList <Object> quads = info["quads"];
// 3) For each quad quad in quads:
foreach (var quad in quads)
{
// 3.1) Serialize the quad in N-Quads format with the following
// special rule:
// 3.1.1) If any component in quad is an blank node, then serialize
// it using a special identifier as follows:
// copy = {}
IDictionary <string, IDictionary <string, string> > copy = new Dictionary <string, IDictionary <string, string> >();
/* 3.1.2) If the blank node's existing blank node identifier
* matches the reference blank node identifier then use the
* blank node identifier _:a, otherwise, use the blank node
* identifier _:z.
* STATUS: working
*/
RDFDataset.Quad quadMap = (RDFDataset.Quad)quad;
foreach (var key in quadMap)
{
IDictionary <string, string> component = new Dictionary <string, string>();
component.Add(key.Key, key.Value.ToString());
if (key.Equals("predicate"))
{
copy.Add(key.Key, component);
continue;
}
copy.Add(key.Key, modifyFirstDegreeComponent(component, id));
}
RDFDataset.Quad copyQuad = new RDFDataset.Quad(copy, copy.ContainsKey("name") && copy["name"] != null
? (copy["name"])["value"] : null);
nquads.Add(RDFDatasetUtils.ToNQuad(copyQuad, copyQuad.ContainsKey("name") && copyQuad["name"] != null
? (string)((IDictionary <string, object>)copyQuad["name"])["value"] : null));
// 4) Sort nquads in lexicographical order.
}
Collections.SortInPlace(nquads);
// 5) Return the hash that results from passing the sorted, joined
// nquads through the hash algorithm.
return(NormalizeUtils.sha256HashnQuads(nquads));
}