CodeSnip Old Code (SVN)

--- a/branches/experimental/Src/SyntaxHighlighting/Languages/CS.SourceCode.Languages.Persist.pas
+++ b/branches/experimental/Src/SyntaxHighlighting/Languages/CS.SourceCode.Languages.Persist.pas
@@ -172,8 +172,8 @@
     SB.AppendLine;
     for Language in Langs do
     begin
-      SB.Append(Format('%s %s', [KwdLanguage, Language.ID]));
-      if Language.ID <> Language.FriendlyName then
+      SB.Append(Format('%s %s', [KwdLanguage, Language.ID.ToString]));
+      if Language.ID.ToString <> Language.FriendlyName then
         SB.Append(' ' + Language.FriendlyName);
       SB.AppendLine;
       SB.AppendLine(Format('  %s %d', [KwdTabSize, Language.EditorTabSize]));
@@ -316,20 +316,22 @@
   const LangList: TLangList; const IsBuiltIn: Boolean);
 var
   LangIDs: IStringList;
-  LangID: string;
+  LangIDStr: string;
+  LangID: TSourceCodeLanguageID;
   LangFriendlyName: string;
   Language: TSourceCodeLanguage;
 begin
   LangIDs := TIStringList.Create;
   while StrSameText(CurrentStatement, KwdLanguage) do
   begin
-    StrSplit(CurrentParameter, ' ', LangID, LangFriendlyName);
-    LangID := StrTrim(LangID);
-    ValidateIdent(KwdLanguage, LangID, LangIDs);
-    LangIDs.Add(LangID);
+    StrSplit(CurrentParameter, ' ', LangIDStr, LangFriendlyName);
+    LangIDStr := StrTrim(LangIDStr);
+    ValidateIdent(KwdLanguage, LangIDStr, LangIDs);
+    LangID := TSourceCodeLanguageID.Create(LangIDStr);
+    LangIDs.Add(LangIDStr);
     LangFriendlyName := StrTrim(LangFriendlyName);
     if LangFriendlyName = EmptyStr then
-      LangFriendlyName := LangID;
+      LangFriendlyName := LangIDStr;
     NextLine;
     Language := TSourceCodeLanguage.Create(LangID, LangFriendlyName, IsBuiltIn);
     ParseLanguage(Language);

--- a/branches/experimental/Src/SyntaxHighlighting/Languages/CS.SourceCode.Languages.pas
+++ b/branches/experimental/Src/SyntaxHighlighting/Languages/CS.SourceCode.Languages.pas
@@ -18,10 +18,41 @@
 interface
 
 uses
+  Generics.Defaults,
   Generics.Collections,
   CS.SourceCode.Hiliter.Brushes;
 
 type
+  TSourceCodeLanguageID = record
+  strict private
+    const
+      DefaultLanguageID = 'Text';
+    var
+      fID: string;
+  public
+    type
+      TEqualityComparer = class(TEqualityComparer<TSourceCodeLanguageID>)
+      public
+        function Equals(const Left, Right: TSourceCodeLanguageID): Boolean;
+          override;
+        function GetHashCode(const Value: TSourceCodeLanguageID): Integer;
+          override;
+      end;
+  public
+    constructor Create(const AID: string);
+    class operator Equal(const Left, Right: TSourceCodeLanguageID): Boolean;
+      inline;
+    class operator NotEqual(const Left, Right: TSourceCodeLanguageID): Boolean;
+      inline;
+    class function Compare(const Left, Right: TSourceCodeLanguageID): Integer;
+      static; inline;
+    class function CreateDefault: TSourceCodeLanguageID; static; inline;
+    function CompareTo(const Other: TSourceCodeLanguageID): Integer; inline;
+    function ToString: string; inline;
+    function Hash: Integer; inline;
+    function IsDefault: Boolean;
+  end;
+
   TSourceCodeLanguage = record
   strict private
     const
@@ -29,18 +60,18 @@
       DefaultBrushID = TSyntaxHiliterBrushes.NullBrushID;
   strict private
     var
-      fID: string;
+      fID: TSourceCodeLanguageID;
       fFriendlyName: string;
       fEditorTabSize: Byte;
       fHiliterBrushID: string;
       fBuiltIn: Boolean;
   public
-    constructor Create(const AID, AFriendlyName: string;
-      const AIsBuiltIn: Boolean);
+    constructor Create(const AID: TSourceCodeLanguageID;
+      const AFriendlyName: string; const AIsBuiltIn: Boolean);
     ///  <summary>Updates the record's properties to those of Lang except that
     ///  the BuiltIn property remains unchanged.</summary>
     procedure Update(const Lang: TSourceCodeLanguage);
-    property ID: string read fID;
+    property ID: TSourceCodeLanguageID read fID;
     property FriendlyName: string read fFriendlyName write fFriendlyName;
     property EditorTabSize: Byte read fEditorTabSize write fEditorTabSize;
     property HiliterBrushID: string read fHiliterBrushID write fHiliterBrushID;
@@ -51,19 +82,20 @@
   TSourceCodeLanguages = class(TObject)
   strict private
     var
