Transform RDFHashedQuadruple in a value type

Author: Marco De Salvo

RDFSharp/Model/RDFGraph.cs

@@ -290,7 +290,7 @@ public List<RDFTriple> SelectTriples(RDFResource s=null, RDFResource p=null, RDF
             _     => [.. Index.Hashes.Values]
         };
 
-        //Decompress hashed triples
+        //Decompress hashes
         return hashes!.ConvertAll(ht => new RDFTriple(ht, Index));
     }
 

RDFSharp/Store/Engines/RDFMemoryStore.cs

@@ -48,11 +48,11 @@ public IEnumerator<RDFQuadruple> QuadruplesEnumerator
     {
         get
         {
-            foreach (RDFHashedQuadruple hashedQuadruple in Index.Hashes.Values)
+            foreach ((_, long cid, long sid, long pid, long oid, byte tfv) in Index.Hashes.Values)
             {
-                yield return hashedQuadruple.TripleFlavor == 1 //SPO
-                    ? new RDFQuadruple(Index.Contexts[hashedQuadruple.ContextID], Index.Resources[hashedQuadruple.SubjectID], Index.Resources[hashedQuadruple.PredicateID], Index.Resources[hashedQuadruple.ObjectID])
-                    : new RDFQuadruple(Index.Contexts[hashedQuadruple.ContextID], Index.Resources[hashedQuadruple.SubjectID], Index.Resources[hashedQuadruple.PredicateID], Index.Literals[hashedQuadruple.ObjectID]);
+                yield return tfv == 1 //SPO
+                    ? new RDFQuadruple(Index.Contexts[cid], Index.Resources[sid], Index.Resources[pid], Index.Resources[oid])
+                    : new RDFQuadruple(Index.Contexts[cid], Index.Resources[sid], Index.Resources[pid], Index.Literals[oid]);
             }
         }
     }
@@ -236,7 +236,7 @@ public override List<RDFQuadruple> SelectQuadruples(RDFContext c=null, RDFResour
         if (p != null) queryFilters.Append('P');
         if (o != null) queryFilters.Append('O');
         if (l != null) queryFilters.Append('L');
-        List<RDFHashedQuadruple> hashedQuadruples = queryFilters.ToString() switch
+        List<(long qid, long cid, long sid, long pid, long oid, byte tfv)> hashes = queryFilters.ToString() switch
         {
             "C"    => [.. Index.LookupIndexByContext(c).Select(q => Index.Hashes[q])],
             "S"    => [.. Index.LookupIndexBySubject(s).Select(q => Index.Hashes[q])],
@@ -264,8 +264,8 @@ public override List<RDFQuadruple> SelectQuadruples(RDFContext c=null, RDFResour
             _      => [.. Index.Hashes.Values]
         };
 
-        //Decompress hashed quadruples
-        return hashedQuadruples!.ConvertAll(hq => new RDFQuadruple(hq, Index));
+        //Decompress hashes
+        return hashes!.ConvertAll(hq => new RDFQuadruple(hq, Index));
     }
     #endregion
 

RDFSharp/Store/RDFQuadruple.cs

@@ -130,24 +130,24 @@ private RDFQuadruple(RDFContext context, RDFResource subj, RDFResource pred)
     }
 
     /// <summary>
-    /// Builds a quadruple from the given hashed quadruple
+    /// Builds a quadruple from the given hashes
     /// </summary>
-    internal RDFQuadruple(RDFHashedQuadruple hashedQuadruple, RDFStoreIndex index)
+    internal RDFQuadruple((long qid, long cid, long sid, long pid, long oid, byte tfv) hashes, RDFStoreIndex index)
     {
-        Context = index.Contexts[hashedQuadruple.ContextID];
-        Subject = index.Resources[hashedQuadruple.SubjectID];
-        Predicate = index.Resources[hashedQuadruple.PredicateID];
-        if (hashedQuadruple.TripleFlavor == 1) //SPO
+        Context = index.Contexts[hashes.cid];
+        Subject = index.Resources[hashes.sid];
+        Predicate = index.Resources[hashes.pid];
+        if (hashes.tfv == 1) //SPO
         {
             TripleFlavor = RDFModelEnums.RDFTripleFlavors.SPO;
-            Object = index.Resources[hashedQuadruple.ObjectID];
+            Object = index.Resources[hashes.oid];
         }
         else
         {
             TripleFlavor = RDFModelEnums.RDFTripleFlavors.SPL;
-            Object = index.Literals[hashedQuadruple.ObjectID];
+            Object = index.Literals[hashes.oid];
         }
-        LazyQuadrupleID = new Lazy<long>(() => hashedQuadruple.QuadrupleID);
+        LazyQuadrupleID = new Lazy<long>(() => hashes.qid);
         LazyReificationSubject = new Lazy<RDFResource>(() => new RDFResource($"bnode:{QuadrupleID}"));
     }
     #endregion
