abstempengine.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) 'Abstempengine.pas' rev: 10.00

#ifndef AbstempengineHPP
#define AbstempengineHPP

#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 <Absexcept.hpp>	// Pascal unit
#include <Absbase.hpp>	// Pascal unit
#include <Abspage.hpp>	// Pascal unit
#include <Absbaseengine.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abssecurity.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit

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

namespace Abstempengine
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSTemporaryRecordManager;
class PASCALIMPLEMENTATION TABSTemporaryRecordManager : public Absbaseengine::TABSBaseRecordManager 
{
	typedef Absbaseengine::TABSBaseRecordManager inherited;
	
private:
	int FRecordsPerPage;
	int FPageSize;
	int FCachedRecordCount;
	char *FCache;
	int FAllocatedRecordCount;
	char *FTempPage;
	int FTempPageRecordCount;
	Abscompression::TABSFileStream* FTempPageFile;
	int FMaxCachedRecordCount;
	int FAllocRecordsBy;
	bool FDisableTempFiles;
	void __fastcall SaveTempPage(void);
	bool __fastcall ReadRecord(char * &RecordBuffer, __int64 RecordID);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromFirstPosition(Abstypes::TABSGetRecordMode GetRecordMode, __int64 &RecordID);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromLastPosition(Abstypes::TABSGetRecordMode GetRecordMode, __int64 &RecordID);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromAnyPosition(Abstypes::TABSGetRecordMode GetRecordMode, __int64 &RecordID);
	
public:
	__fastcall TABSTemporaryRecordManager(int RecordBufferSize, int RecordsPerPage, int AllocRecordsBy, bool DisableTempFiles);
	__fastcall virtual ~TABSTemporaryRecordManager(void);
	virtual void __fastcall Empty(int SessionID);
	virtual bool __fastcall AddRecord(int SessionID, char * RecordBuffer, Abstypes::TABSPageItemID &RecordID);
	virtual bool __fastcall UpdateRecord(int SessionID, char * RecordBuffer, const Abstypes::TABSPageItemID &RecordID);
	virtual bool __fastcall DeleteRecord(int SessionID, Abstypes::TABSPageItemID &RecordID);
	virtual void __fastcall GetRecordBuffer(int SessionID, Abstypes::TABSNavigationInfo &NavigationInfo);
	virtual int __fastcall CompareRecordID(const Abstypes::TABSPageItemID &RecordID1, const Abstypes::TABSPageItemID &RecordID2);
	virtual __int64 __fastcall GetApproximateRecNo(int SessionID, const Abstypes::TABSPageItemID &RecordID);
};


class DELPHICLASS TABSTemporaryPageManager;
class PASCALIMPLEMENTATION TABSTemporaryPageManager : public Abspage::TABSPageManager 
{
	typedef Abspage::TABSPageManager inherited;
	
protected:
	Abstypes::TABSBitsArray* FAllocatedPageMap;
	int FAllocatedPageCount;
	Abscompression::TABSFileStream* FTempPageFile;
	int FMaxMemoryPageCount;
	Abspage::TABSPageManager* FMemoryPageManager;
	bool FDisableTempFiles;
	
public:
	virtual void __fastcall InternalAddPage(Abspage::TABSPage* aPage);
	virtual void __fastcall InternalRemovePage(int PageNo);
	virtual bool __fastcall InternalReadPage(Abspage::TABSPage* aPage);
	virtual void __fastcall InternalWritePage(Abspage::TABSPage* aPage);
	__fastcall TABSTemporaryPageManager(bool DisableTempFiles);
	__fastcall virtual ~TABSTemporaryPageManager(void);
};


class DELPHICLASS TABSTemporaryDatabaseData;
class PASCALIMPLEMENTATION TABSTemporaryDatabaseData : public Absbaseengine::TABSDatabaseData 
{
	typedef Absbaseengine::TABSDatabaseData inherited;
	
private:
	int FLastObjectID;
	
public:
	__fastcall TABSTemporaryDatabaseData(void);
	__fastcall virtual ~TABSTemporaryDatabaseData(void);
	virtual Absbaseengine::TABSTableData* __fastcall CreateTableData(Absbase::TABSCursor* Cursor);
	virtual int __fastcall GetNewObjectId(void);
};


