(*
  String Utility Library
  Tuğrul HELVACI - 2010
  www.tugrulhelvaci.com
*)
unit StringUtils;

interface
  uses Classes, SysUtils, Generics.Defaults, Generics.Collections;

type
  NewString = record
  private
    fData : String;
  public
    constructor Create(const AData : String);
    function ToString : String;

    function ToCharArray : TList<Char>; overload;
    function ToCharArray(const StartIndex, Count : Integer) : TList<Char>; overload;

    function Contains(const SubStr : String)  : Boolean;
    function EndsWith(const Value : String)   : Boolean;
    function StartsWith(const Value : String) : Boolean;
    function IndexOf(const Value : String)    : Integer;
    function Length : Integer;

    function PadLeft(const TotalWidth : Integer) : NewString; overload;
    function PadLeft(const TotalWidth : Integer; const Value : Char) : NewString; overload;

    function PadRight(const TotalWidth : Integer) : NewString; overload;
    function PadRight(const TotalWidth : Integer; const Value : Char) : NewString; overload;

    function Remove(const StartIndex : Integer) : NewString; overload;
    function Remove(const StartIndex, Count : Integer) : NewString; overload;

    function Replace(const OldValue, NewValue : String) : NewString;
    function SubString(const StartIndex, Count : Integer) : NewString;
    function Trim     : NewString;
    function TrimLeft : NewString;
    function TrimRight: NewString;
    function ToLower  : NewString;
    function ToUpper  : NewString;
    function IsNumeric: Boolean;
    function Split(const Seperator : Char) : TList<String>;

    class operator Implicit(const Left : String) : NewString;
    class operator Explicit(const Left : NewString) : String;

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

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

    class operator Add(const Left, Right : NewString) : NewString;
    class operator Add(const Left : NewString; const Right : String) : NewString;
    class operator Add(const Left : String; const Right : NewString) : NewString;

    class operator Multiply(const Left : Integer; const Right : NewString) : NewString;
    class operator Multiply(const Left : NewString; const Right : Integer) : NewString;

    class operator Negative(const Left : NewString) : NewString;
  end;


implementation
uses
  StrUtils;

{ NewString }

class operator NewString.Add(const Left, Right: NewString): NewString;
begin
  Result.fData := Left.fData + Right.fData;
end;

class operator NewString.Add(const Left: NewString;
  const Right: String): NewString;
begin
  Result.fData := Left.fData + Right;
end;

class operator NewString.Add(const Left: String;
  const Right: NewString): NewString;
begin
  Result.fData := Left + Right.fData;
end;

function NewString.Contains(const SubStr: String): Boolean;
begin
  Result := Pos(SubStr, fData) > 0;
end;

constructor NewString.Create(const AData: String);
begin
  fData := AData;
end;

function NewString.EndsWith(const Value: String): Boolean;
begin
  Result := Copy(fData, System.Length(fData) - System.Length(Value) + 1, System.Length(Value)) = Value;
end;

class operator NewString.Equal(const Left: String;
  const Right: NewString): Boolean;
begin
  Result := Left = Right.fData;
end;

class operator NewString.Explicit(const Left: NewString): String;
begin
  Result := Left.fData;
end;

class operator NewString.Equal(const Left: NewString; const Right: String): Boolean;
begin
  Result := Left.fData = Right;
end;

class operator NewString.Equal(const Left, Right: NewString): Boolean;
begin
  Result := Left.fData = Right.fData;
end;

class operator NewString.Implicit(const Left: String): NewString;
begin
  Result.fData := Left;
end;

function NewString.IndexOf(const Value: String): Integer;
begin
  Result := Pos(Value, fData);
end;

function NewString.IsNumeric: Boolean;
var
  ch : Char;
begin
  Result := True;

  for ch in fData do
    if not (ch in ['0'..'9', DecimalSeparator]) then Exit(False);
end;

