unit CSLE.Exceptions;

System.SysUtils;

/// <summary>Base exception class for all CodeSnip LE's native exceptions.

/// </summary>

/// <remarks>All descendants inherited the ability to assign one exception to

/// another.</remarks>

EBase = class(Exception)

public

/// <summary>Constructs the exception object that is shallow copy of

/// exception <c>E</c>.</summary>

/// <remarks>Note that any inner exception of <c>E</c> is not copied.

/// </remarks>

constructor Create(const E: Exception); overload;

/// <summary>Sets this exception object's properties to a shallow copy of

/// exception <c>E</c>.</summary>

/// <remarks>

/// <para>Note that any inner exception of <c>E</c> is not copied.</para>

/// <para>Descendants should overload if any new properties are added to

/// those of the <c>Exception</c> class.</para>

/// </remarks>

procedure Assign(const E: Exception); virtual;

end;

/// <summary>Exceptions that represent expected errors and are handled

/// specially by the program.</summary>

/// <remarks>This class can either be used as-is or used as base class for

/// other expected exception types.</remarks>

EExpected = class(EBase);

/// <summary>Exceptions that are not expected, i.e. may be considered as bugs

/// and not handled epxlicitly by the program.</summary>

/// <remarks>This class can either be used as-is or used as base class for

/// other unexpected exception types.</remarks>

EUnexpected = class(EBase);

procedure EBase.Assign(const E: Exception);

Self.Message := E.Message; // only copy Message property

end;

constructor EBase.Create(const E: Exception);

inherited Create('');

Assign(E); // we call assign so that descendants can copy extra properties

end;

end.

unit CSLE.SourceCode.Language;

System.SysUtils,

System.Generics.Defaults;

TSourceCodeLanguageID = record

public

type

/// <summary>Comparator for source code language IDs.</summary>

/// <remarks>Source code language IDs are not case sensitive.</remarks>

TComparator = class(TInterfacedObject,

IComparer<TSourceCodeLanguageID>,

IEqualityComparer<TSourceCodeLanguageID>

)

public

/// <summary>Compares the two given source code language IDs.</summary>

/// <remarks>Returns zero if Left is the same as Right, -ve if Left is

/// less than Right or +ve if Left is greater than Right.</remarks>

function Compare(const Left, Right: TSourceCodeLanguageID): Integer;

/// <summary>Checks if the two given source code language IDs are

/// equal.</summary>

function Equals(const Left, Right: TSourceCodeLanguageID): Boolean;

reintroduce; overload;

/// <summary>Returns the hash code of the given source code language

/// ID.</summary>

function GetHashCode(const Value: TSourceCodeLanguageID): Integer;

reintroduce; overload;

end;

strict private

// Default language ID. This name is reserved: it must not be used as the

// ID for any source code language. To prevent this being done by accident

// the ID is not valid: IsValidIDString will return False for this ID and

// Create will raise an exception if this ID is passed to it.

// To create a default ID call the CreateDefault method.

const

DefaultLanguageID = '_Default_';

var

fID: string;

class function Compare(const Left, Right: TSourceCodeLanguageID): Integer; static;

public

const

/// <summary>Maximum length of an ID.</summary>

MaxLength = 32;

/// <summary>Required name for Pascal language ID.</summary>

/// <remarks>This name is special since Pascal code is treated specially

/// by the program and such special treatment requires the use of this

/// ID.</summary>

PascalLanguageID = 'Pascal';

/// <summary>Creates a new record with ID set to <c>AID</c>.</summary>

/// <exception>Raises exception if <c>AId</c> is not a valid ID and is not

/// the empty string.</exception>

/// <remarks>

/// <para>If <c>AID</c> is empty then the default language ID is created.

/// </para>

/// <para>A non-empty <c>AID</c> must be between 1 and 32 characters,

/// must start with a letter or digit and subsequent characters must be

/// either letters, digits, symbols or punctuation characters.</para>

/// </remarks>

constructor Create(const AID: string);

/// <summary>Creates a default source code language ID.</summary>

class function CreateDefault: TSourceCodeLanguageID; static;

/// <summary>Checks if <c>AStr</c> is valid source code language ID string.

/// </summary>

/// <remarks>A valid ID string is between 1 and 32 characters long, must

/// start with a letter or digit and subsequent characters must be either

