mytools.pas

Software Requirements1. Delphi 6 SP22. Oracle 8i R33. Raize 3.0.94. ExpressQuantumGrid 4.505. Expres

unit MyTools;

interface

uses
  Classes;

const
  INT_F5 = 4128769;
  INT_F6 = 4194305;
  INT_IM_EN = 1;
  INT_IM_PY = 2;
  S_IM_PY = '中文 (简体) - 微软拼音 IME 3.0';

type
  IParameters = interface
  end;

  ICloneable = interface
    function Clone: ICloneable;
  end;

  IKey = interface(IParameters)
  end;

  ISKey = interface(IKey)
    function GetKeyName: string;
    procedure SetKeyName(const KeyName: string);
  end;

  IMKey = interface(IKey)
    function GetCount: Integer;
    procedure AddKey(var Key: ISKey);
    function GetKey(const Index: Integer): ISKey;
  end;

  TMKey = class(TInterfacedObject, IMKey)
  private
    Keys: TList;
  public
    constructor Creat; virtual;
    destructor Destroy; override;
    function GetCount: Integer;
    procedure AddKey(var Key: ISKey);
    function GetKey(const Index: Integer): ISKey;
  end;

  IDataItem = interface(ICloneable)
    function GetKey: IKey;
  end;

  IDataItemList = interface
    function GetItem(Index: Integer): IDataItem;
    procedure AddItem(Item: IDataItem);
    function GetCount: Integer;
  end;

  TDataItemList = class(TInterfacedObject, IDataItemList)
  private
    List: TList;
  public
    constructor Create;
    destructor Destroy; override;
    function GetItem(Index: Integer): IDataItem;
    procedure AddItem(Item: IDataItem);
    function GetCount: Integer;
  end;

  IQueryParameters = interface(IParameters)
    function GetParameters: TStrings;
  end;

  TQueryParameters = class(TInterfacedObject, IQueryParameters)
  private
    Strings: TStrings;
  public
    constructor Create(Strings: TStrings);
    destructor Destroy; override;
    function GetParameters: TStrings;
  end;

  IStringKey = interface(ISKey)
    function GetKey: string;
    procedure SetKey(const Key: string);
  end;

  IIntegerKey = interface(ISKey)
    function GetKey: Integer;
    procedure SetKey(const Key: Integer);
  end;

  ICurrencyKey = interface(ISKey)
    function GetKey: Currency;
    procedure SetKey(const Key: Currency);
  end;

  TKey = class(TInterfacedObject, IKey)
  private
    KeyName: string;
  public
    function GetKeyName: string; virtual;
    procedure SetKeyName(const KeyName: string); virtual;
  end;

  IFloatKey = interface(ISKey)
    function GetKey: Double;
    procedure SetKey(const Key: Double);
  end;

  TFloatKey = class(TKey, IFloatKey)
  private
    Key: Double;
  public
    function GetKey: Double;
    procedure SetKey(const Key: Double);
  end;

  TCurrencyKey = class(TKey, ICurrencyKey)
  private
    Key: Currency;
  public
    function GetKey: Currency;
    procedure SetKey(const Key: Currency);
  end;

  TIntegerKey = class(TKey, IIntegerKey)
  private
    Key: Integer;
  public
    function GetKey: Integer; virtual;
    procedure SetKey(const Key: Integer); virtual;
  end;

  TStringKey = class(TKey, IStringKey)
  private
    Key: string;
  public
    function GetKey: string; virtual;
    procedure SetKey(const Key: string); virtual;
  end;

implementation

uses
  SysUtils, Dialogs;

{ TQueryParameters }

constructor TQueryParameters.Create(Strings: TStrings);
begin
  Self.Strings := Strings;  
end;

destructor TQueryParameters.Destroy;
begin
  Strings.Free;
  inherited;
end;

function TQueryParameters.GetParameters: TStrings;
begin
  Result := Strings;
end;

{ TDataItemList }

procedure TDataItemList.AddItem(Item: IDataItem);
begin

end;

constructor TDataItemList.Create;
begin
  List := TList.Create;
end;

destructor TDataItemList.Destroy;
begin
  while List.Count > 0 do
    List.Delete(0);
  FreeAndNil(List);
  inherited;
end;

function TDataItemList.GetCount: Integer;
begin
  Result := List.Count;
end;

function TDataItemList.GetItem(Index: Integer): IDataItem;
begin
  if (Index >= 0) and (Index < List.Count) then
    Result := IDataItem(List.Items[Index]);
end;

{ TKey }

function TKey.GetKeyName: string;
begin
  Result := KeyName;
end;

procedure TKey.SetKeyName(const KeyName: string);
begin
  Self.KeyName := KeyName;
end;

{ TStringKey }

function TStringKey.GetKey: string;
begin
  Result := Key;
end;

procedure TStringKey.SetKey(const Key: string);
begin
  Self.Key := Key;
end;

{ TIntegerKey }

function TIntegerKey.GetKey: Integer;
begin
  Result := Key;
end;

procedure TIntegerKey.SetKey(const Key: Integer);
begin
  Self.Key := Key;
end;

{ TMKey }

procedure TMKey.AddKey(var Key: ISKey);
begin
  Keys.Add(TObject(Key))
end;

constructor TMKey.Creat;
begin
  inherited;
  Keys := TList.Create;
end;

destructor TMKey.Destroy;
begin
  Keys.Free;
  inherited;
end;

function TMKey.GetCount: Integer;
begin
  Result := Keys.Count;
end;

function TMKey.GetKey(const Index: Integer): ISKey;
begin
  Result := ISKey(Keys.Items[Index]);
end;

{ TCurrencyKey }

function TCurrencyKey.GetKey: Currency;
begin
  Result := Key;
end;

procedure TCurrencyKey.SetKey(const Key: Currency);
begin
  Self.Key := Key;
end;

{ TFloatKey }

function TFloatKey.GetKey: Double;
begin
  Result := Key;
end;

procedure TFloatKey.SetKey(const Key: Double);
begin
  Self.Key := Key;
end;

end.