absvariant.hpp

Absolute Database 5.12 src. Absolute Database lets you forget the Borland Database Engine (BDE). Th

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Absvariant.pas' rev: 10.00

#ifndef AbsvariantHPP
#define AbsvariantHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Abstypesroutines.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Absvariant
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSVariant;
class PASCALIMPLEMENTATION TABSVariant : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Abstypes::TABSBaseFieldType FDataType;
	int FDataSize;
	char *FPData;
	Byte FIsDataLinked;
	Byte FIsNull;
	
public:
	void __fastcall LoadFromStream(Classes::TStream* Stream);
	void __fastcall SaveToStream(Classes::TStream* Stream);
	__fastcall TABSVariant(Abstypes::TABSBaseFieldType DataType);
	__fastcall virtual ~TABSVariant(void);
	void __fastcall SetNull(Abstypes::TABSBaseFieldType DataType = (Abstypes::TABSBaseFieldType)(0x0));
	void __fastcall Clear(Abstypes::TABSBaseFieldType DataType = (Abstypes::TABSBaseFieldType)(0x0));
	void __fastcall Assign(TABSVariant* Source, bool CopyDataFlag = true);
	void __fastcall SetData(void * Buffer, int Size, Abstypes::TABSBaseFieldType DataType, bool CopyDataFlag = true);
	bool __fastcall CopyDataToAddress(void * Buffer, int MaxSize = 0xffffffff);
	void __fastcall Cast(Abstypes::TABSBaseFieldType NewDataType);
	bool __fastcall IsNumericDataType(void);
	bool __fastcall IsStringDataType(void);
	bool __fastcall IsWideStringDataType(void);
	bool __fastcall IsBlobDataType(void);
	bool __fastcall IsDateTimeDataType(void);
	int __fastcall StrLen(void);
	void __fastcall InvertValue(void);
	void __fastcall Add(TABSVariant* Value);
	void __fastcall Sub(TABSVariant* Value);
	void __fastcall Mul(TABSVariant* Value);
	void __fastcall Division(TABSVariant* Value);
	Abstypes::TABSCompareResult __fastcall Compare(TABSVariant* Value, bool TrueFalseNullLogic = true, bool CaseInsensitive = true, bool PartialKey = false);
	
private:
	void __fastcall SetDataType(Abstypes::TABSBaseFieldType DataType);
	void __fastcall CastResultToType(Abstypes::TABSBaseFieldType NewDataType, /* out */ void *Result);
	void __fastcall CastAndSetData(const void *Value, Abstypes::TABSBaseFieldType ValueType);
	void __fastcall CheckDataForNull(void);
	bool __fastcall GetIsNull(void);
	void __fastcall SetDataValue(const void *value, Abstypes::TABSBaseFieldType ValueType);
	void __fastcall GetDataValue(/* out */ void *Value, Abstypes::TABSBaseFieldType ValueType);
	void __fastcall SetDataAsSignedInt8(Shortint Value);
	Shortint __fastcall GetDataAsSignedInt8(void);
	void __fastcall SetDataAsSignedInt16(short Value);
	short __fastcall GetDataAsSignedInt16(void);
	void __fastcall SetDataAsSignedInt32(int Value);
	int __fastcall GetDataAsSignedInt32(void);
	void __fastcall SetDataAsSignedInt64(__int64 Value);
	__int64 __fastcall GetDataAsSignedInt64(void);
	void __fastcall SetDataAsUnsignedInt8(Byte Value);
	Byte __fastcall GetDataAsUnsignedInt8(void);
	void __fastcall SetDataAsUnsignedInt16(Word Value);
	Word __fastcall GetDataAsUnsignedInt16(void);
	void __fastcall SetDataAsUnsignedInt32(unsigned Value);
	unsigned __fastcall GetDataAsUnsignedInt32(void);
	void __fastcall SetDataAsString(AnsiString Value);
	AnsiString __fastcall GetDataAsString();
	void __fastcall SetDataAsWideString(WideString Value);
	WideString __fastcall GetDataAsWideString();
	void __fastcall SetDataAsSingle(float Value);
	float __fastcall GetDataAsSingle(void);
	void __fastcall SetDataAsDouble(double Value);
	double __fastcall GetDataAsDouble(void);
	void __fastcall SetDataAsExtended(Extended Value);
	Extended __fastcall GetDataAsExtended(void);
	void __fastcall SetDataAsABSDate(int Value);
	int __fastcall GetDataAsABSDate(void);
	void __fastcall SetDataAsTDate(System::TDateTime Value);
	System::TDateTime __fastcall GetDataAsTDate(void);
	void __fastcall SetDataAsABSTime(int Value);
	int __fastcall GetDataAsABSTime(void);
	void __fastcall SetDataAsTTime(System::TDateTime Value);
	System::TDateTime __fastcall GetDataAsTTime(void);
	void __fastcall SetDataAsABSDateTime(const Abstypes::TABSDateTime &Value);
	Abstypes::TABSDateTime __fastcall GetDataAsABSDateTime();
	void __fastcall SetDataAsTDateTime(System::TDateTime Value);
	System::TDateTime __fastcall GetDataAsTDateTime(void);
	void __fastcall SetDataAsBoolean(Word Value);
	Word __fastcall GetDataAsBoolean(void);
	void __fastcall SetDataAsCurrency(double Value);
	double __fastcall GetDataAsCurrency(void);
	void __fastcall SetDataAsVariant(const Variant &Value);
	Variant __fastcall GetDataAsVariant();
	
