Generics.Operators

unit Generics.Operators;

interface

uses
  TypInfo;

type
  Operators = class
  private
    class procedure RaiseNotSupported(typeInfo: PTypeInfo); static; inline;

    class procedure AddInt8(const left, right; var Result); inline;
    class procedure AddUInt8(const left, right; var Result); inline;
    class procedure AddInt16(const left, right; var Result); inline;
    class procedure AddUInt16(const left, right; var Result); inline;
    class procedure AddInt32(const left, right; var Result); inline;
    class procedure AddUInt32(const left, right; var Result); inline;
    class procedure AddInt64(const left, right; var Result); inline;
    class procedure AddUInt64(const left, right; var Result); inline;

    class procedure AddSingle(const left, right; var Result); inline;
    class procedure AddDouble(const left, right; var Result); inline;
    class procedure AddCurrency(const left, right; var Result); inline;
    class procedure AddComp(const left, right; var Result); inline;
    class procedure AddExtended(const left, right; var Result); inline;

    class procedure AddVariant(const left, right; var Result); inline;
    class procedure AddUnicodeString(const left, right; var Result); inline;
  public
    class function Add<T>(const left, right: T): T; inline;
  end;

implementation

uses
  SysUtils;

class procedure Operators.AddInt8(const left, right; var Result);
begin
  ShortInt(Result) := ShortInt(left) + ShortInt(right);
end;

class procedure Operators.AddInt16(const left, right; var Result);
begin
  SmallInt(Result) := SmallInt(left) + SmallInt(right);
end;

class procedure Operators.AddInt32(const left, right; var Result);
begin
  Integer(Result) := Integer(left) + Integer(right);
end;

class procedure Operators.AddInt64(const left, right; var Result);
begin
  Int64(Result) := Int64(left) + Int64(right);
end;

class procedure Operators.AddUInt8(const left, right; var Result);
begin
  Byte(Result) := Byte(left) + Byte(right);
end;

class procedure Operators.AddUInt16(const left, right; var Result);
begin
  Word(Result) := Word(left) + Word(right);
end;

class procedure Operators.AddUInt32(const left, right; var Result);
begin
  Cardinal(Result) := Cardinal(left) + Cardinal(right);
end;

class procedure Operators.AddUInt64(const left, right; var Result);
begin
  UInt64(Result) := UInt64(left) + UInt64(right);
end;

class procedure Operators.AddSingle(const left, right; var Result);
begin
  Single(Result) := Single(left) + Single(right);
end;

class procedure Operators.AddDouble(const left, right; var Result);
begin
  Double(Result) := Double(left) + Double(right);
end;

class procedure Operators.AddCurrency(const left, right; var Result);
begin
  Currency(Result) := Currency(left) + Currency(right);
end;

class procedure Operators.AddComp(const left, right; var Result);
begin
  Comp(Result) := Comp(left) + Comp(right);
end;

class procedure Operators.AddExtended(const left, right; var Result);
begin
  Extended(Result) := Extended(left) + Extended(right);
end;

class procedure Operators.AddVariant(const left, right; var Result);
begin
  Variant(Result) := Variant(left) + Variant(right);
end;

class procedure Operators.AddUnicodeString(const left, right; var Result);
begin
  UnicodeString(Result) := UnicodeString(left) + UnicodeString(right);
end;

class procedure Operators.RaiseNotSupported(typeInfo: PTypeInfo);
begin
  raise ENotSupportedException.CreateFmt('Operation not supported for type %s', [typeInfo.Name]);
end;

class function Operators.Add<T>(const left, right: T): T;
begin
  case GetTypeKind(T) of
    tkInteger:
      case SizeOf(T) of
        1:
          if (TypeInfo(T) = TypeInfo(ShortInt)) then
            AddInt8(left, right, Result)
          else
            AddUInt8(left, right, Result);
        2:
          if (TypeInfo(T) = TypeInfo(SmallInt)) then
            AddInt16(left, right, Result)
          else
            AddUInt16(left, right, Result);
        4:
          if (TypeInfo(T) = TypeInfo(Integer))
            or (TypeInfo(T) = TypeInfo(NativeInt)) then
            AddInt32(left, right, Result);
          else
            AddUInt32(left, right, Result);
      end;
    tkFloat:
      case SizeOf(T) of
        4: AddSingle(left, right, Result);
        8:
          if TypeInfo(T) = TypeInfo(Currency) then
            AddCurrency(left, right, Result)
          else if TypeInfo(T) = TypeInfo(Comp) then
            AddComp(left, right, Result)
          else
            AddDouble(left, right, Result);
        10: AddExtended(left, right, Result);
      end;
//    tkString:
//    tkSet:
//    tkLString:
//    tkWString:
    tkVariant: AddVariant(left, right, Result);
//    tkArray:
//    tkRecord:
    tkInt64:
      if (TypeInfo(T) = TypeInfo(Int64))
        or (TypeInfo(T) = TypeInfo(NativeInt)) then
        AddInt64(left, right, Result)
      else
        AddUInt64(left, right, Result);
//    tkDynArray: System._DynArrayCat3(Result, left, right);
    tkUString: AddUnicodeString(left, right, Result);
  else
    RaiseNotSupported(TypeInfo(T));
  end;
end;

end.