RecordManager

java.lang.Object
- org.apache.directory.mavibot.btree.AbstractTransactionManager
- - org.apache.directory.mavibot.btree.RecordManager

All Implemented Interfaces:

TransactionManager
```
public class RecordManager
extends AbstractTransactionManager
```
The RecordManager is used to manage the file in which we will store the B-trees. A RecordManager will manage more than one B-tree.
It stores data in fixed size pages (default size is 512 bytes), which may be linked one to the other if the data we want to store is too big for a page.

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.List<PageIO>`	`allocatedPages` The list of PageIO that can be freed after a roolback
`(package private) static java.lang.String`	`BTREE_OF_BTREES_NAME` The B-tree of B-trees management btree name
`private java.util.concurrent.locks.ReadWriteLock`	`btreeHeadersLock` A lock to protect the BtreeHeader maps
`(package private) BTree<NameRevision,java.lang.Long>`	`btreeOfBtrees` The B-tree of B-trees
`private static int`	`BYTE_SIZE` Some constants
`private java.util.Queue<RevisionName>`	`closedTransactionsQueue` The queue of recently closed transactions
`private int`	`commitCount` variable to keep track of the write commit count
`private static java.lang.ThreadLocal<java.lang.Integer>`	`context` A ThreadLocalStorage used to store the current transaction
`(package private) static java.lang.String`	`COPIED_PAGE_BTREE_NAME` The CopiedPages management btree name
`(package private) BTree<RevisionName,long[]>`	`copiedPageBtree` A B-tree used to manage the page that has been copied in a new version.
`private java.util.Map<java.lang.String,BTreeHeader<?,?>>`	`currentBTreeHeaders` A Map keeping the latest revisions for each managed BTree
`(package private) long`	`currentBtreeOfBtreesOffset` The current B-tree of B-trees header offset
`(package private) long`	`currentCopiedPagesBtreeOffset` The offset on the current copied pages B-tree
`private static java.lang.String`	`DEFAULT_FILE_NAME` The default file name
`static int`	`DEFAULT_PAGE_SIZE` The default page size
`private boolean`	`disableReclaimer`
`private long`	`endOfFileOffset` The offset of the end of the file
`private java.io.File`	`file` The associated file
`(package private) java.nio.channels.FileChannel`	`fileChannel` The channel used to read and write data
`(package private) long`	`firstFreePage` The first and last free page
`(package private) java.util.List<PageIO>`	`freedPages` The list of PageIO that can be freed after a commit
`private java.util.concurrent.locks.ReentrantLock`	`freePageLock` A lock to protect the freepage pointers
`private static byte[]`	`HEX_CHAR` Hex chars
`(package private) static int`	`INT_SIZE`
`static boolean`	`INTERNAL_BTREE` A flag used by internal btrees
`private boolean`	`keepRevisions` A flag set to true if we want to keep old revisions
`private static int`	`LINK_SIZE` The size of the link to next page
`protected static org.slf4j.Logger`	`LOG` The LoggerFactory used by this class
`protected static org.slf4j.Logger`	`LOG_CHECK` A dedicated logger for the check
`protected static org.slf4j.Logger`	`LOG_PAGES` The LoggerFactory used by this class
`private byte[]`	`LONG_LENGTH` The length of an Offset, as a negative value
`(package private) static int`	`LONG_SIZE`
`private java.util.Map<java.lang.String,BTree<java.lang.Object,java.lang.Object>>`	`managedBtrees` The set of managed B-trees
`private static int`	`MIN_PAGE_SIZE` The minimal page size.
`(package private) int`	`nbBtree` The number of managed B-trees
`java.util.concurrent.atomic.AtomicLong`	`nbCreatedPages`
`java.util.concurrent.atomic.AtomicLong`	`nbFreedPages` Some counters to track the number of free pages
`java.util.concurrent.atomic.AtomicLong`	`nbReusedPages`
`java.util.concurrent.atomic.AtomicLong`	`nbUpdateBtreeHeader`
`java.util.concurrent.atomic.AtomicLong`	`nbUpdatePageIOs`
`java.util.concurrent.atomic.AtomicLong`	`nbUpdateRMHeader`
`private java.util.Map<java.lang.String,BTreeHeader<?,?>>`	`newBTreeHeaders` A Map storing the new revisions when some change have been made in some BTrees
`static long`	`NO_PAGE` A constant for an offset on a non existing page
`static boolean`	`NORMAL_BTREE` A flag used by internal btrees
`private static int`	`PAGE_SIZE` The number of bytes used to store the size of a page
`private int`	`pageReclaimerThreshold` the threshold at which the PageReclaimer will be run to free the copied pages
`(package private) int`	`pageSize` The RecordManager underlying page size.
`private long`	`previousBtreeOfBtreesOffset` The previous B-tree of B-trees header offset
`private long`	`previousCopiedPagesBtreeOffset` The offset on the previous copied pages B-tree
`private PageReclaimer`	`reclaimer` the space reclaimer
`private java.nio.ByteBuffer`	`RECORD_MANAGER_HEADER_BUFFER` A global buffer used to store the RecordManager header
`private byte[]`	`RECORD_MANAGER_HEADER_BYTES` A static buffer used to store the RecordManager header
`(package private) static int`	`RECORD_MANAGER_HEADER_SIZE` The RecordManager header size
`private static int`	`ROLLBACKED_TXN` A value stored into the transaction context for rollbacked transactions
`private java.util.concurrent.locks.ReentrantLock`	`transactionLock` A lock to protect the transaction handling
`protected static org.slf4j.Logger`	`TXN_LOG` The LoggerFactory used to trace TXN operations
`java.util.Map<java.lang.Long,java.lang.Integer>`	`writeCounter`

Constructor Summary

Constructors
Constructor and Description
`RecordManager(java.lang.String fileName)` Create a Record manager which will either create the underlying file or load an existing one.
`RecordManager(java.lang.String fileName, int pageSize)` Create a Record manager which will either create the underlying file or load an existing one.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`_disableReclaimer(boolean toggle)`
`<K,V> BTree<K,V>`	`addBTree(java.lang.String name, ElementSerializer<K> keySerializer, ElementSerializer<V> valueSerializer, boolean allowDuplicates)` Creates a B-tree and automatically adds it to the list of managed btrees
`(package private) <K,V> void`	`addInBtreeOfBtrees(java.lang.String name, long revision, long btreeHeaderOffset)` Add a new tuple into the B-tree of B-trees.
`(package private) <K,V> void`	`addInCopiedPagesBtree(java.lang.String name, long revision, java.util.List<Page<K,V>> pages)` Add a new tuple into the CopiedPages B-tree.
`void`	`beginTransaction()` Starts a transaction
`private void`	`checkFreePages()`
`(package private) void`	`checkOffset(long offset)` Check the offset to be sure it's a valid one : It's >= 0 It's below the end of the file It's a multipl of the pageSize
`void`	`close()` Close the RecordManager and flush everything on disk
`void`	`commit()` Commits a transaction
`private int`	`computeNbPages(int dataSize)` Compute the number of pages needed to store some specific size of data.
`private int`	`computePageNb(long offset)` Compute the page in which we will store data given an offset, when we have a list of pages.
`private void`	`createBtreeOfBtrees()` Create the B-treeOfBtrees
`private void`	`createCopiedPagesBtree()` Create the CopiedPagesBtree
`private boolean`	`createFile(java.io.File mavibotFile)` Create the mavibot file if it does not exist
`private int`	`decrementTxnLevel()` Decrement the transactionLevel
`<K,V> Page<K,V>`	`deserialize(BTree<K,V> btree, long offset)` Deserialize a Page from a B-tree at a give position
`void`	`dump()` Dump the RecordManager file
`static java.lang.String`	`dump(byte octet)`
`private void`	`dump(PageIO pageIo)` Dump a pageIO
`private long`	`dumpBtreeHeader(long btreeOffset)` Dump a B-tree Header
`private void`	`dumpFreePages(long freePageOffset)` Dump the free pages
`private PageIO`	`fetchNewPage()` Return a new Page.
`(package private) PageIO`	`fetchPage(long offset)` fetch a page from disk, knowing its position in the file.
`private void`	`flushPages(PageIO... pageIos)` Write the pages on disk, either at the end of the file, or at the position they were taken from.
`(package private) void`	`free(long... offsets)` Add an array of PageIOs to the list of free PageIOs
`(package private) void`	`free(PageIO pageIo)` Add a PageIO to the list of free PageIOs
`(package private) <K,V> void`	`freePages(BTree<K,V> btree, long revision, java.util.List<Page<K,V>> pages)` Move a list of pages to the free page list.
`BTreeHeader`	`getBTreeHeader(java.lang.String name)` Get the current BTreeHeader for a given Btree.
`private PageIO[]`	`getFreePageIOs(int dataSize)` Get as many pages as needed to store the data of the given size.
`<K,V> BTree<K,V>`	`getManagedTree(java.lang.String name)` Get one managed trees, knowing its name.
`java.util.Set<java.lang.String>`	`getManagedTrees()` Get the managed B-trees.
`int`	`getNbManagedTrees()` Get the number of managed trees.
`BTreeHeader`	`getNewBTreeHeader(java.lang.String name)` Get the new BTreeHeader for a given Btree.
`int`	`getPageSize()`
`(package private) <K,V> Page<K,V>`	`getRootPage(BTree<K,V> btree, long revision)` Fetch the rootPage of a given B-tree for a given revision.
`private int`	`getTxnLevel()` Get the transactionLevel, ie the number of encapsulated update ops
`private void`	`incrementTxnLevel()` Increment the transactionLevel
`private void`	`initRecordManager()` We will create a brand new RecordManager file, containing nothing, but the RecordManager header, a B-tree to manage the old revisions we want to keep and a B-tree used to manage pages associated with old versions.
`boolean`	`isContextOk()`
`boolean`	`isKeepRevisions()`
`private <K,V> void`	`loadBtree(PageIO[] pageIos, BTree<K,V> btree)` Read a B-tree from the disk.
`(package private) <K,V> void`	`loadBtree(PageIO[] pageIos, BTree btree, BTree<K,V> parentBTree)` Read a B-tree from the disk.
`(package private) <K,V> BTree<V,V>`	`loadDupsBtree(long btreeHeaderOffset, BTree<K,V> parentBtree)` Loads a B-tree holding the values of a duplicate key This tree is also called as dups tree or sub tree
`private void`	`loadRecordManager()` Load the BTrees from the disk.
`(package private) static void`	`logPageIos(PageIO[] pageIos)`
`<K,V> void`	`manage(BTree<K,V> btree)` Manage a B-tree.
`<K,V> void`	`manageSubBtree(BTree<K,V> btree)` Managing a btree is a matter of storing an reference to the managed B-tree in the B-tree Of B-trees.
`private byte`	`readByte(PageIO[] pageIos, long position)` Read a byte from pages
`(package private) java.nio.ByteBuffer`	`readBytes(PageIO[] pageIos, long position)` Read a byte[] from pages.
`(package private) int`	`readInt(PageIO[] pageIos, long position)` Read an int from pages
`private <K,V> PersistedLeaf<K,V>`	`readLeafKeysAndValues(BTree<K,V> btree, int nbElems, long revision, java.nio.ByteBuffer byteBuffer, PageIO[] pageIos)` Deserialize a Leaf from some PageIOs
`(package private) long`	`readLong(PageIO[] pageIos, long position)` Read a long from pages
`private <K,V> PersistedNode<K,V>`	`readNodeKeysAndValues(BTree<K,V> btree, int nbElems, long revision, java.nio.ByteBuffer byteBuffer, PageIO[] pageIos)` Deserialize a Node from some PageIos
`private <K,V> Page<K,V>`	`readPage(BTree<K,V> btree, PageIO[] pageIos)` Read a page from some PageIO for a given B-tree
`(package private) PageIO[]`	`readPageIOs(long position, long limit)` Reads all the PageIOs that are linked to the page at the given position, including the first page.
`private <K,V> Page<K,V>`	`readRootPage(BTree<K,V> btree, long btreeHeaderOffset)` Read a root page from the B-tree header offset
`(package private) <K,V> void`	`releaseTransaction(ReadTransaction<K,V> readTransaction)` Add a newly closd transaction into the closed transaction queue
`private void`	`revertBtreeHeaders()` revert the new BTreeHeaders Map to the current BTreeHeader Map.
`void`	`rollback()` Rollback a transaction
`private void`	`runReclaimer()` runs the PageReclaimer to free the copied pages
`private <K,V> int`	`serializeLeafKey(PersistedLeaf<K,V> leaf, int pos, java.util.List<byte[]> serializedData)` Serialize a Leaf's key
`private <K,V> int`	`serializeLeafValue(PersistedLeaf<K,V> leaf, int pos, java.util.List<byte[]> serializedData)` Serialize a Leaf's Value.
`private <K,V> int`	`serializeNodeKey(PersistedNode<K,V> node, int pos, java.util.List<byte[]> serializedData)` Serialize a Node's key
`private <K,V> int`	`serializeNodeValue(PersistedNode<K,V> node, int pos, java.util.List<byte[]> serializedData)` Serialize a Node's Value.
`private <K,V> PageIO[]`	`serializePage(BTree<K,V> btree, long revision, Page<K,V> page)` Serialize a new Page.
`private PageIO[]`	`serializeRootPage(long revision)` Write a root page with no elements in it
`(package private) void`	`setBtreeOfBtreesOffset(long btreeOfBtreesOffset)` Internal method used to update the B-tree of B-trees offset
`void`	`setKeepRevisions(boolean keepRevisions)`
`(package private) void`	`setPageReclaimerThreshold(int pageReclaimerThreshold)` sets the threshold of the number of commits to be performed before reclaiming the free pages.
`(package private) void`	`setPageSize(int pageSize)` Set the page size, ie the number of bytes a page can store.
`private long`	`store(long position, byte[] bytes, PageIO... pageIos)` Stores a byte[] into one ore more pageIO (depending if the long is stored across a boundary or not)
`private long`	`store(long position, int value, PageIO... pageIos)` Stores an Integer into one ore more pageIO (depending if the int is stored across a boundary or not)
`private long`	`store(long position, long value, PageIO... pageIos)` Stores a Long into one ore more pageIO (depending if the long is stored across a boundary or not)
`(package private) void`	`storeCopiedPages(java.lang.String name, long revision, long[] copiedPages)` Stores the copied pages into the CopiedPages B-tree
`private long`	`storeRaw(long position, byte[] bytes, PageIO... pageIos)` Stores a byte[] into one ore more pageIO (depending if the long is stored across a boundary or not).
`(package private) <K,V> void`	`storeRootPage(BTree<K,V> btree, Page<K,V> rootPage)` Store a reference to an old rootPage into the Revision B-tree
`private void`	`swapCurrentBtreeHeaders()` Swap the current BtreeHeader map with the new one.
`java.lang.String`	`toString()`
`(package private) <K,V> long`	`updateBtreeHeader(BTree<K,V> btree, long btreeHeaderOffset)` Update the B-tree header after a B-tree modification.
`private <K,V> long`	`updateBtreeHeader(BTree<K,V> btree, long btreeHeaderOffset, boolean onPlace)` Update the B-tree header after a B-tree modification.
`(package private) <K,V> void`	`updateBtreeHeaderOnPlace(BTree<K,V> btree, long btreeHeaderOffset)` Update the B-tree header after a B-tree modification.
`void`	`updateNewBTreeHeaders(BTreeHeader btreeHeader)` Updates the map of new BTreeHeaders
`void`	`updateRecordManagerHeader()` Update the RecordManager header, injecting the following data :
`void`	`updateRecordManagerHeader(long newBtreeOfBtreesOffset, long newCopiedPageBtreeOffset)` Update the RecordManager header, injecting the following data :
`(package private) <K,V> long`	`writeBtreeHeader(BTree<K,V> btree, BTreeHeader<K,V> btreeHeader)` Write the B-tree header on disk.
`private <K,V> long`	`writeBtreeInfo(BTree<K,V> btree)` Write the B-tree informations on disk.
`private int`	`writeData(byte[] buffer, int position, int value)` Inject an int into a byte[] at a given position.
`private int`	`writeData(byte[] buffer, int position, long value)` Inject a long into a byte[] at a given position.
`(package private) <K,V> PageHolder<K,V>`	`writePage(BTree<K,V> btree, Page<K,V> newPage, long newRevision)` Write the page in a serialized form.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOG
```
protected static final org.slf4j.Logger LOG
```
    The LoggerFactory used by this class
  - TXN_LOG
```
protected static final org.slf4j.Logger TXN_LOG
```
    The LoggerFactory used to trace TXN operations
  - LOG_PAGES
```
protected static final org.slf4j.Logger LOG_PAGES
```
    The LoggerFactory used by this class
  - LOG_CHECK
```
protected static final org.slf4j.Logger LOG_CHECK
```
    A dedicated logger for the check
  - file
```
private java.io.File file
```
    The associated file
  - fileChannel
```
java.nio.channels.FileChannel fileChannel
```
    The channel used to read and write data
  - nbBtree
```
int nbBtree
```
    The number of managed B-trees
  - firstFreePage
```
long firstFreePage
```
    The first and last free page
  - nbFreedPages
```
public java.util.concurrent.atomic.AtomicLong nbFreedPages
```
    Some counters to track the number of free pages
  - nbCreatedPages
```
public java.util.concurrent.atomic.AtomicLong nbCreatedPages
```
  - nbReusedPages
```
public java.util.concurrent.atomic.AtomicLong nbReusedPages
```
  - nbUpdateRMHeader
```
public java.util.concurrent.atomic.AtomicLong nbUpdateRMHeader
```
  - nbUpdateBtreeHeader
```
public java.util.concurrent.atomic.AtomicLong nbUpdateBtreeHeader
```
  - nbUpdatePageIOs
```
public java.util.concurrent.atomic.AtomicLong nbUpdatePageIOs
```
  - endOfFileOffset
```
private long endOfFileOffset
```
    The offset of the end of the file
  - copiedPageBtree
```
BTree<RevisionName,long[]> copiedPageBtree
```
    A B-tree used to manage the page that has been copied in a new version. Those pages can be reclaimed when the associated version is dead.
  - NO_PAGE
```
public static final long NO_PAGE
```
    A constant for an offset on a non existing page
    
    See Also:
    
    Constant Field Values
  - PAGE_SIZE
```
private static final int PAGE_SIZE
```
    The number of bytes used to store the size of a page
    
    See Also:
    
    Constant Field Values
  - LINK_SIZE
```
private static final int LINK_SIZE
```
    The size of the link to next page
    
    See Also:
    
    Constant Field Values
  - BYTE_SIZE
```
private static final int BYTE_SIZE
```
    Some constants
    
    See Also:
    
    Constant Field Values
  - INT_SIZE
```
static final int INT_SIZE
```
    See Also:
    
    Constant Field Values
  - LONG_SIZE
```
static final int LONG_SIZE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_PAGE_SIZE
```
public static final int DEFAULT_PAGE_SIZE
```
    The default page size
    
    See Also:
    
    Constant Field Values
  - MIN_PAGE_SIZE