public:
	__property Abstypes::TABSBaseFieldType DataType = {read=FDataType, write=SetDataType, nodefault};
	__property int DataSize = {read=FDataSize, nodefault};
	__property bool IsNull = {read=GetIsNull, nodefault};
	__property char * pData = {read=FPData};
	__property Byte IsDataLinked = {read=FIsDataLinked, nodefault};
	__property Shortint AsShortint = {read=GetDataAsSignedInt8, write=SetDataAsSignedInt8, nodefault};
	__property short AsSmallint = {read=GetDataAsSignedInt16, write=SetDataAsSignedInt16, nodefault};
	__property int AsInteger = {read=GetDataAsSignedInt32, write=SetDataAsSignedInt32, nodefault};
	__property __int64 AsInt64 = {read=GetDataAsSignedInt64, write=SetDataAsSignedInt64};
	__property Byte AsByte = {read=GetDataAsUnsignedInt8, write=SetDataAsUnsignedInt8, nodefault};
	__property Word AsWord = {read=GetDataAsUnsignedInt16, write=SetDataAsUnsignedInt16, nodefault};
	__property unsigned AsCardinal = {read=GetDataAsUnsignedInt32, write=SetDataAsUnsignedInt32, nodefault};
	__property unsigned AsLongWord = {read=GetDataAsUnsignedInt32, write=SetDataAsUnsignedInt32, nodefault};
	__property float AsSingle = {read=GetDataAsSingle, write=SetDataAsSingle};
	__property double AsDouble = {read=GetDataAsDouble, write=SetDataAsDouble};
	__property Extended AsExtended = {read=GetDataAsExtended, write=SetDataAsExtended};
	__property AnsiString AsString = {read=GetDataAsString, write=SetDataAsString};
	__property WideString AsWideString = {read=GetDataAsWideString, write=SetDataAsWideString};
	__property int AsABSDate = {read=GetDataAsABSDate, write=SetDataAsABSDate, nodefault};
	__property int AsABSTime = {read=GetDataAsABSTime, write=SetDataAsABSTime, nodefault};
	__property Abstypes::TABSDateTime AsABSDateTime = {read=GetDataAsABSDateTime, write=SetDataAsABSDateTime};
	__property System::TDateTime AsTDate = {read=GetDataAsTDate, write=SetDataAsTDate};
	__property System::TDateTime AsTTime = {read=GetDataAsTTime, write=SetDataAsTTime};
	__property System::TDateTime AsTDateTime = {read=GetDataAsTDateTime, write=SetDataAsTDateTime};
	__property Word AsBoolean = {read=GetDataAsBoolean, write=SetDataAsBoolean, nodefault};
	__property Word AsLogical = {read=GetDataAsBoolean, write=SetDataAsBoolean, nodefault};
	__property double AsCurrency = {read=GetDataAsCurrency, write=SetDataAsCurrency};
	__property Variant AsVariant = {read=GetDataAsVariant, write=SetDataAsVariant};
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE Abstypes::TABSBaseFieldType __fastcall GetCommonDataType(Abstypes::TABSBaseFieldType a, Abstypes::TABSBaseFieldType b, bool ForCompare = false)/* overload */;
extern PACKAGE Abstypes::TABSAdvancedFieldType __fastcall GetCommonDataType(Abstypes::TABSAdvancedFieldType a, Abstypes::TABSAdvancedFieldType b, bool ForCompare = false)/* overload */;
extern PACKAGE char * __fastcall CastToNewBuffer(const void *Buffer, const int DataSize, const Abstypes::TABSBaseFieldType DataType, const Abstypes::TABSBaseFieldType NewDataType)/* overload */;
extern PACKAGE char * __fastcall CastToNewBuffer(const void *Buffer, const int DataSize, const Abstypes::TABSBaseFieldType DataType, const Abstypes::TABSBaseFieldType NewDataType, /* out */ int &NewDataSize)/* overload */;
extern PACKAGE Abstypes::TABSCompareResult __fastcall CompareValueBuffers(void * Buffer1, void * Buffer2, Abstypes::TABSBaseFieldType BaseFieldType1, Abstypes::TABSBaseFieldType BaseFieldType2, bool IsField1Null = false, bool IsField2Null = false, int PartialCompareLength = 0xffffffff, bool IgnoreCase = false, unsigned LocaleID = (unsigned)(0x400));
extern PACKAGE int __fastcall CompareValueBuffersForOrder(void * Buffer1, void * Buffer2, Abstypes::TABSBaseFieldType BaseFieldType1, Abstypes::TABSBaseFieldType BaseFieldType2, bool IsField1Null = false, bool IsField2Null = false, int PartialCompareLength = 0xffffffff, bool IgnoreCase = false, unsigned LocaleID = (unsigned)(0x400));

}	/* namespace Absvariant */
using namespace Absvariant;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Absvariant