Keywords

Src/Data/Myc.Data.Keyword.pas

@@ -10,7 +10,7 @@ uses
 
 type
     // The runtime representation of an interned keyword
-    IKeyword = interface(IInterface)
+    IKeyword = interface
         function GetIdx: Integer;
         function GetName: string;
         property Idx: Integer read GetIdx;
@@ -42,26 +42,52 @@ type
         class function Intern(const AName: string): IKeyword; static;
     end;
 
-    TKeywordMapping<T> = record
-        type
-            TField = record
-                Key: IKeyword;
-                Value: T;
-            public
-                constructor Create(const AKey: IKeyword; const AValue: T);
-            end;
-    private
-        FMap: TArray<Integer>;
-        FFields: TArray<TField>;
-        FFirst, FLast: Integer;
-    public
-        constructor Create(const AFields: TArray<TField>);
+    // Defines a mapping from Keywords to a generic value T
+    IKeywordMapping<T> = interface
+        {$region 'private'}
+        function GetFields: TArray<TPair<IKeyword, T>>;
+        {$endregion}
+        // Finds the 0-based index for a given keyword. Returns -1 if not found.
         function IndexOf(const Key: IKeyword): Integer;
-        property Fields: TArray<TField> read FFields;
+        // Gets all fields in the mapping.
+        property Fields: TArray<TPair<IKeyword, T>> read GetFields;
+    end;
+
+    // Factory for creating IKeywordMapping instances
+    TKeywordMappingRegistry<T> = record
+    strict private
+        // Implementation class for IKeywordMapping
+        type
+            TKeywordMapping = class(TInterfacedObject, IKeywordMapping<T>)
+            private
+                FMap: TArray<Integer>;
+                FFields: TArray<TPair<IKeyword, T>>;
+                FFirst, FLast: Integer;
+                function GetFields: TArray<TPair<IKeyword, T>>;
+            public
+                // Expects AFields to be in the desired (canonical) order
+                constructor Create(const AFields: TArray<TPair<IKeyword, T>>);
+                function IndexOf(const Key: IKeyword): Integer;
+            end;
+    strict private
+        // Cache implementation
+        class var
+            FLock: TSpinLock;
+        class var
+            FRegistry: TDictionary<TArray<Integer>, IKeywordMapping<T>>;
+        class constructor Create;
+        class destructor Destroy;
+
+    public
+        // Creates or gets the cached keyword mapping.
+        class function Intern(const AFields: TArray<TPair<IKeyword, T>>): IKeywordMapping<T>; static;
     end;
 
 implementation
 
+uses
+    System.Generics.Defaults; // For TComparer<Integer>
+
 { TKeywordRegistry.TKeyword }
 
 constructor TKeywordRegistry.TKeyword.Create(const AName: string; AIdx: Integer);
@@ -108,21 +134,25 @@ begin
     end;
 end;
 
-{ TKeywordMapping }
+{ TKeywordMappingRegistry<T>.TKeywordMapping<T> }
 
-constructor TKeywordMapping<T>.Create(const AFields: TArray<TField>);
+constructor TKeywordMappingRegistry<T>.TKeywordMapping.Create(const AFields: TArray<TPair<IKeyword, T>>);
+var
+    i, idx: Integer;
 begin
+    inherited Create;
     FFields := AFields;
     FFirst := 0;
     FLast := -1;
     if Length(FFields) = 0 then
         exit;
 
+    // Find min/max Idx for the map. Fields are *not* assumed to be sorted.
     FFirst := FFields[0].Key.Idx;
     FLast := FFirst;
-    for var i := 1 to High(FFields) do
+    for i := 1 to High(FFields) do
     begin
-        var idx := FFields[i].Key.Idx;
+        idx := FFields[i].Key.Idx;
         if FFirst > idx then
             FFirst := idx;
         if FLast < idx then
@@ -130,25 +160,77 @@ begin
     end;
 
     SetLength(FMap, FLast - FFirst + 1);
-    for var i := 0 to High(FMap) do
+    for i := 0 to High(FMap) do
         FMap[i] := -1;
-    for var i := 0 to High(FFields) do
-        FMap[FFirst + FFields[i].Key.Idx] := i;
+
+    // Populate map based on the *original field order*
+    for i := 0 to High(FFields) do
+        FMap[FFields[i].Key.Idx - FFirst] := i;
 end;
 
-function TKeywordMapping<T>.IndexOf(const Key: IKeyword): Integer;
+function TKeywordMappingRegistry<T>.TKeywordMapping.GetFields: TArray<TPair<IKeyword, T>>;
 begin
-    var idx := Key.Idx - FFirst;
+    Result := FFields;
+end;
+
+function TKeywordMappingRegistry<T>.TKeywordMapping.IndexOf(const Key: IKeyword): Integer;
+var
+    idx: Integer;
+begin
+    idx := Key.Idx - FFirst;
     if (idx < 0) or (Idx > High(FMap)) then
         exit(-1);
 
     Result := FMap[idx];
 end;
 
-constructor TKeywordMapping<T>.TField.Create(const AKey: IKeyword; const AValue: T);
+{ TKeywordMappingRegistry<T> }
+
+class constructor TKeywordMappingRegistry<T>.Create;
 begin
-    Key := AKey;
-    Value := AValue;
+    FLock := TSpinLock.Create(false);
+    FRegistry := TDictionary<TArray<Integer>, IKeywordMapping<T>>.Create;
+end;
+
+class destructor TKeywordMappingRegistry<T>.Destroy;
+begin
+    FRegistry.Free;
+end;
+
+class function TKeywordMappingRegistry<T>.Intern(const AFields: TArray<TPair<IKeyword, T>>): IKeywordMapping<T>;
+var
+    key: TArray<Integer>;
+begin
+    SetLength(key, Length(AFields));
+    for var i := 0 to High(key) do
+        key[i] := AFields[i].Key.Idx;
+
+    // 2. Lock
+    FLock.Enter;
+    try
+        // 3. Check cache
+        if FRegistry.TryGetValue(key, Result) then
+            exit; // Found it, exit
+    finally
+        FLock.Exit;
+    end;
+
+    // 4. Not in cache. Create (O(N+M)) - OUTSIDE lock
+    var newMapping := TKeywordMapping.Create(AFields) as IKeywordMapping<T>;
+
+    // 5. Lock again to add
+    FLock.Enter;
+    try
+        // 6. Check again (double-check)
+        if FRegistry.TryGetValue(key, Result) then
+            exit; // Another thread won the race
+
+        // 7. Add our new mapping.
+        Result := newMapping;
+        FRegistry.Add(key, Result);
+    finally
+        FLock.Exit;
+    end;
 end;
 
 end.