abslocalengine.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) 'Abslocalengine.pas' rev: 10.00

#ifndef AbslocalengineHPP
#define AbslocalengineHPP

#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 <Absrelationalalgebra.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Absbase.hpp>	// Pascal unit
#include <Absbaseengine.hpp>	// Pascal unit
#include <Absmemengine.hpp>	// Pascal unit
#include <Abstempengine.hpp>	// Pascal unit
#include <Absdiskengine.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Absvariant.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abssecurity.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Abssqlprocessor.hpp>	// Pascal unit
#include <Absexpressions.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit

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

namespace Abslocalengine
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSLocalBLOBStream;
class PASCALIMPLEMENTATION TABSLocalBLOBStream : public Abscompression::TABSStream 
{
	typedef Abscompression::TABSStream inherited;
	
private:
	Abstypes::TABSBLOBOpenMode FOpenMode;
	Abscompression::TABSStream* FTemporaryStream;
	Abscompression::TABSStream* FUserBLOBStream;
	int FFieldNo;
	Absbase::TABSCursor* FCursor;
	__int64 FPosition;
	
protected:
	void __fastcall InternalSetSize(const __int64 NewSize);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	
public:
	virtual int __fastcall Read(void *Buffer, int Count);
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, Classes::TSeekOrigin Origin)/* overload */;
	__fastcall TABSLocalBLOBStream(Abscompression::TABSStream* TemporaryStream, Absbase::TABSCursor* Cursor, Abstypes::TABSBLOBOpenMode OpenMode, int FieldNo);
	__fastcall virtual ~TABSLocalBLOBStream(void);
	__property Absbase::TABSCursor* Cursor = {read=FCursor};
	__property int FieldNo = {read=FFieldNo, nodefault};
	__property Abstypes::TABSBLOBOpenMode OpenMode = {read=FOpenMode, write=FOpenMode, nodefault};
	__property Abscompression::TABSStream* TemporaryStream = {read=FTemporaryStream, write=FTemporaryStream};
	__property Abscompression::TABSStream* UserBLOBStream = {read=FUserBLOBStream, write=FUserBLOBStream};
};