```
private static final int MIN_PAGE_SIZE
```
    The minimal page size. Can't be below 64, as we have to store many thing sin the RMHeader
    
    See Also:
    
    Constant Field Values
  - RECORD_MANAGER_HEADER_SIZE
```
static int RECORD_MANAGER_HEADER_SIZE
```
    The RecordManager header size
  - RECORD_MANAGER_HEADER_BUFFER
```
private java.nio.ByteBuffer RECORD_MANAGER_HEADER_BUFFER
```
    A global buffer used to store the RecordManager header
  - RECORD_MANAGER_HEADER_BYTES
```
private byte[] RECORD_MANAGER_HEADER_BYTES
```
    A static buffer used to store the RecordManager header
  - LONG_LENGTH
```
private byte[] LONG_LENGTH
```
    The length of an Offset, as a negative value
  - pageSize
```
int pageSize
```
    The RecordManager underlying page size.
  - managedBtrees
```
private java.util.Map<java.lang.String,BTree<java.lang.Object,java.lang.Object>> managedBtrees
```
    The set of managed B-trees
  - closedTransactionsQueue
```
private java.util.Queue<RevisionName> closedTransactionsQueue
```
    The queue of recently closed transactions
  - DEFAULT_FILE_NAME
```
private static final java.lang.String DEFAULT_FILE_NAME
```
    The default file name
    
    See Also:
    
    Constant Field Values
  - keepRevisions
