property Position: Int64 read GetPosition write SetPosition;
  end;// TMYLDBDatabaseFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDatabaseFreeSpaceManager
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBDatabaseFreeSpaceManager = class(TObject)
   private
    LPageManager: TMYLDBDiskPageManager;

    FPageCountInExtent:         Integer;
    FPFSPage_PagesAddressed:    Integer;  // count of pages addressed by PFSPage
    FEAMPage_ExtentsAddressed:  Integer;  // count of extents addressed by EAMPage
    FEAMPage_PagesAddressed:    Integer;  // count of pages addressed by EAMPage

    FLastUsedPageNo:            TMYLDBPageNo;
    FTotalPageCount:            TMYLDBPageNo;
    FSuppressDBHeaderErrors:    Boolean;

    function GetAddPagesStep: Integer;
    function GetDelPagesStep: Integer;

    function NewPage(PageNo: TMYLDBPageNo): TMYLDBPage;
    function ReadPage(PageNo: TMYLDBPageNo): TMYLDBPage;
    procedure WriteAndFreePage(var Page: TMYLDBPage);


    function CorrectEamPageNo(EamPageNo: TMYLDBPageNo): TMYLDBPageNo;
    function UncorrectEamPageNo(EamPageNo: TMYLDBPageNo): TMYLDBPageNo;
    function EamPageNoForEamPagePosition(EamPagePosition: Integer): TMYLDBPageNo;
    function EamPageNoToEamPagePosition(EamPageNo: TMYLDBPageNo): Integer;
    function EamPageNoForPageNo(PageNo: TMYLDBPageNo): TMYLDBPageNo;

    function GetLastEamPagePosition: Integer;
    function GetLastEamPageNo: TMYLDBPageNo;
    function GetLastPfsPagePosition: Integer;
    function PfsPositionsForExtentPosition(const ExtentPosition: Integer;
                                            out PfsFirstPagePosition: Integer;
                                            out PfsLastPagePosition: Integer
                                            ): Boolean;
    function PfsPageNoForPfsPagePosition(PfsPagePosition: Integer): TMYLDBPageNo;
    function PfsPageNoForPageNo(PageNo: TMYLDBPageNo): TMYLDBPageNo;


    function IsPagePfsOrEam(PageNo: TMYLDBPageNo): Boolean;

    function FindAndReusePage: TMYLDBPageNo;
    function FindLastUsedPageNo: TMYLDBPageNo;

    // Set in PFS and EAM maps that page with number PageNo is USED or FREE
    procedure SetPageUsage(PageNo: TMYLDBPageNo; UsedFlag: Boolean);
    procedure SetPageUsageToPFS(PageNo: TMYLDBPageNo; UsedFlag: Boolean);
    procedure SetPageUsageToEAM(PageNo: TMYLDBPageNo; UsedFlag: Boolean);

   public
    function GetPageUsageFromPFS(PageNo: TMYLDBPageNo) : Boolean;

   private
    function AddNewPageAndExtentFile: TMYLDBPageNo;
    procedure TruncateFile;

    procedure ReReadPageCountVariables;
    procedure ReWritePageCountVariables;

   public
    constructor Create(aPageManager: TMYLDBDiskPageManager);
    function GetPage(DesiredStartPageNo: TMYLDBPageNo = INVALID_PAGE_NO): TMYLDBPageNo;
    procedure FreePage(PageNo: TMYLDBPageNo);
    procedure CheckPageNoForSystemPages(PageNo: TMYLDBPageNo);

    property AddPagesStep: Integer read GetAddPagesStep;
    property DelPagesStep: Integer read GetDelPagesStep;
    property SuppressDBHeaderErrors: Boolean read FSuppressDBHeaderErrors write FSuppressDBHeaderErrors;

{
    procedure GetPages(
           PageCount:          TMYLDBPageNo;
           var Pages:          TMYLDBPagesArray;
           bUniform:           Boolean;
           DesiredStartPageNo: TMYLDBPageNo
                     ); virtual; abstract;
    procedure FreePages(Pages: TMYLDBPagesArray); virtual; abstract;
}
  end;// TMYLDBDatabaseFreeSpaceManager