@@ -267,77 +267,4 @@ public RDFMemoryStore ReifyQuadrupleTerm(List<(RDFResource annPredicate, RDFPatt
     public Task<RDFMemoryStore> ReifyQuadrupleTermAsync(List<(RDFResource annPredicate, RDFPatternMember annObject)> quadrupleAnnotations = null)
         => Task.Run(() => ReifyQuadrupleTerm(quadrupleAnnotations));
     #endregion
-}
-
-/// <summary>
-/// RDFHashedQuadruple represents the internal hashed representation of a quadruple
-/// </summary>
-internal sealed class RDFHashedQuadruple : IEquatable<RDFHashedQuadruple>
-{
-    #region Properties
-    /// <summary>
-    /// Identifier of the quadruple
-    /// </summary>
-    internal readonly long QuadrupleID;
-
-    /// <summary>
-    /// Identifier of the member acting as context of the quadruple
-    /// </summary>
-    internal readonly long ContextID;
-
-    /// <summary>
-    /// Identifier of the member acting as subject of the quadruple
-    /// </summary>
-    internal readonly long SubjectID;
-
-    /// <summary>
-    /// Identifier of the member acting as predicate of the quadruple
-    /// </summary>
-    internal readonly long PredicateID;
-
-    /// <summary>
-    /// Identifier of the member acting as object of the quadruple
-    /// </summary>
-    internal readonly long ObjectID;
-
-    /// <summary>
-    /// Flavor of the quadruple (1=SPO, 2=SPL)
-    /// </summary>
-    internal readonly byte TripleFlavor;
-    #endregion
-
-    #region Ctor
-    /// <summary>
-    /// Builds an hashed quadruple from the given quadruple
-    /// </summary>
-    internal RDFHashedQuadruple(RDFQuadruple quadruple)
-    {
-        TripleFlavor = (byte)quadruple.TripleFlavor;
-        QuadrupleID = quadruple.QuadrupleID;
-        ContextID = quadruple.Context.PatternMemberID;
-        SubjectID = quadruple.Subject.PatternMemberID;
-        PredicateID = quadruple.Predicate.PatternMemberID;
-        ObjectID = quadruple.Object.PatternMemberID;
-    }
-    #endregion
-
-    #region Interfaces
-    /// <summary>
-    /// Performs the equality comparison between two hashed quadruples
-    /// </summary>
-    public bool Equals(RDFHashedQuadruple other)
-        => other != null && QuadrupleID == other.QuadrupleID;
-
-    /// <summary>
-    /// Performs the equality comparison between two hashed quadruples
-    /// </summary>
-    public override bool Equals(object other)
-        => other is RDFHashedQuadruple hq && QuadrupleID == hq.QuadrupleID;
-
-    /// <summary>
-    /// Calculates the hashcode of this hashed quadruple
-    /// </summary>
-    public override int GetHashCode()
-        => QuadrupleID.GetHashCode();
-    #endregion
 }

RDFSharp/Store/RDFStoreIndex.cs

@@ -29,7 +29,7 @@ internal sealed class RDFStoreIndex : IDisposable
     /// <summary>
     /// Hashed representation of the quadruples
     /// </summary>
-    internal Dictionary<long, RDFHashedQuadruple> Hashes { get; set; }
+    internal Dictionary<long, (long qid, long cid, long sid, long pid, long oid, byte tfv)> Hashes { get; set; }
 
     /// <summary>
     /// Register of the contexts
@@ -152,10 +152,14 @@ private void Dispose(bool disposing)
     /// </summary>
     internal RDFStoreIndex Add(RDFQuadruple quadruple)
     {
-        //Quadruple (Hash)
+        #region Guards
         if (Hashes.ContainsKey(quadruple.QuadrupleID))
             return this;
-        Hashes.Add(quadruple.QuadrupleID, new RDFHashedQuadruple(quadruple));
+        #endregion
+
+        //Quadruple (Hash)
+        Hashes.Add(quadruple.QuadrupleID, (quadruple.QuadrupleID, quadruple.Context.PatternMemberID,
+            quadruple.Subject.PatternMemberID, quadruple.Predicate.PatternMemberID, quadruple.Object.PatternMemberID, (byte)quadruple.TripleFlavor));
 
         //Context (Register)
         Contexts.TryAdd(quadruple.Context.PatternMemberID, (RDFContext)quadruple.Context);