```
private boolean keepRevisions
```
    A flag set to true if we want to keep old revisions
  - INTERNAL_BTREE
```
public static final boolean INTERNAL_BTREE
```
    A flag used by internal btrees
    
    See Also:
    
    Constant Field Values
  - NORMAL_BTREE
```
public static final boolean NORMAL_BTREE
```
    A flag used by internal btrees
    
    See Also:
    
    Constant Field Values
  - btreeOfBtrees
```
BTree<NameRevision,java.lang.Long> btreeOfBtrees
```
    The B-tree of B-trees
  - BTREE_OF_BTREES_NAME
```
static final java.lang.String BTREE_OF_BTREES_NAME
```
    The B-tree of B-trees management btree name
    
    See Also:
    
    Constant Field Values
  - COPIED_PAGE_BTREE_NAME
```
static final java.lang.String COPIED_PAGE_BTREE_NAME
```
    The CopiedPages management btree name
    
    See Also:
    
    Constant Field Values
  - currentBtreeOfBtreesOffset
```
long currentBtreeOfBtreesOffset
```
    The current B-tree of B-trees header offset
  - previousBtreeOfBtreesOffset
```
private long previousBtreeOfBtreesOffset
```
    The previous B-tree of B-trees header offset
  - currentCopiedPagesBtreeOffset
