absbase.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) 'Absbase.pas' rev: 10.00

#ifndef AbsbaseHPP
#define AbsbaseHPP

#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 <Absmemory.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abssecurity.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Abstypesroutines.hpp>	// Pascal unit
#include <Absvariant.hpp>	// Pascal unit
#include <Abslexer.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit

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

namespace Absbase
{
//-- type declarations -------------------------------------------------------
typedef void *TABSFilterRecord;

struct TABSCursorPos
{
	
public:
	bool FirstPosition;
	bool LastPosition;
	#pragma pack(push,1)
	Abstypes::TABSPageItemID RecordID;
	#pragma pack(pop)
} ;

typedef TABSCursorPos *PABSCursorPos;

class DELPHICLASS TABSMetaObjectDef;
class PASCALIMPLEMENTATION TABSMetaObjectDef : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	System::ShortString FName;
	int FObjectID;
	AnsiString FSchemaName;
	int FSchemaID;
	
public:
	__fastcall TABSMetaObjectDef(void);
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	__property System::ShortString Name = {read=FName, write=FName};
	__property int ObjectID = {read=FObjectID, write=FObjectID, nodefault};
	__property AnsiString SchemaName = {read=FSchemaName, write=FSchemaName};
	__property int SchemaID = {read=FSchemaID, write=FSchemaID, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSMetaObjectDef(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSFieldDef;
class PASCALIMPLEMENTATION TABSFieldDef : public TABSMetaObjectDef 
{
	typedef TABSMetaObjectDef inherited;
	
private:
	Abstypes::TABSBaseFieldType FBaseFieldType;
	Abstypes::TABSAdvancedFieldType FAdvancedFieldType;
	int FFieldSize;
	int FDiskDataSize;
	int FMemoryDataSize;
	int FDiskOffset;
	int FMemoryOffset;
	int FFieldNoReference;
	Absvariant::TABSVariant* FDefaultValue;
	System::TObject* FDefaultValueExpr;
	Abscompression::TABSCompressionAlgorithm FBLOBCompressionAlgorithm;
	Byte FBLOBCompressionMode;
	int FBLOBBlockSize;
	__int64 FAutoincIncrement;
	__int64 FAutoincInitialValue;
	__int64 FAutoincMinValue;
	__int64 FAutoincMaxValue;
	Byte FAutoincCycled;
	void __fastcall RecalcInternalSizes(void);
	void __fastcall CreateDefaultValueExprIfNeeded(void);
	
public:
	__fastcall TABSFieldDef(void);
	__fastcall virtual ~TABSFieldDef(void);
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall SetFieldDefDataType(Abstypes::TABSAdvancedFieldType AdvancedFieldType, int FieldSize = 0x0)/* overload */;
	void __fastcall SetFieldDefDataType(Abstypes::TABSBaseFieldType BaseFieldType, int FieldSize = 0x0)/* overload */;
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	__property Abstypes::TABSBaseFieldType BaseFieldType = {read=FBaseFieldType, write=FBaseFieldType, nodefault};
	__property Abstypes::TABSAdvancedFieldType AdvancedFieldType = {read=FAdvancedFieldType, write=FAdvancedFieldType, nodefault};
	__property int FieldSize = {read=FFieldSize, write=FFieldSize, nodefault};
	__property int DiskOffset = {read=FDiskOffset, write=FDiskOffset, nodefault};
	__property int MemoryOffset = {read=FMemoryOffset, write=FMemoryOffset, nodefault};
	__property int DiskDataSize = {read=FDiskDataSize, write=FDiskDataSize, nodefault};
	__property int MemoryDataSize = {read=FMemoryDataSize, write=FMemoryDataSize, nodefault};
	__property int FieldNoReference = {read=FFieldNoReference, write=FFieldNoReference, nodefault};
	__property Absvariant::TABSVariant* DefaultValue = {read=FDefaultValue, write=FDefaultValue};
	__property System::TObject* DefaultValueExpr = {read=FDefaultValueExpr};
	__property __int64 AutoincIncrement = {read=FAutoincIncrement, write=FAutoincIncrement};
	__property __int64 AutoincInitialValue = {read=FAutoincInitialValue, write=FAutoincInitialValue};
	__property __int64 AutoincMinValue = {read=FAutoincMinValue, write=FAutoincMinValue};
	__property __int64 AutoincMaxValue = {read=FAutoincMaxValue, write=FAutoincMaxValue};
	__property Byte AutoincCycled = {read=FAutoincCycled, write=FAutoincCycled, nodefault};
	__property Abscompression::TABSCompressionAlgorithm BLOBCompressionAlgorithm = {read=FBLOBCompressionAlgorithm, write=FBLOBCompressionAlgorithm, nodefault};
	__property Byte BLOBCompressionMode = {read=FBLOBCompressionMode, write=FBLOBCompressionMode, nodefault};
	__property int BLOBBlockSize = {read=FBLOBBlockSize, write=FBLOBBlockSize, nodefault};
};


#pragma option push -b-
enum TABSIndexType { itBTree, itAnotherOne };
#pragma option pop

class DELPHICLASS TABSIndexColumn;
class PASCALIMPLEMENTATION TABSIndexColumn : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	AnsiString FFieldName;
	Byte FDescending;
	Byte FCaseInsensitive;
	int FMaxIndexedSize;
	
public:
	void __fastcall LoadFromStream(Classes::TStream* Stream);
	void __fastcall SaveToStream(Classes::TStream* Stream);
	__property AnsiString FieldName = {read=FFieldName, write=FFieldName};
	__property Byte Descending = {read=FDescending, write=FDescending, nodefault};
	__property Byte CaseInsensitive = {read=FCaseInsensitive, write=FCaseInsensitive, nodefault};
	__property int MaxIndexedSize = {read=FMaxIndexedSize, write=FMaxIndexedSize, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TABSIndexColumn(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSIndexColumn(void) { }
	#pragma option pop
	
};


typedef DynamicArray<TABSIndexColumn* >  ABSBase__5;

class DELPHICLASS TABSIndexDef;
class PASCALIMPLEMENTATION TABSIndexDef : public TABSMetaObjectDef 
{
	typedef TABSMetaObjectDef inherited;
	
private:
	TABSIndexType FIndexType;
	DynamicArray<TABSIndexColumn* >  FIndexColumns;
	Byte FUnique;
	Byte FPrimary;
	int FRootPageNo;
	Byte FTemporary;
	int FSessionID;
	int FTableState;
	Byte FNeedRebuild;
	TABSIndexColumn* __fastcall GetIndexColumn(int Index);
	int __fastcall GetColumnCount(void);
	void __fastcall SetColumnCount(int Value);
	
public:
	__fastcall TABSIndexDef(void);
	__fastcall virtual ~TABSIndexDef(void);
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall AssignByNames(Classes::TStringList* FieldNames, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList);
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	__property TABSIndexType IndexType = {read=FIndexType, write=FIndexType, nodefault};
	__property TABSIndexColumn* Columns[int Index] = {read=GetIndexColumn};
	__property int ColumnCount = {read=GetColumnCount, write=SetColumnCount, nodefault};
	__property Byte Unique = {read=FUnique, write=FUnique, nodefault};
	__property Byte Primary = {read=FPrimary, write=FPrimary, nodefault};
	__property int RootPageNo = {read=FRootPageNo, write=FRootPageNo, nodefault};
	__property Byte Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property int SessionID = {read=FSessionID, write=FSessionID, nodefault};
	__property int TableState = {read=FTableState, write=FTableState, nodefault};
	__property Byte NeedRebuild = {read=FNeedRebuild, write=FNeedRebuild, nodefault};
};


class DELPHICLASS TABSConstraintDef;
class PASCALIMPLEMENTATION TABSConstraintDef : public TABSMetaObjectDef 
{
	typedef TABSMetaObjectDef inherited;
	
private:
	Abstypes::TABSConstraintType FConstraintType;
	
public:
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	__property Abstypes::TABSConstraintType ConstraintType = {read=FConstraintType, write=FConstraintType, nodefault};
public:
	#pragma option push -w-inl
	/* TABSMetaObjectDef.Create */ inline __fastcall TABSConstraintDef(void) : TABSMetaObjectDef() { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSConstraintDef(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSConstraintDefNotNull;
class PASCALIMPLEMENTATION TABSConstraintDefNotNull : public TABSConstraintDef 
{
	typedef TABSConstraintDef inherited;
	
private:
	System::ShortString FTableSchemaName;
	int FTableSchemaObjectID;
	System::ShortString FTableName;
	int FTableObjectID;
	System::ShortString FColumnName;
	int FColumnObjectID;
	
public:
	__fastcall TABSConstraintDefNotNull(void);
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall SetNames(AnsiString ColumnName, AnsiString TableName = "", AnsiString SchemaName = "");
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	__property System::ShortString TableSchemaName = {read=FTableSchemaName, write=FTableSchemaName};
	__property int TableSchemaObjectID = {read=FTableSchemaObjectID, write=FTableSchemaObjectID, nodefault};
	__property System::ShortString TableName = {read=FTableName, write=FTableName};
	__property int TableObjectID = {read=FTableObjectID, write=FTableObjectID, nodefault};
	__property System::ShortString ColumnName = {read=FColumnName, write=FColumnName};
	__property int ColumnObjectID = {read=FColumnObjectID, write=FColumnObjectID, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSConstraintDefNotNull(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSConstraintDefCheck;
class PASCALIMPLEMENTATION TABSConstraintDefCheck : public TABSConstraintDef 
{
	typedef TABSConstraintDef inherited;
	
private:
	System::ShortString FTableSchemaName;
	int FTableSchemaObjectID;
	System::ShortString FTableName;
	int FTableObjectID;
	System::ShortString FColumnName;