class DELPHICLASS TABSLocalSQLProcessor;
class PASCALIMPLEMENTATION TABSLocalSQLProcessor : public Abssqlprocessor::TABSSQLProcessor 
{
	typedef Abssqlprocessor::TABSSQLProcessor inherited;
	
public:
	#pragma option push -w-inl
	/* TABSSQLProcessor.Create */ inline __fastcall TABSLocalSQLProcessor(Db::TDataSet* Query) : Abssqlprocessor::TABSSQLProcessor(Query) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSSQLProcessor.Destroy */ inline __fastcall virtual ~TABSLocalSQLProcessor(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSLocalCursor;
class PASCALIMPLEMENTATION TABSLocalCursor : public Absbase::TABSCursor 
{
	typedef Absbase::TABSCursor inherited;
	
private:
	Absbaseengine::TABSTableData* FTableData;
	Absbaseengine::TABSDatabaseData* FDatabaseData;
	
public:
	__fastcall TABSLocalCursor(void);
	__fastcall virtual ~TABSLocalCursor(void);
	virtual void __fastcall CreateTable(Absbase::TABSFieldDefs* FieldDefs, Absbase::TABSIndexDefs* IndexDefs, Absbase::TABSConstraintDefs* ConstraintDefs);
	virtual void __fastcall DeleteTable(void);
	virtual void __fastcall EmptyTable(void);
	virtual void __fastcall RenameTable(AnsiString NewTableName);
	virtual void __fastcall InternalInitFieldDefs(void);
	virtual void __fastcall OpenTableByFieldDefs(Absbase::TABSFieldDefs* FieldDefs, Absbase::TABSIndexDefs* IndexDefs, Absbase::TABSConstraintDefs* ConstraintDefs);
	void __fastcall OpenTable(Absbaseengine::TABSTableData* aTableData);
	virtual void __fastcall CloseTable(void);
	virtual void __fastcall LockTableData(void);
	virtual void __fastcall UnlockTableData(void);
	virtual bool __fastcall LockTable(Abstypes::TABSLockType LockType, int TryCount, int Delay, bool AllowXIRWAfterSIRW = true);
	virtual bool __fastcall UnlockTable(Abstypes::TABSLockType LockType, bool IgnoreIfNoLock = false);
	virtual void __fastcall InternalInitRecord(char * RecordBuffer, bool InsertMode);
	virtual void __fastcall RenameField(AnsiString FieldName, AnsiString NewFieldName);
	virtual void __fastcall CopyFieldValue(int SrcFieldNo, bool DirectAccess, int DestFieldNo, Absbase::TABSCursor* DestCursor);
	virtual Absbase::TABSIndexDefs* __fastcall GetIndexDefs(void);
	virtual void __fastcall AddIndex(Absbase::TABSIndexDef* IndexDef);
	virtual void __fastcall DeleteIndex(AnsiString Name);
	virtual void __fastcall DeleteAllIndexes(void);
	virtual AnsiString __fastcall FindOrCreateIndex(Classes::TStringList* FieldNamesList, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList, bool &IsCreated);
	virtual bool __fastcall IndexExists(Classes::TStringList* FieldNamesList, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList);
	virtual void __fastcall FreeRecordBuffer(char * &Buffer);
	virtual Abstypes::TABSGetRecordResult __fastcall GetRecordBuffer(Abstypes::TABSGetRecordMode GetRecordMode);
	virtual __int64 __fastcall GetRecordCount(void);
	virtual void __fastcall SetRecNo(__int64 Value);
	virtual __int64 __fastcall GetRecNo(void);
	virtual void __fastcall InternalFirst(void);
	virtual void __fastcall InternalLast(void);
	virtual void __fastcall InternalInsert(void);
	virtual void __fastcall InternalEdit(void);
	virtual void __fastcall InternalCancel(bool ToInsert);
	virtual void __fastcall InternalPost(bool ToInsert);
	virtual void __fastcall InternalDelete(void);
	virtual void __fastcall ApplyDistinct(Classes::TStringList* FieldNamesList, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList);
	virtual void __fastcall ActivateFilters(AnsiString FilterText, bool CaseInsensitive, bool PartialKey);
	virtual void __fastcall DeactivateFilters(void);
	virtual bool __fastcall Locate(const AnsiString KeyFields, const Variant &KeyValues, bool CaseInsensitive, bool PartialKey);
	virtual bool __fastcall FindKey(Abstypes::TABSSearchCondition SearchCondition);
	virtual bool __fastcall IsAnyRecordMatchCondition(const AnsiString FieldName, const Abstypes::TABSDataOperator Operator, const Absvariant::TABSVariant* Value);
	virtual Abscompression::TABSStream* __fastcall InternalCreateBlobStream(bool ToInsert, bool ToEdit, int FieldNo, Abstypes::TABSBLOBOpenMode OpenMode, bool CanDoGetRecordBuffer);
	virtual void __fastcall InternalCloseBLOB(int FieldNo);
	virtual void __fastcall ClearBLOBStreams(bool WriteOnly = false);
	virtual __int64 __fastcall LastAutoincValue(int FieldNo);
	virtual void __fastcall BeginBatchUpdate(void);
	virtual void __fastcall EndBatchUpdate(void);
	virtual void __fastcall CancelBatchUpdate(void);
	virtual bool __fastcall CheckConstraints(bool ToInsert);
	__property Absbaseengine::TABSTableData* TableData = {read=FTableData};
	__property Absbaseengine::TABSDatabaseData* DatabaseData = {read=FDatabaseData};
};


class DELPHICLASS TABSLocalSession;
class PASCALIMPLEMENTATION TABSLocalSession : public Absbase::TABSBaseSession 
{
	typedef Absbase::TABSBaseSession inherited;
	
private:
	Absbaseengine::TABSDatabaseData* FDatabaseData;
	Abssecurity::TABSPassword FPassword;
	int FPageSize;
	int FPageCountInExtent;
	Abssecurity::PABSPassword __fastcall GetPassword(void);
	bool __fastcall IsAppropriateDatabaseData(Absbaseengine::TABSDatabaseData* DBData);
	Absbaseengine::TABSDatabaseData* __fastcall FindDatabaseData(void);
	Absbaseengine::TABSDatabaseData* __fastcall CreateDatabaseData(void);
	Absbaseengine::TABSDatabaseData* __fastcall FindOrCreateDatabaseData(void);
	
protected:
	virtual bool __fastcall GetConnected(void);
	virtual void __fastcall SetConnected(bool Value);
	virtual bool __fastcall GetSuppressDBHeaderErrors(void);
	virtual void __fastcall SetSuppressDBHeaderErrors(bool Value);
	
public:
	virtual void __fastcall CreateDatabase(void);
	void __fastcall TruncateDatabase(void);
	int __fastcall GetDBFileConnectionsCount(void);
	virtual void __fastcall DeleteDatabase(void);
	virtual void __fastcall RenameDatabase(AnsiString NewDatabaseFileName);
	virtual void __fastcall GetTablesList(Classes::TStrings* List);
	virtual bool __fastcall TableExists(AnsiString TableName);
	virtual void __fastcall StartTransaction(void);
	virtual void __fastcall Commit(bool DoFlushBuffers = true);
	virtual void __fastcall Rollback(void);
	virtual void __fastcall FlushBuffers(void);
	__property Absbaseengine::TABSDatabaseData* DatabaseData = {read=FDatabaseData};
	__property Abssecurity::PABSPassword Password = {read=GetPassword};
	__property int PageSize = {read=FPageSize, write=FPageSize, nodefault};
	__property int PageCountInExtent = {read=FPageCountInExtent, write=FPageCountInExtent, nodefault};
public:
	#pragma option push -w-inl
	/* TABSBaseSession.Create */ inline __fastcall TABSLocalSession(void) : Absbase::TABSBaseSession() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSBaseSession.Destroy */ inline __fastcall virtual ~TABSLocalSession(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE Classes::TThreadList* DBDataList;

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

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