-      fLanguages: TDictionary<string,TSourceCodeLanguage>;
-    function GetLanguage(const LangID: string): TSourceCodeLanguage;
+      fLanguages: TDictionary<TSourceCodeLanguageID,TSourceCodeLanguage>;
+    function GetLanguage(const LangID: TSourceCodeLanguageID):
+      TSourceCodeLanguage;
   public
     constructor Create;
     destructor Destroy; override;
     procedure Add(const Language: TSourceCodeLanguage);
     procedure Update(const Language: TSourceCodeLanguage);
     procedure Clear;
-    procedure Delete(const LangID: string);
-    function HasLanguage(const LangID: string): Boolean;
-    function SupportedLanguageIDs: TArray<string>;
+    procedure Delete(const LangID: TSourceCodeLanguageID);
+    function HasLanguage(const LangID: TSourceCodeLanguageID): Boolean;
+    function SupportedLanguageIDs: TArray<TSourceCodeLanguageID>;
     function GetEnumerator: TEnumerator<TSourceCodeLanguage>;
-    property Languages[const ID: string]: TSourceCodeLanguage
+    property Languages[const ID: TSourceCodeLanguageID]: TSourceCodeLanguage
       read GetLanguage; default;
   end;
 
@@ -71,12 +103,82 @@
 implementation
 
 uses
-  UComparers;
+  SysUtils,
+  CS.Utils.Hashes,
+  UStrUtils;
+
+{ TSourceCodeLanguageID }
+
+class function TSourceCodeLanguageID.Compare(const Left,
+  Right: TSourceCodeLanguageID): Integer;
+begin
+  Result := StrCompareText(Left.fID, Right.fID);
+end;
+
+function TSourceCodeLanguageID.CompareTo(
+  const Other: TSourceCodeLanguageID): Integer;
+begin
+  Result := Compare(Self, Other);
+end;
+
+constructor TSourceCodeLanguageID.Create(const AID: string);
+begin
+  if AID <> EmptyStr then
+    fID := AID
+  else
+    fID := DefaultLanguageID;
+end;
+
+class function TSourceCodeLanguageID.CreateDefault: TSourceCodeLanguageID;
+begin
+  Result := TSourceCodeLanguageID.Create(DefaultLanguageID);
+end;
+
+class operator TSourceCodeLanguageID.Equal(const Left,
+  Right: TSourceCodeLanguageID): Boolean;
+begin
+  Result := Compare(Left, Right) = 0;
+end;
+
+function TSourceCodeLanguageID.Hash: Integer;
+begin
+  Result := PaulLarsonHash(fID);
+end;
+
+function TSourceCodeLanguageID.IsDefault: Boolean;
+begin
+  Result := StrSameText(fID, DefaultLanguageID);
+end;
+
+class operator TSourceCodeLanguageID.NotEqual(const Left,
+  Right: TSourceCodeLanguageID): Boolean;
+begin
+  Result := Compare(Left, Right) <> 0;
+end;
+
+function TSourceCodeLanguageID.ToString: string;
+begin
+  Result := fID;
+end;
+
+{ TSourceCodeLanguageID.TEqualityComparer }
+
+function TSourceCodeLanguageID.TEqualityComparer.Equals(const Left,
+  Right: TSourceCodeLanguageID): Boolean;
+begin
+  Result := Left = Right;
+end;
+
+function TSourceCodeLanguageID.TEqualityComparer.GetHashCode(
+  const Value: TSourceCodeLanguageID): Integer;
+begin
+  Result := Value.Hash;
+end;
 
 { TSourceCodeLanguage }
 
-constructor TSourceCodeLanguage.Create(const AID, AFriendlyName: string;
-  const AIsBuiltIn: Boolean);
+constructor TSourceCodeLanguage.Create(const AID: TSourceCodeLanguageID;
+  const AFriendlyName: string; const AIsBuiltIn: Boolean);
 begin
   fID := AID;
   fFriendlyName := AFriendlyName;
@@ -110,12 +212,12 @@
 constructor TSourceCodeLanguages.Create;
 begin
   inherited Create;
-  fLanguages := TDictionary<string,TSourceCodeLanguage>.Create(
-    TTextEqualityComparer.Create
+  fLanguages := TDictionary<TSourceCodeLanguageID,TSourceCodeLanguage>.Create(
+    TSourceCodeLanguageID.TEqualityComparer.Create
   );
 end;
 
-procedure TSourceCodeLanguages.Delete(const LangID: string);
+procedure TSourceCodeLanguages.Delete(const LangID: TSourceCodeLanguageID);
 begin
   fLanguages.Remove(LangID);
 end;
@@ -131,18 +233,20 @@
   Result := fLanguages.Values.GetEnumerator;
 end;
 
-function TSourceCodeLanguages.GetLanguage(const LangID: string):
+function TSourceCodeLanguages.GetLanguage(const LangID: TSourceCodeLanguageID):
   TSourceCodeLanguage;
 begin
   Result := fLanguages[LangID];
 end;
 
-function TSourceCodeLanguages.HasLanguage(const LangID: string): Boolean;
+function TSourceCodeLanguages.HasLanguage(const LangID: TSourceCodeLanguageID):
+  Boolean;
 begin
   Result := fLanguages.ContainsKey(LangID);
 end;
 
-function TSourceCodeLanguages.SupportedLanguageIDs: TArray<string>;
+function TSourceCodeLanguages.SupportedLanguageIDs:
+  TArray<TSourceCodeLanguageID>;
 begin
   Result := fLanguages.Keys.ToArray;
 end;