function NewString.Length: Integer;
begin
  Result := System.Length(fData)
end;

class operator NewString.Multiply(const Left: Integer;
  const Right: NewString): NewString;
begin
  Result.fData := DupeString(Right.fData, Left);
end;

class operator NewString.Multiply(const Left: NewString;
  const Right: Integer): NewString;
begin
  Result.fData := DupeString(Left.fData, Right);
end;

class operator NewString.NotEqual(const Left, Right: NewString): Boolean;
begin
  Result := Left.fData <> Right.fData;
end;

class operator NewString.NotEqual(const Left: NewString;
  const Right: String): Boolean;
begin
  Result := Left.fData <> Right;
end;

class operator NewString.Negative(const Left: NewString): NewString;
begin
  Result.fData := ReverseString(Left.fData);
end;

class operator NewString.NotEqual(const Left: String;
  const Right: NewString): Boolean;
begin
  Result := Left <> Right.fData;
end;

function NewString.PadLeft(const TotalWidth: Integer): NewString;
begin
  Result.fData := StringOfChar(' ', TotalWidth - System.Length(fData)) + fData;
end;

function NewString.PadLeft(const TotalWidth: Integer;
  const Value: Char): NewString;
begin
  Result.fData := StringOfChar(Value, TotalWidth - System.Length(fData)) + fData;
end;

function NewString.PadRight(const TotalWidth: Integer): NewString;
begin
  Result.fData := fData + StringOfChar(' ', TotalWidth - System.Length(fData));
end;

function NewString.PadRight(const TotalWidth: Integer;
  const Value: Char): NewString;
begin
  Result.fData := fData + StringOfChar(Value, TotalWidth - System.Length(fData));
end;

function NewString.Remove(const StartIndex: Integer): NewString;
begin
  Result.fData := fData;
  Delete(Result.fData, StartIndex, System.Length(fData));
end;

function NewString.Remove(const StartIndex, Count: Integer): NewString;
begin
  Result.fData := fData;
  Delete(Result.fData, StartIndex, Count);
end;

function NewString.Replace(const OldValue, NewValue: String): NewString;
begin
  Result.fData := StringReplace(fData, OldValue, NewValue, [rfReplaceAll]);
end;

function NewString.Split(const Seperator: Char): TList<String>;
var
  sList : TStrings;
  s : String;
begin
  Result := TList<string>.Create;
  sList := TStringList.Create;

  try
    ExtractStrings([Seperator], [], PWideChar(fData), sList);
    for s in sList do
      Result.Add(s);
  finally
    sList.Free;
  end;
end;

function NewString.StartsWith(const Value: String): Boolean;
begin
  Result := Copy(fData, 1, System.Length(Value)) = Value;
end;

function NewString.SubString(const StartIndex, Count : Integer): NewString;
begin
  Result.fData := Copy(fData, StartIndex, Count);
end;

function NewString.ToCharArray: TList<Char>;
var
  ch : Char;
begin
  Result := TList<Char>.Create;

  for ch in fData do
    Result.Add(ch);
end;

function NewString.ToCharArray(const StartIndex, Count: Integer): TList<Char>;
var
  New : NewString;
  ch  : Char;
begin
  Result := TList<Char>.Create;
  New := SubString(StartIndex, Count);

  for ch in New.fData do
    Result.Add(ch);
end;

function NewString.ToLower: NewString;
begin
  Result.fData := LowerCase(fData);
end;

function NewString.ToString: String;
begin
  Result := fData;
end;

function NewString.ToUpper: NewString;
begin
  Result.fData := UpperCase(fData);
end;

function NewString.Trim: NewString;
begin
  Result.fData := SysUtils.Trim(fData);
end;

function NewString.TrimLeft: NewString;
begin
  Result.fData := SysUtils.TrimLeft(fData);
end;

function NewString.TrimRight: NewString;
begin
  Result.fData := SysUtils.TrimRight(fData);
end;

end.