class DELPHICLASS TABSTemporaryTableData;
class PASCALIMPLEMENTATION TABSTemporaryTableData : public Absbaseengine::TABSTableData 
{
	typedef Absbaseengine::TABSTableData inherited;
	
private:
	Abscompression::TABSStream* FBLOBFile;
	int FRecordsPerPage;
	int FAllocRecordsBy;
	
protected:
	virtual void __fastcall CreateRecordManager(void);
	virtual void __fastcall CreateFieldManager(Absbase::TABSFieldDefs* FieldDefs);
	virtual void __fastcall CreateIndexManager(Absbase::TABSIndexDefs* IndexDefs);
	virtual void __fastcall CreateConstraintManager(Absbase::TABSConstraintDefs* ConstraintDefs);
	void __fastcall CreateBLOBFile(void);
	void __fastcall DeleteBLOBFile(void);
	virtual __int64 __fastcall GetBitmapRecordCount(int SessionID);
	virtual __int64 __fastcall GetBitmapRecNoByRecordID(const Abstypes::TABSPageItemID &RecordID);
	virtual Abstypes::TABSPageItemID __fastcall GetRecordIDByBitmapRecNo(__int64 RecordNo);
	
public:
	__fastcall TABSTemporaryTableData(Absbaseengine::TABSDatabaseData* aDatabaseData, int RecordsPerPage, int AllocRecordsBy);
	__fastcall virtual ~TABSTemporaryTableData(void);
	virtual void __fastcall CreateTable(Absbase::TABSCursor* Cursor, Absbase::TABSFieldDefs* FieldDefs, Absbase::TABSIndexDefs* IndexDefs, Absbase::TABSConstraintDefs* ConstraintDefs);
	virtual void __fastcall DeleteTable(Absbase::TABSCursor* Cursor, bool DesignMode = false);
	virtual void __fastcall EmptyTable(Absbase::TABSCursor* Cursor);
	virtual void __fastcall OpenTable(Absbase::TABSCursor* Cursor);
	virtual void __fastcall CloseTable(Absbase::TABSCursor* Cursor);
	virtual void __fastcall AddIndex(Absbase::TABSIndexDef* IndexDef, Absbase::TABSCursor* Cursor);
	virtual void __fastcall DeleteIndex(int IndexID, Absbase::TABSCursor* Cursor);
	virtual bool __fastcall InsertRecord(Absbase::TABSCursor* &Cursor);
	virtual bool __fastcall DeleteRecord(Absbase::TABSCursor* Cursor);
	virtual bool __fastcall UpdateRecord(Absbase::TABSCursor* Cursor);
	virtual __int64 __fastcall InternalGetRecordCount(Absbase::TABSCursor* Cursor);
	virtual void __fastcall InternalSetRecNo(Absbase::TABSCursor* Cursor, __int64 RecNo);
	virtual __int64 __fastcall InternalGetRecNo(Absbase::TABSCursor* Cursor);
	virtual void __fastcall WriteBLOBFieldToRecordBuffer(Absbase::TABSCursor* Cursor, int FieldNo, Abscompression::TABSStream* BLOBStream);
	virtual Abscompression::TABSStream* __fastcall InternalCreateBlobStream(Absbase::TABSCursor* Cursor, bool ToInsert, int FieldNo, Abstypes::TABSBLOBOpenMode OpenMode);
	virtual void __fastcall GetDirectBlobData(Absbase::TABSCursor* Cursor, int FieldNo, char * RecordBuffer, Abstypes::TABSPartialTemporaryBLOBDescriptor &BLOBDescriptor, char * &pBlobData);
	virtual void __fastcall SetDirectBlobData(Absbase::TABSCursor* Cursor, int FieldNo, char * RecordBuffer, Abstypes::TABSPartialTemporaryBLOBDescriptor &BLOBDescriptor, char * &pBlobData);
	virtual void __fastcall FreeDirectBlobData(Absbase::TABSCursor* Cursor, int FieldNo, char * RecordBuffer, Abstypes::TABSPartialTemporaryBLOBDescriptor &BLOBDescriptor, char * &pBlobData);
};


//-- var, const, procedure ---------------------------------------------------

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

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