cxvariants.pas

来自「胜天进销存源码,国产优秀的进销存」· PAS 代码 · 共 1,201 行 · 第 1/3 页

      if AValue then
        WriteValue(vaTrue)
      else
        WriteValue(vaFalse);
    {$IFDEF DELPHI4}
    varOleStr:
      WriteWideString(AValue);
    varSingle:
      WriteSingle(AValue);
    varCurrency:
      WriteCurrency(AValue);
    varDate:
      WriteDate(AValue);
    {$ENDIF}
  else
{$IFDEF DELPHI6}
  {$IFNDEF NONDB}
    if VType = VarSQLTimeStamp then
      WriteVariantProc(AStream, TDateTime(AValue))
    else
  {$ENDIF}
{$ENDIF}
    try
      WriteString(AValue);
    except
      raise EWriteError.Create(cxSDataWriteError);
    end;
  end;
end;

function ReadBooleanFunc(AStream: TStream): Boolean;
begin
  ReadBooleanProc(AStream, Result);
end;

procedure ReadBooleanProc(AStream: TStream; var Value: Boolean);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteBooleanProc(AStream: TStream; AValue: Boolean);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadCharFunc(AStream: TStream): Char;
begin
  ReadCharProc(AStream, Result);
end;

procedure ReadCharProc(AStream: TStream; var Value: Char);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteCharProc(AStream: TStream; AValue: Char);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadFloatFunc(AStream: TStream): Extended;
begin
  ReadFloatProc(AStream, Result);
end;

procedure ReadFloatProc(AStream: TStream; var Value: Extended);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteFloatProc(AStream: TStream; AValue: Extended);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadSingleFunc(AStream: TStream): Single;
begin
  ReadSingleProc(AStream, Result);
end;

procedure ReadSingleProc(AStream: TStream; var Value: Single);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteSingleProc(AStream: TStream; AValue: Single);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadCurrencyFunc(AStream: TStream): Currency;
begin
  ReadCurrencyProc(AStream, Result);
end;

procedure ReadCurrencyProc(AStream: TStream; var Value: Currency);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteCurrencyProc(AStream: TStream; AValue: Currency);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadDateTimeFunc(AStream: TStream): TDateTime;
begin
  ReadDateTimeProc(AStream, Result);
end;

procedure ReadDateTimeProc(AStream: TStream; var Value: TDateTime);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteDateTimeProc(AStream: TStream; AValue: TDateTime);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadIntegerFunc(AStream: TStream): Integer;
begin
  ReadIntegerProc(AStream, Result);
end;

procedure ReadIntegerProc(AStream: TStream; var Value: Integer);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteIntegerProc(AStream: TStream; AValue: Integer);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadLargeIntFunc(AStream: TStream): LargeInt;
begin
  ReadLargeIntProc(AStream, Result);
end;

procedure ReadLargeIntProc(AStream: TStream; var Value: LargeInt);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteLargeIntProc(AStream: TStream; AValue: LargeInt);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadByteFunc(AStream: TStream): Byte;
begin
  ReadByteProc(AStream, Result);
end;

procedure ReadByteProc(AStream: TStream; var Value: Byte);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteByteProc(AStream: TStream; AValue: Byte);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadSmallIntFunc(AStream: TStream): SmallInt;
begin
  ReadSmallIntProc(AStream, Result);
end;

procedure ReadSmallIntProc(AStream: TStream; var Value: SmallInt);
begin
  AStream.ReadBuffer(Value, SizeOf(Value));
end;

procedure WriteSmallIntProc(AStream: TStream; AValue: SmallInt);
begin
  AStream.WriteBuffer(AValue, SizeOf(AValue));
end;

function ReadCardinalFunc(AStream: TStream): Cardinal;
begin
  ReadCardinalProc(AStream, Result);
end;

procedure ReadCardinalProc(AStream: TStream; var Value: Cardinal);
begin
  Value := ReadIntegerFunc(AStream);
end;

procedure WriteCardinalProc(AStream: TStream; AValue: Cardinal);
begin
  WriteIntegerProc(AStream, AValue);
end;

function ReadShortIntFunc(AStream: TStream): ShortInt;
begin
  ReadShortIntProc(AStream, Result);
end;

procedure ReadShortIntProc(AStream: TStream; var Value: ShortInt);
begin
  Value := ReadByteFunc(AStream);
end;

procedure WriteShortIntProc(AStream: TStream; AValue: ShortInt);
begin
  WriteByteProc(AStream, AValue);
