absmemengine.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) 'Absmemengine.pas' rev: 10.00

#ifndef AbsmemengineHPP
#define AbsmemengineHPP

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

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

namespace Absmemengine
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSMemoryDatabaseData;
class PASCALIMPLEMENTATION TABSMemoryDatabaseData : public Absbaseengine::TABSDatabaseData 
{
	typedef Absbaseengine::TABSDatabaseData inherited;
	
private:
	int FLastObjectID;
	
public:
	__fastcall TABSMemoryDatabaseData(void);
	__fastcall virtual ~TABSMemoryDatabaseData(void);
	virtual Absbaseengine::TABSTableData* __fastcall CreateTableData(Absbase::TABSCursor* Cursor);
	virtual void __fastcall ConnectSession(Absbase::TABSBaseSession* Session);
	virtual int __fastcall GetNewObjectId(void);
};


class DELPHICLASS TABSMemoryRecordManager;
class PASCALIMPLEMENTATION TABSMemoryRecordManager : public Absbaseengine::TABSBaseRecordManager 
{
	typedef Absbaseengine::TABSBaseRecordManager inherited;
	
private:
	char *FRecordBuffer;
	char *FDeleteFlagBuffer;
	int FAllocatedRecordCount;
	int FAllocRecordsBy;
	int FFirstRecordID;
	int FLastRecordID;
	Byte FBitsTable[256];
	Byte FNoRecordsDeleted;
	__int64 __fastcall FindRecord(__int64 RecordNo);
	__int64 __fastcall GetTablePositionByRecordID(__int64 RecordNo);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromFirstPosition(Abstypes::TABSGetRecordMode GetRecordMode, int &RecordID);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromLastPosition(Abstypes::TABSGetRecordMode GetRecordMode, int &RecordID);
	Abstypes::TABSGetRecordResult __fastcall GetRecordFromAnyPosition(Abstypes::TABSGetRecordMode GetRecordMode, int &RecordID);
	
protected:
	void __fastcall SetRecordCount(int NewRecordCount);
	
public:
	__fastcall TABSMemoryRecordManager(int RecordBufferSize, int AllocRecordsBy);
	__fastcall virtual ~TABSMemoryRecordManager(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 TABSMemoryTableData;
class PASCALIMPLEMENTATION TABSMemoryTableData : public Absbaseengine::TABSTableData 
{
	typedef Absbaseengine::TABSTableData inherited;
	
private:
	int FLoadedRecordCount;
	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 LoadTableHeader(Classes::TStream* Stream, Abstypes::TABSBLOBDescriptor &BLOBDescriptor);
	void __fastcall SaveTableHeader(Classes::TStream* Stream, Abstypes::TABSBLOBDescriptor &BLOBDescriptor);
	void __fastcall LoadBLOBDataFromStream(char * RecordBuffer, int FieldNo, Classes::TStream* Stream);
	void __fastcall LoadRecordFromStream(char * RecordBuffer, Classes::TStream* Stream);
	void __fastcall PrepareRecordBufferForSave(char * RecordBuffer, Classes::TList* BLOBDescriptorList, Classes::TList* BLOBDataList, __int64 BLOBPosition);
	void __fastcall SaveRecordToStream(char * RecordBuffer, Classes::TStream* Stream);
	virtual __int64 __fastcall GetBitmapRecordCount(int SessionID);
	virtual __int64 __fastcall GetBitmapRecNoByRecordID(const Abstypes::TABSPageItemID &RecordID);
	virtual Abstypes::TABSPageItemID __fastcall GetRecordIDByBitmapRecNo(__int64 RecordNo);
	
public:
	__fastcall TABSMemoryTableData(Absbaseengine::TABSDatabaseData* aDatabaseData, int AllocRecordsBy);
	__fastcall virtual ~TABSMemoryTableData(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 void __fastcall WriteBLOBFieldToRecordBuffer(Absbase::TABSCursor* Cursor, int FieldNo, Abscompression::TABSStream* BLOBStream);
	virtual void __fastcall ClearBLOBFieldInRecordBuffer(char * RecordBuffer, int FieldNo);
	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);
	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 __int64 __fastcall LastAutoincValue(int FieldNo, Absbase::TABSBaseSession* Session);
};


typedef DynamicArray<char * >  ABSMemEngine__5;

class DELPHICLASS TABSMemoryPageManager;
class PASCALIMPLEMENTATION TABSMemoryPageManager : public Abspage::TABSPageManager 
{
	typedef Abspage::TABSPageManager inherited;
	
protected:
	Abstypes::TABSBitsArray* FAllocatedPageMap;
	int FAllocatedPageCount;
	int FAllocateBy;
	int LastAllocatedPageNo;
	DynamicArray<char * >  FDataPtrs;
	
public:
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	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 TABSMemoryPageManager(void);
	__fastcall virtual ~TABSMemoryPageManager(void);
};


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

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

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