/// letters, digits, symbols or punctuation characters.</remarks>

class function IsValidIDString(const AStr: string): Boolean; static;

/// <summary>Returns string representation of ID.</summary>

function ToString: string; inline;

/// <summary>Checks if the current ID is the default ID.</summary>

function IsDefault: Boolean; inline;

/// <summary>Checks if the current ID is that of the Pascal language.

/// </summary>

/// <remarks>Detects if the ID is that specified by the

/// <c>PascalLanguageID</c> constant.</remarks>

function IsPascal: Boolean; inline;

// Default ctor: creates a default source code language ID.

class operator Initialize(out Dest: TSourceCodeLanguageID);

// Comparison operators

class operator Equal(const Left, Right: TSourceCodeLanguageID): Boolean;

class operator NotEqual(const Left, Right: TSourceCodeLanguageID): Boolean;

end;

System.Character,

System.Hash,

System.Types,

CSLE.Exceptions;

class function TSourceCodeLanguageID.Compare(const Left,

Right: TSourceCodeLanguageID): Integer;

Result := string.CompareText(Left.fID, Right.fID);

end;

constructor TSourceCodeLanguageID.Create(const AID: string);

if not AID.IsEmpty then

begin

if not IsValidIDString(AID) then

raise EUnexpected.CreateFmt(

'TSourceCodeLanguageID.Create: Invalid ID string "%s"', [AID]

);

fID := AID;

end

else

fID := DefaultLanguageID;

end;

class function TSourceCodeLanguageID.CreateDefault: TSourceCodeLanguageID;

Result := TSourceCodeLanguageID.Create(string.Empty);

end;

class operator TSourceCodeLanguageID.Equal(const Left,

Right: TSourceCodeLanguageID): Boolean;

Result := Compare(Left, Right) = EqualsValue;

end;

class operator TSourceCodeLanguageID.Initialize(out Dest: TSourceCodeLanguageID);

Dest.fID := DefaultLanguageID;

end;

function TSourceCodeLanguageID.IsDefault: Boolean;

Result := fID = DefaultLanguageID;

end;

function TSourceCodeLanguageID.IsPascal: Boolean;

// Use Equal operator to ensure test allows for case diiferences between this

// record's ID and PascalLangauageID.

Result := TSourceCodeLanguageID.Create(PascalLanguageID) = Self;

end;

class function TSourceCodeLanguageID.IsValidIDString(const AStr: string):

Boolean;

// Per docs:

// [ID] must start with a Unicode letter or digit and be followed by

// a sequence of zero or more Unicode letters, digits and punctuation

// characters.

Result := False;

if AStr.IsEmpty then

Exit;

if AStr.Length > MaxLength then

Exit;

if not AStr[1].IsLetterOrDigit then

Exit;

for var Idx := 2 to AStr.Length do

if not AStr[Idx].IsLetterOrDigit and not AStr[Idx].IsPunctuation

and not AStr[Idx].IsSymbol then

Exit;

Result := True;

end;

class operator TSourceCodeLanguageID.NotEqual(const Left,

Right: TSourceCodeLanguageID): Boolean;

Result := Compare(Left, Right) <> EqualsValue;

end;

function TSourceCodeLanguageID.ToString: string;

Result := fID;

end;

function TSourceCodeLanguageID.TComparator.Compare(const Left,

Right: TSourceCodeLanguageID): Integer;

Result := TSourceCodeLanguageID.Compare(Left, Right);

end;

function TSourceCodeLanguageID.TComparator.Equals(const Left,

Right: TSourceCodeLanguageID): Boolean;

Result := Left = Right;

end;

function TSourceCodeLanguageID.TComparator.GetHashCode(

const Value: TSourceCodeLanguageID): Integer;

Result := THashBobJenkins.GetHashValue(Value.fID);

end;

end.

Test.Streams.Wrapper in 'Test.Streams.Wrapper.pas',

CSLE.Exceptions in '..\src\CSLE.Exceptions.pas',

CSLE.SourceCode.Language in '..\src\CSLE.SourceCode.Language.pas',

Test.SourceCode.Language in 'Test.SourceCode.Language.pas';

<DCCReference Include="..\src\CSLE.Exceptions.pas"/>

<DCCReference Include="..\src\CSLE.SourceCode.Language.pas"/>

<DCCReference Include="Test.SourceCode.Language.pas"/>