abspage.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) 'Abspage.pas' rev: 10.00

#ifndef AbspageHPP
#define AbspageHPP

#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 <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit

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

namespace Abspage
{
//-- type declarations -------------------------------------------------------
#pragma pack(push,1)
struct TABSPageTableStateInfo
{
	
public:
	int TableState;
	bool IsTableStateValueAssigned;
} ;
#pragma pack(pop)

typedef DynamicArray<TABSPageTableStateInfo >  ABSPage__2;

class DELPHICLASS TABSPage;
class DELPHICLASS TABSPageManager;
class DELPHICLASS TABSSortedPageList;
struct TABSPageElement; struct TABSSessionPageInfo;
class PASCALIMPLEMENTATION TABSSortedPageList : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	DynamicArray<int >  KeyItems;
	int ItemCount;
	int AllocBy;
	int deAllocBy;
	int MaxAllocBy;
	int AllocItemCount;
	__int64 LRUCount;
	int LRULastFound;
	int __fastcall FindPositionForInsert(int key);
	int __fastcall FindPosition(int key);
	void __fastcall InsertByPosition(int ItemNo, int key, TABSPageElement &value);
	void __fastcall DeleteByPosition(int ItemNo);
	
public:
	DynamicArray<TABSPageElement >  ValueItems;
	__fastcall TABSSortedPageList(int size);
	void __fastcall SetSize(int newSize);
	TABSPage* __fastcall Find(int key);
	void __fastcall Insert(TABSPage* Page);
	void __fastcall Delete(int PageNo);
	void __fastcall Clear(void);
	TABSPage* __fastcall FirstByLRU(void);
	TABSPage* __fastcall NextByLRU(void);
	void __fastcall UpdateLRU(TABSPage* Page);
	__property int Count = {read=ItemCount, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSortedPageList(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TABSPageManager : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	_RTL_CRITICAL_SECTION FCSect;
	int FCacheCapacity;
	TABSSortedPageList* FSharedPages;
	DynamicArray<TABSSessionPageInfo >  FSessions;
	Word FPageSize;
	Word FPageHeaderSize;
	Word FPageDataSize;
	int FPageCount;
	bool FMultiUser;
	void __fastcall Lock(void);
	void __fastcall Unlock(void);
	int __fastcall AddNewSession(int SessionID);
	bool __fastcall FindSession(int SessionID, int &SessionNo);
	bool __fastcall FindPage(TABSSortedPageList* Pages, int PageNo, TABSPage* &Page);
	void __fastcall RemovePageIfExists(TABSSortedPageList* Pages, int PageNo);
	virtual int __fastcall GetPageCount(void);
	virtual bool __fastcall IsSafeNotToSyncPage(int SessionID, TABSPage* Page);
	virtual void __fastcall UpdatePageTableState(int SessionID, TABSPage* Page);
	
public:
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	virtual void __fastcall InternalAddPage(TABSPage* aPage) = 0 ;
	virtual void __fastcall InternalRemovePage(int PageNo) = 0 ;
	virtual bool __fastcall InternalReadPage(TABSPage* aPage) = 0 ;
	virtual void __fastcall InternalWritePage(TABSPage* aPage) = 0 ;
	__fastcall TABSPageManager(void);
	__fastcall virtual ~TABSPageManager(void);
	TABSPage* __fastcall AddPage(int SessionID, Word PageType);
	virtual void __fastcall RemovePage(int SessionID, int PageNo);
	virtual TABSPage* __fastcall GetPage(int SessionID, int PageNo, Word PageType, bool SynchronizeAllowed = true);
	void __fastcall PutPage(TABSPage* aPage);
	virtual void __fastcall ApplyChanges(int SessionID);
	void __fastcall CancelChanges(int SessionID);
	__property Word PageSize = {read=FPageSize, nodefault};
	__property Word PageHeaderSize = {read=FPageHeaderSize, nodefault};
	__property Word PageDataSize = {read=FPageDataSize, nodefault};
	__property int PageCount = {read=GetPageCount, nodefault};
	__property bool MultiUser = {read=FMultiUser, write=FMultiUser, nodefault};
};


class PASCALIMPLEMENTATION TABSPage : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TABSPageManager* LPageManager;
	int FPageNo;
	char *FPageBuffer;
	bool FOwnBuffer;
	bool FIsDirty;
	int FUseCount;
	TABSSortedPageList* FParentList;
	int FSessionID;
	bool FReloaded;
	bool FEncryptionEnabled;
	DynamicArray<TABSPageTableStateInfo >  FTableStates;
	Abstypes::PABSDiskPageHeader __fastcall GetPageHeader(void);
	int __fastcall GetPageHeaderSize(void);
	char * __fastcall GetPageData(void);
	int __fastcall GetPageDataSize(void);
	int __fastcall GetPageSize(void);
	void __fastcall InitHeader(void);
	
public:
	__fastcall TABSPage(TABSPageManager* PageManager);
	__fastcall virtual ~TABSPage(void);
	void __fastcall ClearPageBuffer(void);
	void __fastcall AllocPageBuffer(void);
	void __fastcall FreeAndNilPageBuffer(void);
	void __fastcall EnlargePageBuffer(int NewSize);
	void __fastcall Synchronize(void);
	bool __fastcall GetTableState(int SessionID, int &TableState);
	void __fastcall SetTableState(int SessionID, int TableState);
	__property int PageNo = {read=FPageNo, write=FPageNo, nodefault};
	__property int PageSize = {read=GetPageSize, nodefault};
	__property char * PageBuffer = {read=FPageBuffer, write=FPageBuffer};
	__property bool OwnBuffer = {read=FOwnBuffer, write=FOwnBuffer, nodefault};
	__property bool IsDirty = {read=FIsDirty, write=FIsDirty, nodefault};
	__property int UseCount = {read=FUseCount, write=FUseCount, nodefault};
	__property TABSPageManager* PageManager = {read=LPageManager, write=LPageManager};
	__property Abstypes::PABSDiskPageHeader PageHeader = {read=GetPageHeader};
	__property int PageHeaderSize = {read=GetPageHeaderSize, nodefault};
	__property char * PageData = {read=GetPageData};
	__property int PageDataSize = {read=GetPageDataSize, nodefault};
	__property TABSSortedPageList* ParentList = {read=FParentList, write=FParentList};
	__property int SessionID = {read=FSessionID, write=FSessionID, nodefault};
	__property bool Reloaded = {read=FReloaded, write=FReloaded, nodefault};
	__property bool EncryptionEnabled = {read=FEncryptionEnabled, write=FEncryptionEnabled, nodefault};
};


class DELPHICLASS TABSPageController;
class PASCALIMPLEMENTATION TABSPageController : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TABSPage* LPage;
	
protected:
	void __fastcall SetPageNo(int Value);
	int __fastcall GetPageNo(void);
	int __fastcall GetPageSize(void);
	void __fastcall SetPageBuffer(char * Value);
	char * __fastcall GetPageBuffer(void);
	void __fastcall SetOwnBuffer(bool Value);
	bool __fastcall GetOwnBuffer(void);
	void __fastcall SetIsDirty(bool Value);
	bool __fastcall GetIsDirty(void);
	void __fastcall SetUseCount(int Value);
	int __fastcall GetUseCount(void);
	TABSPageManager* __fastcall GetPageManager(void);
	char * __fastcall GetPageData(void);
	int __fastcall GetPageDataSize(void);
	
public:
	void __fastcall EnlargePageBuffer(int NewSize);
	__property TABSPage* Page = {read=LPage, write=LPage};
	__property int PageNo = {read=GetPageNo, write=SetPageNo, nodefault};
	__property int PageSize = {read=GetPageSize, nodefault};
	__property char * PageBuffer = {read=GetPageBuffer, write=SetPageBuffer};
	__property bool OwnBuffer = {read=GetOwnBuffer, write=SetOwnBuffer, nodefault};
	__property bool IsDirty = {read=GetIsDirty, write=SetIsDirty, nodefault};
	__property int UseCount = {read=GetUseCount, write=SetUseCount, nodefault};
	__property TABSPageManager* PageManager = {read=GetPageManager};
	__property char * PageData = {read=GetPageData};
	__property int PageDataSize = {read=GetPageDataSize, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TABSPageController(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSPageController(void) { }
	#pragma option pop
	
};


struct TABSPageElement
{
	
public:
	TABSPage* Page;
	__int64 LRUCount;
} ;

typedef DynamicArray<int >  ABSPage__5;

typedef DynamicArray<TABSPageElement >  ABSPage__6;

struct TABSSessionPageInfo
{
	
public:
	int SessionID;
	TABSSortedPageList* DirtyPages;
	Abstypes::TABSIntegerArray* AddedPageNumbers;
	Abstypes::TABSIntegerArray* RemovedPageNumbers;
} ;

typedef DynamicArray<TABSSessionPageInfo >  ABSPage__8;

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

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

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