```
long currentCopiedPagesBtreeOffset
```
    The offset on the current copied pages B-tree
  - previousCopiedPagesBtreeOffset
```
private long previousCopiedPagesBtreeOffset
```
    The offset on the previous copied pages B-tree
  - transactionLock
```
private java.util.concurrent.locks.ReentrantLock transactionLock
```
    A lock to protect the transaction handling
  - context
```
private static final java.lang.ThreadLocal<java.lang.Integer> context
```
    A ThreadLocalStorage used to store the current transaction
  - freedPages
```
java.util.List<PageIO> freedPages
```
    The list of PageIO that can be freed after a commit
  - allocatedPages
```
private java.util.List<PageIO> allocatedPages
```
    The list of PageIO that can be freed after a roolback
  - currentBTreeHeaders
```
private java.util.Map<java.lang.String,BTreeHeader<?,?>> currentBTreeHeaders
```
    A Map keeping the latest revisions for each managed BTree
  - newBTreeHeaders
```
private java.util.Map<java.lang.String,BTreeHeader<?,?>> newBTreeHeaders
```
    A Map storing the new revisions when some change have been made in some BTrees
  - btreeHeadersLock
```
private java.util.concurrent.locks.ReadWriteLock btreeHeadersLock
```
    A lock to protect the BtreeHeader maps
  - ROLLBACKED_TXN
```
private static final int ROLLBACKED_TXN
```
    A value stored into the transaction context for rollbacked transactions
    
    See Also:
    
    Constant Field Values
  - freePageLock
```
private java.util.concurrent.locks.ReentrantLock freePageLock
```
    A lock to protect the freepage pointers
  - reclaimer
```
private PageReclaimer reclaimer
```
    the space reclaimer
  - commitCount
```
private int commitCount
```
    variable to keep track of the write commit count
  - pageReclaimerThreshold
```
private int pageReclaimerThreshold
```
    the threshold at which the PageReclaimer will be run to free the copied pages
  - disableReclaimer
```
private boolean disableReclaimer
```
  - writeCounter
```
public java.util.Map<java.lang.Long,java.lang.Integer> writeCounter
```
  - HEX_CHAR
```
private static final byte[] HEX_CHAR
```
    Hex chars
- Constructor Detail
  - RecordManager
```
public RecordManager(java.lang.String fileName)
```
    Create a Record manager which will either create the underlying file or load an existing one. If a folder is provided, then we will create a file with a default name : mavibot.db
    
    Parameters:
    
    name - The file name, or a folder name
  - RecordManager
```
public RecordManager(java.lang.String fileName,
                     int pageSize)
```
    Create a Record manager which will either create the underlying file or load an existing one. If a folder is provider, then we will create a file with a default name : mavibot.db
    
    Parameters:
    
    name - The file name, or a folder name
    
    pageSize - the size of a page on disk, in bytes
- Method Detail
  - runReclaimer
```
private void runReclaimer()
```
    runs the PageReclaimer to free the copied pages
  - createFile
```
private boolean createFile(java.io.File mavibotFile)
```
    Create the mavibot file if it does not exist
  - initRecordManager
```
private void initRecordManager()
                        throws java.io.IOException
```
    We will create a brand new RecordManager file, containing nothing, but the RecordManager header, a B-tree to manage the old revisions we want to keep and a B-tree used to manage pages associated with old versions.
    The RecordManager header contains the following details :
```
 +--------------------------+
 | PageSize                 | 4 bytes : The size of a physical page (default to 512)
 +--------------------------+
 |  NbTree                  | 4 bytes : The number of managed B-trees (zero or more)
 +--------------------------+
 | FirstFree                | 8 bytes : The offset of the first free page
 +--------------------------+
 | current BoB offset       | 8 bytes : The offset of the current BoB
 +--------------------------+
 | previous BoB offset      | 8 bytes : The offset of the previous BoB
 +--------------------------+
 | current CP btree offset  | 8 bytes : The offset of the current BoB
 +--------------------------+
 | previous CP btree offset | 8 bytes : The offset of the previous BoB
 +--------------------------+
 
```
    We then store the B-tree managing the pages that have been copied when we have added or deleted an element in the B-tree. They are associated with a version. Last, we add the bTree that keep a track on each revision we can have access to.
    Throws:
    
    java.io.IOException
  - createBtreeOfBtrees
```
private void createBtreeOfBtrees()
```
    Create the B-treeOfBtrees
  - createCopiedPagesBtree
```
private void createCopiedPagesBtree()
```
    Create the CopiedPagesBtree
  - loadRecordManager
```
private void loadRecordManager()
                        throws java.io.IOException,
                               java.lang.ClassNotFoundException,
                               java.lang.IllegalAccessException,
                               java.lang.InstantiationException,
                               java.lang.IllegalArgumentException,
                               java.lang.SecurityException,
                               java.lang.NoSuchFieldException,
                               KeyNotFoundException
```
    Load the BTrees from the disk.
    
    Throws:
    
    java.lang.InstantiationException
    
    java.lang.IllegalAccessException
    
    java.lang.ClassNotFoundException
    
    java.lang.NoSuchFieldException
    
    java.lang.SecurityException
    
    java.lang.IllegalArgumentException
    
    java.io.IOException
    
    KeyNotFoundException
  - beginTransaction
```
public void beginTransaction()
```
    Starts a transaction
  - commit
```
public void commit()
```
    Commits a transaction
  - isContextOk
```
public boolean isContextOk()
```
  - getTxnLevel
```
private int getTxnLevel()
```
    Get the transactionLevel, ie the number of encapsulated update ops
  - incrementTxnLevel
```
private void incrementTxnLevel()
```
    Increment the transactionLevel
  - decrementTxnLevel
```
private int decrementTxnLevel()
```
    Decrement the transactionLevel
  - rollback
```
public void rollback()
```
    Rollback a transaction
  - readPageIOs
```
PageIO[] readPageIOs(long position,
                     long limit)
              throws java.io.IOException,
                     EndOfFileExceededException
```
    Reads all the PageIOs that are linked to the page at the given position, including the first page.
    
    Parameters:
    
    position - The position of the first page
    
    limit - The maximum bytes to read. Set this value to -1 when the size is unknown.
    
    Returns:
    
    An array of pages
    
    Throws:
    
    java.io.IOException
    
    EndOfFileExceededException
  - checkOffset
```
void checkOffset(long offset)
```
    Check the offset to be sure it's a valid one :
    - It's >= 0
    - It's below the end of the file
    - It's a multipl of the pageSize
    Parameters:
    
    offset - The offset to check
    
    Throws:
    
    InvalidOffsetException - If the offset is not valid
  - loadBtree
```
private <K,V> void loadBtree(PageIO[] pageIos,
                             BTree<K,V> btree)
                      throws EndOfFileExceededException,
                             java.io.IOException,
                             java.lang.ClassNotFoundException,
                             java.lang.IllegalAccessException,
                             java.lang.InstantiationException,
                             java.lang.IllegalArgumentException,
                             java.lang.SecurityException,
                             java.lang.NoSuchFieldException
```
    Read a B-tree from the disk. The meta-data are at the given position in the list of pages. We load a B-tree in two steps : first, we load the B-tree header, then the common informations
    
    Parameters:
    
    pageIos - The list of pages containing the meta-data
    
    btree - The B-tree we have to initialize
    
    Throws:
    
    java.lang.InstantiationException
    
    java.lang.IllegalAccessException
    
    java.lang.ClassNotFoundException
    
    java.lang.NoSuchFieldException
    
    java.lang.SecurityException
    
    java.lang.IllegalArgumentException
    
    EndOfFileExceededException
    
    java.io.IOException
  - loadBtree
