absmain.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) 'Absmain.pas' rev: 10.00

#ifndef AbsmainHPP
#define AbsmainHPP

#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 <Db.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Dbcommon.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Sqltimst.hpp>	// Pascal unit
#include <Registry.hpp>	// Pascal unit
#include <Abslocalengine.hpp>	// Pascal unit
#include <Absbase.hpp>	// Pascal unit
#include <Absdlgwait.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abssecurity.hpp>	// Pascal unit
#include <Absvariant.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Abssqlprocessor.hpp>	// Pascal unit
#include <Abslexer.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit

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

namespace Absmain
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TABSEngineType { etLocal, etClient, etServer };
#pragma option pop

#pragma option push -b-
enum TCompressionAlgorithm { caNone, caZLIB, caBZIP, caPPM };
#pragma option pop

class DELPHICLASS EABSEngineError;
class PASCALIMPLEMENTATION EABSEngineError : public Db::EDatabaseError 
{
	typedef Db::EDatabaseError inherited;
	
private:
	int FErrorCode;
	AnsiString FErrorMessage;
	
public:
	__fastcall EABSEngineError(int ErrorCode, AnsiString ErrMessage);
	__property int ErrorCode = {read=FErrorCode, nodefault};
	__property AnsiString ErrorMessage = {read=FErrorMessage};
public:
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall EABSEngineError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size) : Db::EDatabaseError(Msg, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateRes */ inline __fastcall EABSEngineError(int Ident)/* overload */ : Db::EDatabaseError(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall EABSEngineError(int Ident, System::TVarRec const * Args, const int Args_Size)/* overload */ : Db::EDatabaseError(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall EABSEngineError(const AnsiString Msg, int AHelpContext) : Db::EDatabaseError(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall EABSEngineError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size, int AHelpContext) : Db::EDatabaseError(Msg, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall EABSEngineError(int Ident, int AHelpContext)/* overload */ : Db::EDatabaseError(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall EABSEngineError(System::PResStringRec ResStringRec, System::TVarRec const * Args, const int Args_Size, int AHelpContext)/* overload */ : Db::EDatabaseError(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~EABSEngineError(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSBLOBStream;
class DELPHICLASS TABSDataSet;
typedef Set<Shortint, 0, 15>  TABSDBFlags;

class DELPHICLASS TABSDatabase;
class DELPHICLASS TABSSession;
#pragma option push -b-
enum TABSDatabaseEvent { dbOpen, dbClose, dbAdd, dbRemove };
#pragma option pop

typedef void __fastcall (__closure *TABSDatabaseNotifyEvent)(TABSDatabaseEvent DBEvent, const void *Param);

class PASCALIMPLEMENTATION TABSSession : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Absbase::TABSSessionComponentManager* FHandle;
	Classes::TList* FDatabases;
	bool FStreamedActive;
	bool FKeepConnections;
	bool FDefault;
	bool FAutoSessionName;
	bool FUpdatingAutoSessionName;
	AnsiString FSessionName;
	int FSessionNumber;
	int FLockCount;
	TABSDatabaseNotifyEvent FOnDBNotify;
	Classes::TNotifyEvent FOnStartup;
	void __fastcall AddDatabase(TABSDatabase* Value);
	void __fastcall CheckInactive(void);
	void __fastcall DBNotification(TABSDatabaseEvent DBEvent, const void *Param);
	TABSDatabase* __fastcall DoFindDatabase(const AnsiString DatabaseName, Classes::TComponent* AOwner);
	TABSDatabase* __fastcall DoOpenDatabase(const AnsiString DatabaseName, Classes::TComponent* AOwner);
	Absbase::TABSBaseSession* __fastcall FindDatabaseHandle(const AnsiString DatabaseName);
	bool __fastcall GetActive(void);
	TABSDatabase* __fastcall GetDatabase(int Index);
	int __fastcall GetDatabaseCount(void);
	Absbase::TABSSessionComponentManager* __fastcall GetHandle(void);
	bool __fastcall SessionNameStored(void);
	void __fastcall MakeCurrent(void);
	void __fastcall RemoveDatabase(TABSDatabase* Value);
	void __fastcall SetActive(bool Value);
	void __fastcall SetAutoSessionName(bool Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall SetSessionNames(void);
	void __fastcall StartSession(bool Value);
	void __fastcall UpdateAutoSessionName(void);
	void __fastcall ValidateAutoSession(Classes::TComponent* AOwner, bool AllSessions);
	
protected:
	virtual void __fastcall Loaded(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	__property TABSDatabaseNotifyEvent OnDBNotify = {read=FOnDBNotify, write=FOnDBNotify};
	virtual void __fastcall SetName(const AnsiString NewName);
	
public:
	__fastcall virtual TABSSession(Classes::TComponent* AOwner);
	__fastcall virtual ~TABSSession(void);
	void __fastcall LockSession(void);
	void __fastcall UnlockSession(void);
	void __fastcall Close(void);
	void __fastcall CloseDatabase(TABSDatabase* Database);
	void __fastcall DropConnections(void);
	TABSDatabase* __fastcall FindDatabase(const AnsiString DatabaseName);
	void __fastcall GetDatabaseNames(Classes::TStrings* List);
	void __fastcall GetTableNames(const AnsiString DatabaseName, Classes::TStrings* List);
	void __fastcall Open(void);
	TABSDatabase* __fastcall OpenDatabase(const AnsiString DatabaseName);
	__property int DatabaseCount = {read=GetDatabaseCount, nodefault};
	__property TABSDatabase* Databases[int Index] = {read=GetDatabase};
	__property Absbase::TABSSessionComponentManager* Handle = {read=GetHandle};
	
__published:
	__property bool Active = {read=GetActive, write=SetActive, default=0};
	__property bool AutoSessionName = {read=FAutoSessionName, write=SetAutoSessionName, default=0};
	__property bool KeepConnections = {read=FKeepConnections, write=FKeepConnections, default=1};
	__property AnsiString SessionName = {read=FSessionName, write=SetSessionName, stored=SessionNameStored};
	__property Classes::TNotifyEvent OnStartup = {read=FOnStartup, write=FOnStartup};
};


typedef void __fastcall (__closure *TABSPasswordEvent)(System::TObject* Sender, bool &Continue);

typedef void __fastcall (__closure *TABSProgressEvent)(System::TObject* Sender, int PercentDone, bool &Continue);

typedef void __fastcall (__closure *TABSOnNeedRepairEvent)(System::TObject* Sender, bool &DoRepair);

class PASCALIMPLEMENTATION TABSDatabase : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	AnsiString FCurrentVersion;
	Classes::TList* FDataSets;
	bool FKeepConnection;
	bool FTemporary;
	bool FStreamedConnected;
	bool FAcquiredHandle;
	bool FHandleShared;
	bool FReadOnly;
	bool FExclusive;
	int FRefCount;
	Absbase::TABSBaseSession* FHandle;
	TABSSession* FSession;
	AnsiString FSessionName;
	AnsiString FDatabaseName;
	AnsiString FDatabaseFileName;
	AnsiString FPassword;
	Abssecurity::TABSCryptoAlgorithm FCryptoAlgorithm;
	int FPageSize;
	int FPageCountInExtent;
	bool FNoRequestAutoRepair;
	bool FSilentMode;
	bool FMultiUser;
	int FMaxConnections;
	bool FDisableTempFiles;
	TABSPasswordEvent FOnPassword;
	Classes::TNotifyEvent FBeforeRepair;
	TABSProgressEvent FOnRepairProgress;
	Classes::TNotifyEvent FAfterRepair;
	Classes::TNotifyEvent FBeforeCompact;
	TABSProgressEvent FOnCompactProgress;
	Classes::TNotifyEvent FAfterCompact;
	Classes::TNotifyEvent FBeforeChangePassword;
	TABSProgressEvent FOnChangePasswordProgress;
	Classes::TNotifyEvent FAfterChangePassword;
	Classes::TNotifyEvent FAfterChangeDatabaseSettings;
	TABSProgressEvent FOnChangeDatabaseSettingsProgress;
	Classes::TNotifyEvent FBeforeChangeDatabaseSettings;
	TABSOnNeedRepairEvent FOnNeedRepair;
	Absdlgwait::TfrmWait* frmWait;
	void __fastcall CheckActive(void);
	void __fastcall CheckInactive(void);
	void __fastcall CheckDatabaseName(void);
	void __fastcall CheckSessionName(bool Required);
	void __fastcall CheckConnected(void);
	bool __fastcall GetConnected(void);
	TABSDataSet* __fastcall GetDataSet(int Index);
	int __fastcall GetDataSetCount(void);
	bool __fastcall OpenFromExistingDB(void);
	void __fastcall SetDatabaseFileName(AnsiString Value);
	void __fastcall SetDatabaseName(AnsiString Value);
	void __fastcall SetHandle(Absbase::TABSBaseSession* Value);
	void __fastcall SetKeepConnection(bool Value);
	void __fastcall SetReadOnly(bool Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall SetConnected(bool value);
	bool __fastcall GetExists(void);
	void __fastcall CreateHandle(void);
	void __fastcall DestroyHandle(void);
	bool __fastcall GetPassword(void);
	bool __fastcall GetInTransaction(void);
	AnsiString __fastcall GetCurrentVersion();
	void __fastcall DoOnNeedRepair(bool &DoRepair);
	void __fastcall DoOnNeedConvert(bool &DoRepair);
	bool __fastcall InternalCopyDatabase(AnsiString NewDatabaseFileName, AnsiString &Log, bool IgnoreErrors = false, AnsiString NewPassword = "", Abssecurity::TABSCryptoAlgorithm NewCryptoAlgorithm = (Abssecurity::TABSCryptoAlgorithm)(0x0), int NewPageSize = 0x1000, int NewPageCountInExtent = 0x8, int NewMaxConnections = 0x1f4, Classes::TNotifyEvent BeforeEvent = 0x0, TABSProgressEvent ProgressEvent = 0x0, Classes::TNotifyEvent AfterEvent = 0x0);
	void __fastcall EmptyEvent(System::TObject* Sender);
	void __fastcall InternalBeforeRepair(System::TObject* Sender);
	void __fastcall InternalOnRepairProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterRepair(System::TObject* Sender);
	void __fastcall InternalBeforeCompact(System::TObject* Sender);
	void __fastcall InternalOnCompactProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterCompact(System::TObject* Sender);
	void __fastcall InternalBeforeChangePassword(System::TObject* Sender);
	void __fastcall InternalOnChangePasswordProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterChangePassword(System::TObject* Sender);
	void __fastcall InternalBeforeChangeDatabaseSettings(System::TObject* Sender);
	void __fastcall InternalOnChangeDatabaseSettingsProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterChangeDatabaseSettings(System::TObject* Sender);
	
protected:
	virtual void __fastcall Loaded(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	
public:
	__fastcall virtual TABSDatabase(Classes::TComponent* AOwner);
	__fastcall virtual ~TABSDatabase(void);
	void __fastcall Open(void);
	void __fastcall Close(void);
	void __fastcall CreateDatabase(void);
	void __fastcall DeleteDatabase(void);
	void __fastcall RenameDatabase(AnsiString NewDatabaseFileName);
	bool __fastcall CompactDatabase(AnsiString NewDatabaseFileName)/* overload */;
	bool __fastcall CompactDatabase(void)/* overload */;
	void __fastcall TruncateDatabase(void);
	AnsiString __fastcall RepairDatabase()/* overload */;
	bool __fastcall RepairDatabase(AnsiString NewDatabaseFileName, AnsiString &Log)/* overload */;