source: trunk/DataTypes.pas

unit DataTypes;

interface

uses
  Classes, SysUtils, DbEngine, USqlDatabase;

type
  { TValueString }

  TValueString = class(TValue)
    Value: string;
    procedure Assign(Source: TValue); override;
    function GetString: string; override;
    procedure SetString(Value: string); override;
  end;

  { TValueInteger }

  TValueInteger = class(TValue)
    Value: Integer;
    procedure Assign(Source: TValue); override;
    function GetString: string; override;
    procedure SetString(Value: string); override;
  end;

  { TValueDateTime }

  TValueDateTime = class(TValue)
    Value: TDateTime;
    procedure Assign(Source: TValue); override;
    function GetString: string; override;
    procedure SetString(Value: string); override;
  end;

  { TValueDate }

  TValueDate = class(TValueDateTime)
  end;

  { TValueTime }

  TValueTime = class(TValueDateTime)
  end;

  { TValueBoolean }

  TValueBoolean = class(TValue)
    Value: Boolean;
    procedure Assign(Source: TValue); override;
    function GetString: string; override;
    procedure SetString(Value: string); override;
  end;

  { TValueFloat }

  TValueFloat = class(TValue)
    Value: Double;
    procedure Assign(Source: TValue); override;
    function GetString: string; override;
    procedure SetString(Value: string); override;
  end;

  { TValueReference }

  TValueReference = class(TValueInteger)
  end;

  { TFieldString }

  TFieldString = class(TFieldTypeSpecific)
    DefaultValue: string;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  { TFieldInteger }

  TFieldInteger = class(TFieldTypeSpecific)
    Min: Integer;
    Max: Integer;
    DefaultValue: Integer;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  { TFieldFloat }

  TFieldFloat = class(TFieldTypeSpecific)
    Min: Double;
    Max: Double;
    DefaultValue: Double;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  { TFieldDateTime }

  TFieldDateTime = class(TFieldTypeSpecific)
    Min: TDateTime;
    Max: TDateTime;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  TFieldDate = class(TFieldTypeSpecific)
    Min: TDate;
    Max: TDate;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  { TFieldTime }

  TFieldTime = class(TFieldTypeSpecific)
    Min: TTime;
    Max: TTime;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  TFieldImage = class(TFieldTypeSpecific)
    MinSize: TPoint;
    MaxSize: TPoint;
  end;

  { TFieldReference }

  TFieldReference = class(TFieldTypeSpecific)
    TableName: string;
    Id: Integer;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  { TFieldBoolean }

  TFieldBoolean = class(TFieldTypeSpecific)
    DefaultValue: Boolean;
    procedure Assign(Source: TFieldTypeSpecific); override;
    function GetValueClass: TValueClass; override;
  end;

  TFieldMapPosition = class(TFieldTypeSpecific)
  end;


implementation

{ TFieldReference }

procedure TFieldReference.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldReference then begin
    Id := TFieldReference(Source).Id;
    TableName := TFieldReference(Source).TableName;
  end;
end;

function TFieldReference.GetValueClass: TValueClass;
begin
  Result := TValueReference;
end;

{ TFieldTime }

procedure TFieldTime.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldTime then begin
    Min := TFieldTime(Source).Min;
    Max := TFieldTime(Source).Max;
  end;
end;

function TFieldTime.GetValueClass: TValueClass;
begin
  Result := TValueTime;
end;

{ TFieldDate }

procedure TFieldDate.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldDate then begin
    Min := TFieldDate(Source).Min;
    Max := TFieldDate(Source).Max;
  end;
end;

function TFieldDate.GetValueClass: TValueClass;
begin
  Result := TValueDate;
end;

{ TValueFloat }

procedure TValueFloat.Assign(Source: TValue);
begin
  if Source is TValueFloat then
    Value := TValueFloat(Source).Value;
end;

function TValueFloat.GetString: string;
begin
  Result := FloatToStr(Value);
end;

procedure TValueFloat.SetString(Value: string);
begin
  Self.Value := StrToFloat(Value);
end;

{ TFieldBoolean }

procedure TFieldBoolean.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldBoolean then begin
    DefaultValue := TFieldBoolean(Source).DefaultValue;
  end;
end;

function TFieldBoolean.GetValueClass: TValueClass;
begin
  Result := TValueBoolean;
end;

{ TFieldFloat }

procedure TFieldFloat.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldFloat then begin
    DefaultValue:= TFieldFloat(Source).DefaultValue;
    Min:= TFieldFloat(Source).Min;
    Max:= TFieldFloat(Source).Max;
  end;
end;

function TFieldFloat.GetValueClass: TValueClass;
begin
  Result := TValueFloat;
end;

{ TFieldInteger }

procedure TFieldInteger.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldInteger then begin
    DefaultValue:= TFieldInteger(Source).DefaultValue;
    Min:= TFieldInteger(Source).Min;
    Max:= TFieldInteger(Source).Max;
  end;
end;

function TFieldInteger.GetValueClass: TValueClass;
begin
  Result := TValueInteger;
end;

{ TValueBoolean }

procedure TValueBoolean.Assign(Source: TValue);
begin
  if Source is TValueBoolean then
    Value := TValueBoolean(Source).Value;
end;

function TValueBoolean.GetString: string;
begin
  Result := BoolToStr(Value);
end;

procedure TValueBoolean.SetString(Value: string);
begin
  Self.Value := StrToBool(Value);
end;

{ TValueInteger }

procedure TValueInteger.Assign(Source: TValue);
begin
  if Source is TValueInteger then
    Value := TValueInteger(Source).Value;
end;

function TValueInteger.GetString: string;
begin
  Result := IntToStr(Value);
end;

procedure TValueInteger.SetString(Value: string);
var
  IntVal: Integer;
begin
  if TryStrToInt(Value, IntVal) then Self.Value := IntVal;
end;

{ TFieldDateTime }

procedure TFieldDateTime.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldDateTime then begin
    Min := TFieldDateTime(Source).Min;
    Max := TFieldDateTime(Source).Max;
  end;
end;

function TFieldDateTime.GetValueClass: TValueClass;
begin
  Result := TValueDateTime;
end;

{ TValueDateTime }

procedure TValueDateTime.Assign(Source: TValue);
begin
  if Source is TValueDateTime then
    Value := TValueDateTime(Source).Value;
end;

function TValueDateTime.GetString: string;
begin
  Result := DateTimeToStr(Value);
end;

procedure TValueDateTime.SetString(Value: string);
begin
  Self.Value := SQLToDateTime(Value);
//  if not TryStrToDateTime(Value, Self.Value) then begin
//  end;
end;

{ TValueString }

procedure TValueString.Assign(Source: TValue);
begin
  if Source is TValueString then
    Value := TValueString(Source).Value;
end;

function TValueString.GetString: string;
begin
  Result := Value;
end;

procedure TValueString.SetString(Value: string);
begin
  Self.Value := Value;
end;

{ TFieldString }

procedure TFieldString.Assign(Source: TFieldTypeSpecific);
begin
  if Source is TFieldString then
    DefaultValue:= TFieldString(Source).DefaultValue;
end;

function TFieldString.GetValueClass: TValueClass;
begin
  Result := TValueString;
end;

end.