```
<K,V> void loadBtree(PageIO[] pageIos,
                     BTree btree,
                     BTree<K,V> parentBTree)
              throws EndOfFileExceededException,
                     java.io.IOException,
                     java.lang.ClassNotFoundException,
                     java.lang.IllegalAccessException,
                     java.lang.InstantiationException,
                     java.lang.IllegalArgumentException,
                     java.lang.SecurityException,
                     java.lang.NoSuchFieldException
```
    Read a B-tree from the disk. The meta-data are at the given position in the list of pages. We load a B-tree in two steps : first, we load the B-tree header, then the common informations
    
    Parameters:
    
    pageIos - The list of pages containing the meta-data
    
    btree - The B-tree we have to initialize
    
    Throws:
    
    java.lang.InstantiationException
    
    java.lang.IllegalAccessException
    
    java.lang.ClassNotFoundException
    
    java.lang.NoSuchFieldException
    
    java.lang.SecurityException
    
    java.lang.IllegalArgumentException
    
    EndOfFileExceededException
    
    java.io.IOException
  - deserialize
```
public <K,V> Page<K,V> deserialize(BTree<K,V> btree,
                                   long offset)
                            throws EndOfFileExceededException,
                                   java.io.IOException
```
    Deserialize a Page from a B-tree at a give position
    
    Parameters:
    
    btree - The B-tree we want to read a Page from
    
    offset - The position in the file for this page
    
    Returns:
    
    The read page
    
    Throws:
    
    EndOfFileExceededException - If we have reached the end of the file while reading the page
    
    java.io.IOException
  - readPage
```
private <K,V> Page<K,V> readPage(BTree<K,V> btree,
                                 PageIO[] pageIos)
                          throws java.io.IOException
```
    Read a page from some PageIO for a given B-tree
    
    Parameters:
    
    btree - The B-tree we want to read a page for
    
    pageIos - The PageIO containing the raw data
    
    Returns:
    
    The read Page if successful
    
    Throws:
    
    java.io.IOException - If the deserialization failed
  - readLeafKeysAndValues
```
private <K,V> PersistedLeaf<K,V> readLeafKeysAndValues(BTree<K,V> btree,
                                                       int nbElems,
                                                       long revision,
                                                       java.nio.ByteBuffer byteBuffer,
                                                       PageIO[] pageIos)
```
    Deserialize a Leaf from some PageIOs
  - readNodeKeysAndValues
```
private <K,V> PersistedNode<K,V> readNodeKeysAndValues(BTree<K,V> btree,
                                                       int nbElems,
                                                       long revision,
                                                       java.nio.ByteBuffer byteBuffer,
                                                       PageIO[] pageIos)
                                                throws java.io.IOException
```
    Deserialize a Node from some PageIos
    
    Throws:
    
    java.io.IOException
  - readBytes
```
java.nio.ByteBuffer readBytes(PageIO[] pageIos,
                              long position)
```
    Read a byte[] from pages.
    
    Parameters:
    
    pageIos - The pages we want to read the byte[] from
    
    position - The position in the data stored in those pages
    
    Returns:
    
    The byte[] we have read
  - readInt
```
int readInt(PageIO[] pageIos,
            long position)
```
    Read an int from pages
    
    Parameters:
    
    pageIos - The pages we want to read the int from
    
    position - The position in the data stored in those pages
    
    Returns:
    
    The int we have read
  - readByte
```
private byte readByte(PageIO[] pageIos,
                      long position)
```
    Read a byte from pages
    
    Parameters:
    
    pageIos - The pages we want to read the byte from
    
    position - The position in the data stored in those pages
    
    Returns:
    
    The byte we have read
  - readLong
```
long readLong(PageIO[] pageIos,
              long position)
```
    Read a long from pages
    
    Parameters:
    
    pageIos - The pages we want to read the long from
    
    position - The position in the data stored in those pages
    
    Returns:
    
    The long we have read
  - manage
```
public <K,V> void manage(BTree<K,V> btree)
                  throws BTreeAlreadyManagedException,
                         java.io.IOException
```
    Manage a B-tree. The btree will be added and managed by this RecordManager. We will create a new RootPage for this added B-tree, which will contain no data.
    This method is threadsafe. Managing a btree is a matter of storing an reference to the managed B-tree in the B-tree Of B-trees. We store a tuple of NameRevision (where revision is 0L) and a offset to the B-tree header. At the same time, we keep a track of the managed B-trees in a Map.
    
    Parameters:
    
    btree - The new B-tree to manage.
    
    treeType - flag indicating if this is an internal tree
    
    Throws:
    
    BTreeAlreadyManagedException - If the B-tree is already managed
    
    java.io.IOException - if there was a problem while accessing the file
  - manageSubBtree
```
public <K,V> void manageSubBtree(BTree<K,V> btree)
                          throws BTreeAlreadyManagedException,
                                 java.io.IOException
```
    Managing a btree is a matter of storing an reference to the managed B-tree in the B-tree Of B-trees. We store a tuple of NameRevision (where revision is 0L) and a offset to the B-tree header. At the same time, we keep a track of the managed B-trees in a Map.
    
    Parameters:
    
    btree - The new B-tree to manage.
    
    treeType - flag indicating if this is an internal tree
    
    Throws:
    
    BTreeAlreadyManagedException - If the B-tree is already managed
    
    java.io.IOException
  - serializePage
```
private <K,V> PageIO[] serializePage(BTree<K,V> btree,
                                     long revision,
                                     Page<K,V> page)
                              throws java.io.IOException
```
    Serialize a new Page. It will contain the following data :
    - the revision : a long
    - the number of elements : an int (if <= 0, it's a Node, otherwise it's a Leaf)
    - the size of the values/keys when serialized
    - the keys : an array of serialized keys
    - the values : an array of references to the children pageIO offset (stored as long) if it's a Node, or a list of values if it's a Leaf
    Parameters:
    
    revision - The node revision
    
    keys - The keys to serialize
    
    children - The references to the children
    
    Returns:
    
    An array of pages containing the serialized node
    
    Throws:
    
    java.io.IOException
  - serializeNodeKey
```
private <K,V> int serializeNodeKey(PersistedNode<K,V> node,
                                   int pos,
                                   java.util.List<byte[]> serializedData)
```
    Serialize a Node's key
  - serializeNodeValue
```
private <K,V> int serializeNodeValue(PersistedNode<K,V> node,
                                     int pos,
                                     java.util.List<byte[]> serializedData)
                              throws java.io.IOException
```
    Serialize a Node's Value. We store the two offsets of the child page.
    
    Throws:
    
    java.io.IOException
  - serializeLeafKey
```
private <K,V> int serializeLeafKey(PersistedLeaf<K,V> leaf,
                                   int pos,
                                   java.util.List<byte[]> serializedData)
```
    Serialize a Leaf's key
  - serializeLeafValue