////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDTPCTableInfo
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBDTPCTableInfo = class
   private
    TableID: TMYLDBTableID;
    TableSLockCount: Integer;
    TableRWLockCount: Integer;
    IsMostUpdatedLoaded: Boolean;

    procedure Clear;
   public
    TableState: Integer;

    constructor Create(aTableID: TMYLDBTableID);
    destructor Destroy; override;
    procedure TableIsSLocked;
    procedure TableIsSUnlocked;
    procedure TableIsRWLocked;
    procedure TableIsRWUnlocked;
    function GetIsMostUpdatedLoaded: Boolean;
    procedure SetIsMostUpdatedLoaded(aTableState: Integer);
    function IsTableLockedFromModification: Boolean;
  end;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDTPCSessionInfo
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBDTPCSessionInfo = class
   private
    FTableInfo: array of TMYLDBDTPCTableInfo;
    FWorkTableIDs: TList; // stack of work table IDs

   public
    constructor Create;
    destructor Destroy; override;
    function GetTableInfo(TableID: TMYLDBTableID): TMYLDBDTPCTableInfo;
    procedure BeginWorkWithTable(TableID: TMYLDBTableID);
    procedure EndWorkWithTable(TableID: TMYLDBTableID);
    function GetWorkTableState(var WorkTableState: Integer): Boolean;
  end;// TMYLDBDTPCSessionInfo

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDiskTablePagesCacheManager
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBDiskTablePagesCacheManager = class
   private
    FSessionInfo: array of TMYLDBDTPCSessionInfo;

    function GetSessionInfo(SessionID: TMYLDBSessionID): TMYLDBDTPCSessionInfo;
   public
    constructor Create;
    destructor Destroy; override;
    procedure TableIsSLocked(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    procedure TableIsSUnlocked(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    procedure TableIsRWLocked(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    procedure TableIsRWUnlocked(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    function GetIsMostUpdatedLoaded(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID): Boolean;
    procedure SetIsMostUpdatedLoaded(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID; TableState: Integer);
    procedure BeginWorkWithTable(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    procedure EndWorkWithTable(SessionID: TMYLDBSessionID; TableID: TMYLDBTableID);
    function GetWorkTableState(SessionID: TMYLDBSessionID; var WorkTableState: Integer): Boolean;
  end;// TMYLDBDiskTablePagesCacheManager



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDiskPageManager
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBDiskPageManager = class (TMYLDBPageManager)
   private
    FDatabaseFreeSpaceManager:  TMYLDBDatabaseFreeSpaceManager;
    FDatabaseFile:              TMYLDBDatabaseFile;
    FDBHeader:                  TMYLDBDBHeader;
    FCryptoHeader:              TMYLDBCryptoHeader;
    FPassword:                  TMYLDBPassword;
    FLockedBytes:               TMYLDBLockedBytes;
    FLockDBHeaderCount:         Integer;
    FExclusive:                 Boolean;
    FTablePagesCacheManager:    TMYLDBDiskTablePagesCacheManager;

    FOffsetToDBHeader:          Int64;
    FOffsetToCryptoHeader:      Int64;
    FOffsetToLockedBytes:       Int64;
    FOffsetToLastObjectID:      Int64;
    FOffsetToFirstPage:         Int64;

    procedure InitHeaders;

    procedure LoadDBHeader;
    procedure SaveDBHeader(PerformExternalAppUpdateCheck: boolean = True);
    function GetDbHeader: PMYLDBDBHeader;

    procedure LoadCryptoHeader;
    procedure SaveCryptoHeader;

    procedure LoadLockedBytes;
    procedure SaveLockedBytes;

    function GetPassword: PMYLDBPassword;
    function GetEncrypted: Boolean;
    function GetIsOpened: Boolean;
    function IsFileReadOnly(DatabaseFileName: String; var MultiUser: Boolean): Boolean;
    function GetPageOffset(PageNo: TMYLDBPageNo): Int64;
    procedure OpenFileForDesignTime;
    procedure CloseFileForDesignTime;
   protected
    function GetPageCount: TMYLDBPageNo; override;

    function IsSafeNotToSyncPage(SessionID: TMYLDBSessionID; Page: TMYLDBPage): Boolean; override;
    procedure UpdatePageTableState(SessionID: TMYLDBSessionID; Page: TMYLDBPage); override;
   public
    procedure ReadPageRegion(var Buffer; PageNo: TMYLDBPageNo; Offset, Count: Word);
    procedure WritePageRegion(const Buffer; PageNo: TMYLDBPageNo; Offset, Count: Word);

    procedure WriteEmptyPage(PageNo: TMYLDBPageNo);
    procedure InternalAddPage(aPage: TMYLDBPage); override;
    procedure InternalRemovePage(PageNo: TMYLDBPageNo); override;
    function InternalReadPage(aPage: TMYLDBPage): Boolean; override;
    procedure InternalWritePage(aPage: TMYLDBPage); override;
    function InternalReadPageState(PageNo: Integer): Integer;
    procedure InternalWritePageState(PageNo: Integer; PageState: Integer);

    function GetPage(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo;
                     PageType: TMYLDBPageTypeID; SynchronizeAllowed: Boolean = True): TMYLDBPage; override;

    procedure RemovePage(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo); override;

    // lock Free Space Manager byte
    function LockFreeSpaceManager: Boolean;
    // unlock Free Space Manager byte
    function UnlockFreeSpaceManager: Boolean;
    // lock Free Space Manager byte
    function LockTables: Boolean;
    // unlock Free Space Manager byte
    function UnlockTables: Boolean;
    function LockDBHeader: Boolean;
    function UnlockDBHeader: Boolean;
    // LastObjectID
    function LockLastObjectID: Boolean;
    function UnlockLastObjectID: Boolean;

    // Lock Byte (return TRUE if success)
    function LockPageByte(PageNo: TMYLDBPageNo; Offset: Word): Boolean;
    // Unlock Byte
    function UnlockPageByte(PageNo: TMYLDBPageNo; Offset: Word): Boolean;
    // return True if byte is locked
    function IsPageByteLocked(PageNo: TMYLDBPageNo; Offset: Word): Boolean;
    // return True if any byte of region is locked
    function IsPageRegionLocked(PageNo: TMYLDBPageNo; Offset: Word; Count: Word): Boolean;
   public
    constructor Create;
    destructor Destroy; override;
    procedure CreateAndOpenDatabase(
                              DatabaseFileName: String;
                              Password:         TMYLDBPassword;
                              PageSize:         Word = DefaultPageSize;
                              ExtentPageCount:  Word = DefaultExtentPageCount
                              );
    procedure OpenDatabase(
                DatabaseFileName: String;
                Password:         TMYLDBPassword;
                var ReadOnly:     Boolean;
                var RepairNeeded: Boolean;
                Exclusive:        Boolean;
                var MultiUser:    Boolean
                          );
    procedure CloseDatabase;
    procedure TruncateDatabase;
    // extend file by number of pages specified by PageCount
    procedure ExtendFile(PageCount: TMYLDBPageNo);
    // Truncate file by number of pages specified by PageCount
    procedure TruncateFile(PageCount: TMYLDBPageNo);
    // Increment LastObjectID and return it
    function GetNextObjectID(TryCount: Integer=5; DelayMS: Integer=100): TMYLDBLastObjectID;
    procedure InitObjectID(TryCount: Integer=5; DelayMS: Integer=100);
    procedure ApplyChanges(SessionID: TMYLDBSessionID); override;

   public
    property DatabaseFile: TMYLDBDatabaseFile read FDatabaseFile;
    property DBHeader: PMYLDBDBHeader read GetDbHeader;
    property LockedBytes: TMYLDBLockedBytes read FLockedBytes;
    property Password: PMYLDBPassword read GetPassword;
    property IsOpened: Boolean read GetIsOpened;
    property OffsetToFirstPage: Int64 read FOffsetToFirstPage;
    property OffsetToLockedBytes: Int64 read FOffsetToLockedBytes;
    property FreeSpaceManager: TMYLDBDatabaseFreeSpaceManager read FDatabaseFreeSpaceManager;
    property TablePagesCacheManager: TMYLDBDiskTablePagesCacheManager read FTablePagesCacheManager;
    property Exclusive: Boolean read FExclusive;
    property Encrypted: Boolean read GetEncrypted;
  end; // TMYLDBDiskPageManager


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBInternalDBTransactedAccessFile
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBInternalDBTransactedAccessFile = class(TObject)
   private
    LPageManager: TMYLDBDiskPageManager;
    FStartPageNo: TMYLDBPageNo;
    FPageTypeID:  TMYLDBPageTypeID;
   private
    // SetStartPageNo
    procedure SetStartPageNo(StartPageNo: TMYLDBPageNo);
    // raise if file is Closed
    procedure CheckFileOpened(OperationName: String);
    // return Count of File Pages
    function GetPageCountForDataSize(DataSize: Integer): Integer;
    // return Count of File Pages
    procedure GetPageNoAndOffsetForPosition(Position: Integer; var PagePosition: Integer; var Offset: word);
    // return real page No for file page (firstPageNo=0)
    function GoToPage(SessionID: TMYLDBSessionID; PagePosition: TMYLDBPageNo): TMYLDBPageNo;
   public