Returns the current node capacity @return the newCap variable value.

Return the page index @return current page index

Read each tree node and return it as a generic type @param index index of the page in the file @return a TreeNode object referencing to the loaded pa

Get the specific key at position indicated by <code>index</code> @param index the position to get the key @return the key at position

Function that is responsible to redistribute values among two leaf nodes while updating the referring key of the parent node (always an internal node)

Abstract method that all classes must implement that writes each node type to a page slot. More details in each implementation. @param r an already

Increment the node capacity by one. @param conf configuration instance for validating the limits. @throws InvalidBTreeStateException is thrown when t

Decrement the node capacity by one. @param conf configuration instance for validating the limits. @throws InvalidBTreeStateException is thrown when t

Simple helper function to check if we can re-distribute the node values. @param with node to check the capacity @return the number of positions to ch

Returns the total number of pages currently in use @return return the total number of pages

Add a random sequence of numbers in the tree using unique or discrete values for the key. @param from starting range (>= 0) @param to ending range @p

Set being deleted flag @param beingDeleted value to set the flag.

Add key at index while shifting entries pointed by index and after by one. @param index index to shift keys and add @param key key to add in position

Delete the page @param pageIndex page index to remove @param sort sort free sort pool?

Check if the node is a leaf page @param nt nodeType of the node we want to check @return return true it's a leaf page, false if it's not

It reads an positive integer, zero included, from standard input and returns it as value. In case of an error it returns -1 @param message The messag

Add a key to the last place of the array @param key key to add

Check if the node in question is a leaf (including root) @return true if the node is a leaf, false if it's not.

Generate the first available index for a page. @param conf B+ configuration reference @return page index

Return the node type @return the current node type

Check if the node in question is an internal node (including root) @return true if the node is an internal node, false if it's not.

Check if the node in question is a tree root. @return true if it is a tree root, false if it's not.

Function that merges two leaves together; in this case we must have two leaves, left and right that are merged and their parent that must be an inter

Pop the key at the head of the array @return key that is in the head of the array

Helper to add stuff to the tree @param from key to start @param to key to end @param val value to tie with the keys @param unique allow duplicates? @p

Set the current capacity @param newCap replace node capacity with this argument.

Overflow node write structure is as follows: -- node type -- (2 bytes) -- next pointer -- (8 bytes) -- prev pointer -- (8 bytes) -- values -- (ma

Used to give us access to the actual list @return query result list reference

Insert the key into the tree while also providing the flexibility of having unique keys or not at will. @param key key to add @param value value of t

Check if the node is empty (and definitely needs merging) @return true if it is empty false if it's not.

Check if the node is an internal node @param nt nodeType of the node we want to check @return return true if it's an Internal Node, false if it's not

Check if the node in question is an overflow page @return true if the node is an overflow page, false if it's not

Returns a pseudo-random number between min and max, inclusive. The difference between min and max can be at most <code>Integer.MAX_VALUE - 1</code>.

Writes the file header containing all the juicy details @param conf valid configuration @throws IOException is thrown when an I/O operation fails

Leaf node write structure is as follows: -- node type -- (2 bytes) -- next pointer -- (8 bytes) -- prev pointer -- (8 bytes) -- key/value pairs -

Set up the basic parameters of the tree @param pageSize page size (default is 1024 bytes) @param keySize key size (default is long [8 bytes]) @par

calculates the degree of a node (internal/leaf) @param elementSize the node element size (in bytes) @param elementHeaderSize the node header size (in

Just commit the tree by actually closing the FD thus flushing the buffers. @throws IOException is thrown when an I/O operation fails @throws InvalidB

Get the page type that maps the enumeration to numbers that are easily stored in our file. @return the number representation of the node type @throws

Handy method to initialize common variables

Common method to initialize constructor parameters @param pageSize page size (default is 1024 bytes) @param keySize key size (default is long [8 byte

Grab from user the unique flag. @param sin console input library. @return the boolean user choice.

Opens a file descriptor to our B+ Tree storage file; it can handle already existing files as well without recreating them unless explicitly stated. @

Remove and pop the key at specific position @param index index that points where to remvoe the key @return removed key

Explicitly set the node type @param nodeType set the node type

Binary search implementation for tree blocks; if not found returns the lower/upper bound position instead based on `rank`. @param n node to search @pa

Calculate the page offset taking in account the for the lookup page at the start of the file. @param index index of the page @return the calculated f

Get first key @return return the first key value

Check if the node is full (and needs splitting) @param conf configuration to deduce which degree to use @return true is the node is full false if it'

Check if the node is underutilized and needs to be merged @param conf B+ Tree configuration reference @return true is the node needs to be merged or

Push a key to head of the array @param key key to push

Remove and pop the last key of the array @return key that is in the last place of the array

Search inside the B+ Tree data structure for the requested key; based on the unique flag we have two choices which are the following: unique flag tr

Set the key in the array at specific position @param index index to set the key @param key key to set in position