```
private <K,V> int serializeLeafValue(PersistedLeaf<K,V> leaf,
                                     int pos,
                                     java.util.List<byte[]> serializedData)
                              throws java.io.IOException
```
    Serialize a Leaf's Value.
    
    Throws:
    
    java.io.IOException
  - serializeRootPage
```
private PageIO[] serializeRootPage(long revision)
                            throws java.io.IOException
```
    Write a root page with no elements in it
    
    Throws:
    
    java.io.IOException
  - updateRecordManagerHeader
```
public void updateRecordManagerHeader()
```
    Update the RecordManager header, injecting the following data :
```
 +---------------------+
 | PageSize            | 4 bytes : The size of a physical page (default to 4096)
 +---------------------+
 | NbTree              | 4 bytes : The number of managed B-trees (at least 1)
 +---------------------+
 | FirstFree           | 8 bytes : The offset of the first free page
 +---------------------+
 | current BoB offset  | 8 bytes : The offset of the current B-tree of B-trees
 +---------------------+
 | previous BoB offset | 8 bytes : The offset of the previous B-tree of B-trees
 +---------------------+
 | current CP offset   | 8 bytes : The offset of the current CopiedPages B-tree
 +---------------------+
 | previous CP offset  | 8 bytes : The offset of the previous CopiedPages B-tree
 +---------------------+
 
```
  - updateRecordManagerHeader
```
public void updateRecordManagerHeader(long newBtreeOfBtreesOffset,
                                      long newCopiedPageBtreeOffset)
```
    Update the RecordManager header, injecting the following data :
```
 +---------------------+
 | PageSize            | 4 bytes : The size of a physical page (default to 4096)
 +---------------------+
 | NbTree              | 4 bytes : The number of managed B-trees (at least 1)
 +---------------------+
 | FirstFree           | 8 bytes : The offset of the first free page
 +---------------------+
 | current BoB offset  | 8 bytes : The offset of the current B-tree of B-trees
 +---------------------+
 | previous BoB offset | 8 bytes : The offset of the previous B-tree of B-trees
 +---------------------+
 | current CP offset   | 8 bytes : The offset of the current CopiedPages B-tree
 +---------------------+
 | previous CP offset  | 8 bytes : The offset of the previous CopiedPages B-tree
 +---------------------+
 
```
  - writeData
```
private int writeData(byte[] buffer,
                      int position,
                      int value)
```
    Inject an int into a byte[] at a given position.
  - writeData
```
private int writeData(byte[] buffer,
                      int position,
                      long value)
```
    Inject a long into a byte[] at a given position.
  - addInBtreeOfBtrees
```
<K,V> void addInBtreeOfBtrees(java.lang.String name,
                              long revision,
                              long btreeHeaderOffset)
                       throws java.io.IOException
```
    Add a new tuple into the B-tree of B-trees.
    
    Parameters:
    
    name - The B-tree name
    
    revision - The B-tree revision
    
    btreeHeaderOffset - The B-tree offset
    
    Throws:
    
    java.io.IOException - If the update failed
  - addInCopiedPagesBtree
```
<K,V> void addInCopiedPagesBtree(java.lang.String name,
                                 long revision,
                                 java.util.List<Page<K,V>> pages)
                          throws java.io.IOException
```
    Add a new tuple into the CopiedPages B-tree.
    
    Parameters:
    
    name - The B-tree name
    
    revision - The B-tree revision
    
    btreeHeaderOffset - The B-tree offset
    
    Throws:
    
    java.io.IOException - If the update failed
  - setBtreeOfBtreesOffset
```
void setBtreeOfBtreesOffset(long btreeOfBtreesOffset)
```
    Internal method used to update the B-tree of B-trees offset
    
    Parameters:
    
    btreeOfBtreesOffset - The new offset
  - writeBtreeHeader
```
<K,V> long writeBtreeHeader(BTree<K,V> btree,
                            BTreeHeader<K,V> btreeHeader)
                     throws java.io.IOException
```
    Write the B-tree header on disk. We will write the following informations :
```
 +------------+
 | revision   | The B-tree revision
 +------------+
 | nbElems    | The B-tree number of elements
 +------------+
 | rootPage   | The root page offset
 +------------+
 | BtreeInfo  | The B-tree info offset
 +------------+
 
```
    Parameters:
    
    btree - The B-tree which header has to be written
    
    btreeInfoOffset - The offset of the B-tree informations
    
    Returns:
    
    The B-tree header offset
    
    Throws:
    
    java.io.IOException - If we weren't able to write the B-tree header
  - writeBtreeInfo
```
private <K,V> long writeBtreeInfo(BTree<K,V> btree)
                           throws java.io.IOException
```
    Write the B-tree informations on disk. We will write the following informations :
```
 +------------+
 | pageSize   | The B-tree page size (ie, the number of elements per page max)
 +------------+
 | nameSize   | The B-tree name size
 +------------+
 | name       | The B-tree name
 +------------+
 | keySerSize | The keySerializer FQCN size
 +------------+
 | keySerFQCN | The keySerializer FQCN
 +------------+
 | valSerSize | The Value serializer FQCN size
 +------------+
 | valSerKQCN | The valueSerializer FQCN
 +------------+
 | dups       | The flags that tell if the dups are allowed
 +------------+
 
```
    Parameters:
    
    btree - The B-tree which header has to be written
    
    Returns:
    
    The B-tree header offset
    
    Throws:
    
    java.io.IOException - If we weren't able to write the B-tree header
  - updateBtreeHeader
```
<K,V> long updateBtreeHeader(BTree<K,V> btree,
                             long btreeHeaderOffset)
                      throws EndOfFileExceededException,
                             java.io.IOException
```
    Update the B-tree header after a B-tree modification. This will make the latest modification visible.
    We update the following fields :
    - the revision
    - the number of elements
    - the B-tree root page offset
    As a result, a new version of the BtreHeader will be created, which will replace the previous B-tree header
    Parameters:
    
    btree - TheB-tree to update
    
    btreeHeaderOffset - The offset of the modified btree header
    
    Returns:
    
    The offset of the new B-tree Header
    
    Throws:
    
    java.io.IOException - If we weren't able to write the file on disk
    
    EndOfFileExceededException - If we tried to write after the end of the file
  - updateBtreeHeaderOnPlace
```
<K,V> void updateBtreeHeaderOnPlace(BTree<K,V> btree,
                                    long btreeHeaderOffset)
                             throws EndOfFileExceededException,
                                    java.io.IOException
```
    Update the B-tree header after a B-tree modification. This will make the latest modification visible.
    We update the following fields :
    - the revision
    - the number of elements
    - the reference to the current B-tree revisions
    - the reference to the old B-tree revisions
    As a result, we new version of the BtreHeader will be created
    Parameters:
    
    btree - The B-tree to update
    
    btreeHeaderOffset - The offset of the modified btree header
    
    Throws:
    
    java.io.IOException
    
    EndOfFileExceededException
  - updateBtreeHeader
