public string CalculateHash(HashSet <Triple> triples)
        {
            var finalDigest = new byte[_hashCalculator.HashSize / 8];

            _triplesWithBlankNodeAsSubject = new Dictionary <string, List <Triple> >();
            _triplesWithBlankNodeAsObject  = new Dictionary <string, List <Triple> >();
            PopulateBlankNodeLists(triples);
            foreach (var t in triples)
            {
                var subject = t.Subject;
                var object_ = t.Object;
                if (subject.IsBlankNode() || t.Object.IsBlankNode())
                {
                    if (t.Subject.IsBlankNode())
                    {
                        subject = NormalizeBlankNode(_triplesWithBlankNodeAsObject, t.Subject.AsBlankNode(), "Magic_S");
                    }
                    if (t.Object.IsBlankNode())
                    {
                        object_ = NormalizeBlankNode(_triplesWithBlankNodeAsSubject, t.Object.AsBlankNode(), "Magic_O");
                    }
                    var nTriple = _nTriplesFormatHandler.SerializeTriple(new Triple(subject, t.Predicate, object_));
                    finalDigest = ByteArrayUtils.AddHashes(finalDigest, _hashCalculator.CalculateHashAsBytes(nTriple));
                }
                else
                {
                    var nTriple = _nTriplesFormatHandler.SerializeTriple(t);
                    finalDigest = ByteArrayUtils.AddHashes(finalDigest, _hashCalculator.CalculateHashAsBytes(nTriple));
                }
            }
            return(finalDigest.ToHexString().ToLower());
        }
 private BlankNode NormalizeBlankNode(Dictionary <string, List <Triple> > tripleList, BlankNode bNode, string emptyListName)
 {
     if (tripleList.ContainsKey(bNode.ValueAsString()))
     {
         var hashSum = new byte[_hashCalculator.HashSize / 8];
         foreach (var ot in tripleList[bNode.ValueAsString()])
         {
             hashSum = ByteArrayUtils.AddHashes(hashSum, SimpleHash(ot));
         }
         return(new BlankNode(hashSum.ToHexString()));
     }
     else
     {
         return(new BlankNode(emptyListName));
     }
 }
        public string CalculateHash(HashSet <Triple> triples)
        {
            _logger.LogDebug("Calculating hash for {0} triples.", triples.Count);

            var finalDigest = new byte[_hashCalculator.HashSize / 8];

            foreach (Triple triple in triples)
            {
                string serializedTriple = _nTriplesFormatHandler.SerializeTriple(triple);
                byte[] hash             = _hashCalculator.CalculateHashAsBytes(serializedTriple);

                _logger.LogTrace("T: {0} || H: {1}", serializedTriple, hash.ToHexString());
                finalDigest = ByteArrayUtils.AddHashes(finalDigest, hash);
            }

            return(finalDigest.ToHexString().ToLower());
        }