end;

function ReadWordFunc(AStream: TStream): Word;
begin
  ReadWordProc(AStream, Result);
end;

procedure ReadWordProc(AStream: TStream; var Value: Word);
begin
  Value := ReadSmallIntFunc(AStream);
end;

procedure WriteWordProc(AStream: TStream; AValue: Word);
begin
  WriteSmallIntProc(AStream, AValue);
end;

{ TcxFiler }

constructor TcxFiler.Create(AStream: TStream);
begin
  inherited Create;
  FStream := AStream;
end;

{ TcxReader }

function TcxReader.ReadBoolean: Boolean;
begin
  ReadBooleanProc(Stream, Result);
end;

function TcxReader.ReadByte: Byte;
begin
  ReadByteProc(Stream, Result);
end;

function TcxReader.ReadCardinal: Cardinal;
begin
  ReadCardinalProc(Stream, Result);
end;

function TcxReader.ReadChar: Char;
begin
  ReadCharProc(Stream, Result);
end;

function TcxReader.ReadCurrency: Currency;
begin
  ReadCurrencyProc(Stream, Result);
end;

function TcxReader.ReadDateTime: TDateTime;
begin
  ReadDateTimeProc(Stream, Result);
end;

function TcxReader.ReadFloat: Extended;
begin
  ReadFloatProc(Stream, Result);
end;

function TcxReader.ReadInteger: Integer;
begin
  ReadIntegerProc(Stream, Result);
end;

function TcxReader.ReadLargeInt: LargeInt;
begin
  ReadLargeIntProc(Stream, Result);
end;

function TcxReader.ReadShortInt: ShortInt;
begin
  ReadShortIntProc(Stream, Result);
end;

function TcxReader.ReadSingle: Single;
begin
  ReadSingleProc(Stream, Result);
end;

function TcxReader.ReadSmallInt: SmallInt;
begin
  ReadSmallIntProc(Stream, Result);
end;

function TcxReader.ReadString: string;
begin
  ReadStringProc(Stream, Result);
end;

function TcxReader.ReadVariant: Variant;
begin
  ReadVariantProc(Stream, Result);
end;

function TcxReader.ReadWideString: WideString;
begin
  ReadWideStringProc(Stream, Result);
end;

function TcxReader.ReadWord: Word;
begin
  ReadWordProc(Stream, Result);
end;

{ TcxWriter }

procedure TcxWriter.WriteBoolean(AValue: Boolean);
begin
  WriteBooleanProc(Stream, AValue);
end;

procedure TcxWriter.WriteByte(AValue: Byte);
begin
  WriteByteProc(Stream, AValue);
end;

procedure TcxWriter.WriteCardinal(AValue: Cardinal);
begin
  WriteCardinalProc(Stream, AValue);
end;

procedure TcxWriter.WriteChar(AValue: Char);
begin
  WriteCharProc(Stream, AValue);
end;

procedure TcxWriter.WriteCurrency(AValue: Currency);
begin
  WriteCurrencyProc(Stream, AValue);
end;

procedure TcxWriter.WriteDateTime(AValue: TDateTime);
begin
  WriteDateTimeProc(Stream, AValue);
end;

procedure TcxWriter.WriteFloat(AValue: Extended);
begin
  WriteFloatProc(Stream, AValue);
end;

procedure TcxWriter.WriteInteger(AValue: Integer);
begin
  WriteIntegerProc(Stream, AValue);
end;

procedure TcxWriter.WriteLargeInt(AValue: LargeInt);
begin
  WriteLargeIntProc(Stream, AValue);
end;

procedure TcxWriter.WriteShortInt(AValue: ShortInt);
begin
  WriteShortIntProc(Stream, AValue);
end;

procedure TcxWriter.WriteSingle(AValue: Single);
begin
  WriteSingleProc(Stream, AValue);
end;

procedure TcxWriter.WriteSmallInt(AValue: SmallInt);
begin
  WriteSmallIntProc(Stream, AValue);
end;

procedure TcxWriter.WriteString(const S: string);
begin
  WriteStringProc(Stream, S);
end;

procedure TcxWriter.WriteVariant(const AValue: Variant);
begin
  WriteVariantProc(Stream, AValue);
end;

procedure TcxWriter.WriteWideString(const S: WideString);
begin
  WriteWideStringProc(Stream, S);
end;

procedure TcxWriter.WriteWord(AValue: Word);
begin
  WriteWordProc(Stream, AValue);
end;

end.