```
private <K,V> long updateBtreeHeader(BTree<K,V> btree,
                                     long btreeHeaderOffset,
                                     boolean onPlace)
                              throws EndOfFileExceededException,
                                     java.io.IOException
```
    Update the B-tree header after a B-tree modification. This will make the latest modification visible.
    We update the following fields :
    - the revision
    - the number of elements
    - the reference to the current B-tree revisions
    - the reference to the old B-tree revisions
    As a result, a new version of the BtreHeader will be created, which may replace the previous B-tree header (if the onPlace flag is set to true) or a new set of pageIos will contain the new version.
    Parameters:
    
    btree - The B-tree to update
    
    rootPageOffset - The offset of the modified rootPage
    
    onPlace - Tells if we modify the B-tree on place, or if we create a copy
    
    Returns:
    
    The offset of the new B-tree Header if it has changed (ie, when the onPlace flag is set to true)
    
    Throws:
    
    EndOfFileExceededException - If we tried to write after the end of the file
    
    java.io.IOException - If tehre were some error while writing the data on disk
  - flushPages
```
private void flushPages(PageIO... pageIos)
                 throws java.io.IOException
```
    Write the pages on disk, either at the end of the file, or at the position they were taken from.
    
    Parameters:
    
    pageIos - The list of pages to write
    
    Throws:
    
    java.io.IOException - If the write failed
  - computePageNb
```
private int computePageNb(long offset)
```
    Compute the page in which we will store data given an offset, when we have a list of pages.
    
    Parameters:
    
    offset - The position in the data
    
    Returns:
    
    The page number in which the offset will start
  - store
```
private long store(long position,
                   byte[] bytes,
                   PageIO... pageIos)
```
    Stores a byte[] into one ore more pageIO (depending if the long is stored across a boundary or not)
    
    Parameters:
    
    position - The position in a virtual byte[] if all the pages were contiguous
    
    bytes - The byte[] to serialize
    
    pageIos - The pageIOs we have to store the data in
    
    Returns:
    
    The new offset
  - storeRaw
```
private long storeRaw(long position,
                      byte[] bytes,
                      PageIO... pageIos)
```
    Stores a byte[] into one ore more pageIO (depending if the long is stored across a boundary or not). We don't add the byte[] size, it's already present in the received byte[].
    
    Parameters:
    
    position - The position in a virtual byte[] if all the pages were contiguous
    
    bytes - The byte[] to serialize
    
    pageIos - The pageIOs we have to store the data in
    
    Returns:
    
    The new offset
  - store
```
private long store(long position,
                   int value,
                   PageIO... pageIos)
```
    Stores an Integer into one ore more pageIO (depending if the int is stored across a boundary or not)
    
    Parameters:
    
    position - The position in a virtual byte[] if all the pages were contiguous
    
    value - The int to serialize
    
    pageIos - The pageIOs we have to store the data in
    
    Returns:
    
    The new offset
  - store
```
private long store(long position,
                   long value,
                   PageIO... pageIos)
```
    Stores a Long into one ore more pageIO (depending if the long is stored across a boundary or not)
    
    Parameters:
    
    position - The position in a virtual byte[] if all the pages were contiguous
    
    value - The long to serialize
    
    pageIos - The pageIOs we have to store the data in
    
    Returns:
    
    The new offset
  - writePage
```
<K,V> PageHolder<K,V> writePage(BTree<K,V> btree,
                                Page<K,V> newPage,
                                long newRevision)
                         throws java.io.IOException
```
    Write the page in a serialized form.
    
    Parameters:
    
    btree - The persistedBtree we will create a new PageHolder for
    
    newPage - The page to write on disk
    
    newRevision - The page's revision
    
    Returns:
    
    A PageHolder containing the copied page
    
    Throws:
    
    java.io.IOException - If the page can't be written on disk
  - logPageIos
```
static void logPageIos(PageIO[] pageIos)
```
  - computeNbPages
```
private int computeNbPages(int dataSize)
```
    Compute the number of pages needed to store some specific size of data.
    
    Parameters:
    
    dataSize - The size of the data we want to store in pages
    
    Returns:
    
    The number of pages needed
  - getFreePageIOs
```
private PageIO[] getFreePageIOs(int dataSize)
                         throws java.io.IOException
```
    Get as many pages as needed to store the data of the given size. The returned PageIOs are all linked together.
    
    Parameters:
    
    dataSize - The data size
    
    Returns:
    
    An array of pages, enough to store the full data
    
    Throws:
    
    java.io.IOException
  - fetchNewPage
```
private PageIO fetchNewPage()
                     throws java.io.IOException
```
    Return a new Page. We take one of the existing free pages, or we create a new page at the end of the file.
    
    Returns:
    
    The fetched PageIO
    
    Throws:
    
    java.io.IOException
  - fetchPage
```
PageIO fetchPage(long offset)
          throws java.io.IOException,
                 EndOfFileExceededException
```
    fetch a page from disk, knowing its position in the file.
    
    Parameters:
    
    offset - The position in the file
    
    Returns:
    
    The found page
    
    Throws:
    
    java.io.IOException
    
    EndOfFileExceededException
  - getPageSize
```
public int getPageSize()
```
    Returns:
    
    the pageSize
  - setPageSize
```
void setPageSize(int pageSize)
```
    Set the page size, ie the number of bytes a page can store.
    
    Parameters:
    
    pageSize - The number of bytes for a page
  - close
```
public void close()
           throws java.io.IOException
```
    Close the RecordManager and flush everything on disk
    
    Throws:
    
    java.io.IOException
  - dump
```
public static java.lang.String dump(byte octet)
```
  - dump
```
private void dump(PageIO pageIo)
```
    Dump a pageIO
  - dump
```
public void dump()
```
    Dump the RecordManager file
    
    Throws:
    
    java.io.IOException
  - dumpFreePages
```
private void dumpFreePages(long freePageOffset)
                    throws EndOfFileExceededException,
                           java.io.IOException
```
    Dump the free pages
    
    Throws:
    
    EndOfFileExceededException
    
    java.io.IOException
  - dumpBtreeHeader
```
private long dumpBtreeHeader(long btreeOffset)
                      throws EndOfFileExceededException,
                             java.io.IOException
```
    Dump a B-tree Header
    
    Throws:
    
    EndOfFileExceededException
    
    java.io.IOException
  - getNbManagedTrees
```
public int getNbManagedTrees()
```
    Get the number of managed trees. We don't count the CopiedPage B-tree and the B-tree of B-trees
    
    Returns:
    
    The number of managed B-trees
  - getManagedTrees
```
public java.util.Set<java.lang.String> getManagedTrees()
```
    Get the managed B-trees. We don't return the CopiedPage B-tree nor the B-tree of B-trees.
    
    Returns:
    
    The managed B-trees
  - storeCopiedPages
```
void storeCopiedPages(java.lang.String name,
                      long revision,
                      long[] copiedPages)
               throws java.io.IOException
```
    Stores the copied pages into the CopiedPages B-tree
    
    Parameters:
    
    name - The B-tree name
    
    revision - The revision
    
    copiedPages - The pages that have been copied while creating this revision
    
    Throws:
    
    java.io.IOException - If we weren't able to store the data on disk
  - storeRootPage
```
<K,V> void storeRootPage(BTree<K,V> btree,
                         Page<K,V> rootPage)
                  throws java.io.IOException
```
    Store a reference to an old rootPage into the Revision B-tree
    
    Parameters:
    
    btree - The B-tree we want to keep an old RootPage for
    
    rootPage - The old rootPage
    
    Throws:
    
    java.io.IOException - If we have an issue while writing on disk
  - getRootPage
```
<K,V> Page<K,V> getRootPage(BTree<K,V> btree,
                            long revision)
                     throws KeyNotFoundException,
                            java.io.IOException
```
    Fetch the rootPage of a given B-tree for a given revision.
    
    Parameters:
    
    btree - The B-tree we are interested in
    
    revision - The revision we want to get back
    
    Returns:
    
    The rootPage for this B-tree and this revision, if any
    
    Throws:
    
    KeyNotFoundException - If we can't find the rootPage for this revision and this B-tree
    
    java.io.IOException - If we had an ise while accessing the data on disk
  - readRootPage
```
private <K,V> Page<K,V> readRootPage(BTree<K,V> btree,
                                     long btreeHeaderOffset)
                              throws EndOfFileExceededException,
                                     java.io.IOException
```
    Read a root page from the B-tree header offset
    
    Throws:
    
    EndOfFileExceededException
    
    java.io.IOException
  - getManagedTree
```
public <K,V> BTree<K,V> getManagedTree(java.lang.String name)
```
    Get one managed trees, knowing its name.
    
    Parameters:
    
    name - The B-tree name we are looking for
    
    Returns:
    
    The managed B-trees
  - freePages
```
<K,V> void freePages(BTree<K,V> btree,
                     long revision,
                     java.util.List<Page<K,V>> pages)
              throws EndOfFileExceededException,
                     java.io.IOException
```
    Move a list of pages to the free page list. A logical page is associated with one or more physical PageIOs, which are on the disk. We have to move all those PagIO instances to the free list, and do the same in memory (we try to keep a reference to a set of free pages.
    
    Parameters:
    
    btree - The B-tree which were owning the pages
    
    revision - The current revision
    
    pages - The pages to free
    
    Throws:
    
    java.io.IOException - If we had a problem while updating the file
    
    EndOfFileExceededException - If we tried to write after the end of the file
  - free
```
void free(PageIO pageIo)
   throws java.io.IOException
```
    Add a PageIO to the list of free PageIOs
    
    Parameters:
    
    pageIo - The page to free
    
    Throws:
    
    java.io.IOException - If we weren't capable of updating the file
  - free
```
void free(long... offsets)
   throws java.io.IOException
```
    Add an array of PageIOs to the list of free PageIOs
    
    Parameters:
    
    offsets - The offsets of the pages whose associated PageIOs will be fetched and freed.
    
    Throws:
    
    java.io.IOException - If we weren't capable of updating the file
  - isKeepRevisions
```
public boolean isKeepRevisions()
```
    Returns:
    
    the keepRevisions flag
  - setKeepRevisions
```
public void setKeepRevisions(boolean keepRevisions)
```
    Parameters:
    
    keepRevisions - the keepRevisions flag to set
  - addBTree
```
public <K,V> BTree<K,V> addBTree(java.lang.String name,
                                 ElementSerializer<K> keySerializer,
                                 ElementSerializer<V> valueSerializer,
                                 boolean allowDuplicates)
                          throws java.io.IOException,
                                 BTreeAlreadyManagedException
```
    Creates a B-tree and automatically adds it to the list of managed btrees
    
    Parameters:
    
    name - the name of the B-tree
    
    keySerializer - key serializer
    
    valueSerializer - value serializer
    
    allowDuplicates - flag for allowing duplicate keys
    
    Returns:
    
    a managed B-tree
    
    Throws:
    
    java.io.IOException - If we weren't able to update the file on disk
    
    BTreeAlreadyManagedException - If the B-tree is already managed
  - releaseTransaction
```
<K,V> void releaseTransaction(ReadTransaction<K,V> readTransaction)
```
    Add a newly closd transaction into the closed transaction queue
  - getBTreeHeader
```
public BTreeHeader getBTreeHeader(java.lang.String name)
```
    Get the current BTreeHeader for a given Btree. It might not exist
    
    Parameters:
    
    name - The Btree name we are looking the BtreeHeader for
    
    Returns:
    
    the current BTreeHeader
  - getNewBTreeHeader
```
public BTreeHeader getNewBTreeHeader(java.lang.String name)
```
    Get the new BTreeHeader for a given Btree. It might not exist
  - updateNewBTreeHeaders
```
public void updateNewBTreeHeaders(BTreeHeader btreeHeader)
```
    Updates the map of new BTreeHeaders
    
    Parameters:
    
    btreeHeader - The new BtreeHeader
  - swapCurrentBtreeHeaders
```
private void swapCurrentBtreeHeaders()
```
    Swap the current BtreeHeader map with the new one. This method will only be called in a single trhead, when the current transaction will be committed.
  - revertBtreeHeaders
```
private void revertBtreeHeaders()
```
    revert the new BTreeHeaders Map to the current BTreeHeader Map. This method is called when we have to rollback a transaction.
  - loadDupsBtree
```
<K,V> BTree<V,V> loadDupsBtree(long btreeHeaderOffset,
                               BTree<K,V> parentBtree)
```
    Loads a B-tree holding the values of a duplicate key This tree is also called as dups tree or sub tree
    
    Parameters:
    
    offset - the offset of the B-tree header
    
    Returns:
    
    the deserialized B-tree
  - checkFreePages
```
private void checkFreePages()
                     throws EndOfFileExceededException,
                            java.io.IOException
```
    Throws:
    
    EndOfFileExceededException
    
    java.io.IOException
  - setPageReclaimerThreshold
```
void setPageReclaimerThreshold(int pageReclaimerThreshold)
```
    sets the threshold of the number of commits to be performed before reclaiming the free pages.
    
    Parameters:
    
    pageReclaimerThreshold - the number of commits before the reclaimer runs
  - _disableReclaimer
```
void _disableReclaimer(boolean toggle)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
    
    See Also:
    
    Object.toString()

Class RecordManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

TXN_LOG

LOG_PAGES

LOG_CHECK

file

fileChannel

nbBtree

firstFreePage

nbFreedPages

nbCreatedPages

nbReusedPages

nbUpdateRMHeader

nbUpdateBtreeHeader

nbUpdatePageIOs

endOfFileOffset

copiedPageBtree

NO_PAGE

PAGE_SIZE

LINK_SIZE

BYTE_SIZE

INT_SIZE

LONG_SIZE

DEFAULT_PAGE_SIZE

MIN_PAGE_SIZE

RECORD_MANAGER_HEADER_SIZE

RECORD_MANAGER_HEADER_BUFFER

RECORD_MANAGER_HEADER_BYTES

LONG_LENGTH

pageSize

managedBtrees

closedTransactionsQueue

DEFAULT_FILE_NAME

keepRevisions

INTERNAL_BTREE

NORMAL_BTREE

btreeOfBtrees

BTREE_OF_BTREES_NAME

COPIED_PAGE_BTREE_NAME

currentBtreeOfBtreesOffset

previousBtreeOfBtreesOffset

currentCopiedPagesBtreeOffset

previousCopiedPagesBtreeOffset

transactionLock

context

freedPages

allocatedPages

currentBTreeHeaders

newBTreeHeaders

btreeHeadersLock

ROLLBACKED_TXN

freePageLock

reclaimer

commitCount

pageReclaimerThreshold

disableReclaimer

writeCounter

HEX_CHAR

Constructor Detail

RecordManager

RecordManager

Method Detail

runReclaimer

createFile

initRecordManager

createBtreeOfBtrees

createCopiedPagesBtree

loadRecordManager

beginTransaction

commit

isContextOk

getTxnLevel

incrementTxnLevel

decrementTxnLevel

rollback