/// <summary>
/// Initializes a new instance of the <see cref="Sdb.BTree.Tree`2"/> class.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="nodeManager">Node manager.</param>
public Tree (ITreeNodeManager<K, V> nodeManager, bool allowDuplicateKeys = false)
{
if (nodeManager == null)
throw new ArgumentNullException ("nodeManager");
this.nodeManager = nodeManager;
this.allowDuplicateKeys = allowDuplicateKeys;
}
public TreeNode(ITreeNodeManager <K, V> nodeManager, uint id, uint parentId,
IEnumerable <Tuple <K, V> > entries = null,
IEnumerable <uint> childrenIds = null)
{
if (nodeManager == null)
{
throw new ArgumentNullException("nodeManager");
}
this.nodeManager = nodeManager;
this.childrenIds = new List <uint>();
this.entries = new List <Tuple <K, V> >(nodeManager.MaxEntriesPerNode);
this.id = id;
this.parentId = parentId;
// Make shallow copies of lists.
if (entries != null)
{
this.entries.AddRange(entries);
}
if (childrenIds != null)
{
this.childrenIds.AddRange(childrenIds);
}
}
//
// Constructors
//
/// <summary>
/// Initializes a new instance of the <see cref="Sdb.BTree.Node`2"/> class.
/// </summary>
/// <param name="branchingFactor">Branching factor.</param>
/// <param name="nodeManager">Node manager.</param>
public TreeNode(ITreeNodeManager <K, V> nodeManager
, uint id
, uint parentId
, IEnumerable <Tuple <K, V> > entries = null
, IEnumerable <uint> childrenIds = null)
{
if (nodeManager == null)
{
throw new ArgumentNullException(nameof(nodeManager));
}
this.id = id;
this.parentId = parentId;
// Setting up readonly attributes
this.nodeManager = nodeManager;
this.childrenIds = new List <uint>();
this.entries = new List <Tuple <K, V> >(this.nodeManager.MinEntriesPerNode * 2);
// Loading up data
if (entries != null)
{
this.entries.AddRange(entries);
}
if (childrenIds != null)
{
this.childrenIds.AddRange(childrenIds);
}
}
public TreeDiskNodeSerializer(ITreeNodeManager <TK, TV> nodeManager, ISerializer <TK> keySerializer,
ISerializer <TV> valueSerializer)
{
_nodeManager = nodeManager ?? throw new ArgumentNullException(nameof(nodeManager));
_keySerializer = keySerializer ?? throw new ArgumentNullException(nameof(keySerializer));
_valueSerializer = valueSerializer ?? throw new ArgumentNullException(nameof(valueSerializer));
}
public TreeEnumerator(ITreeNodeManager <TK, TV> nodeManager, TreeNode <TK, TV> node, int fromIndex, TreeTraverseDirection direction)
{
_nodeManager = nodeManager;
CurrentNode = node;
CurrentEntry = fromIndex;
_direction = direction;
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeTraverser{K,V}"/> class.
/// </summary>
/// <param name="nodeManager">Node manager.</param>
/// <param name="fromNode">From node.</param>
/// <param name="fromIndex">From index.</param>
/// <param name="direction">Direction.</param>
public TreeTraverser(ITreeNodeManager <TK, TV> nodeManager, TreeNode <TK, TV> fromNode, int fromIndex, TreeTraverseDirection direction)
{
_direction = direction;
_fromIndex = fromIndex;
_fromNode = fromNode ?? throw new ArgumentNullException(nameof(fromNode));
_nodeManager = nodeManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeEnumerator{K,V}"/> class.
/// </summary>
/// <param name="nodeManager">Node manager.</param>
/// <param name="node">Node.</param>
/// <param name="fromIndex">From index.</param>
/// <param name="direction">Direction.</param>
public TreeEnumerator (ITreeNodeManager<K, V> nodeManager
, TreeNode<K, V> node
, int fromIndex
, TreeTraverseDirection direction)
{
this.nodeManager = nodeManager;
this.currentNode = node;
this.currentEntry = fromIndex;
this.direction = direction;
}
public TreeEnumerator(ITreeNodeManager <K, V> nodeManager, TreeNode <K, V> node,
int startIndex, TreeScanDirections direction)
{
this.nodeManager = nodeManager;
this.curNode = node;
this.curIndex = startIndex;
this.scanNext = (
direction == TreeScanDirections.Ascending ?
new Func <bool>(Ascend) :
new Func <bool>(Descend)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="Sdb.BTree.TreeTraverser`2"/> class.
/// </summary>
/// <param name="nodeManager">Node manager.</param>
/// <param name="fromNode">From node.</param>
/// <param name="fromIndex">From index.</param>
/// <param name="direction">Direction.</param>
public TreeTraverser(ITreeNodeManager <K, V> nodeManager
, TreeNode <K, V> fromNode
, int fromIndex
, TreeTraverseDirection direction)
{
if (fromNode == null)
{
throw new ArgumentNullException("fromNode");
}
this.direction = direction;
this.fromIndex = fromIndex;
this.fromNode = fromNode;
this.nodeManager = nodeManager;
}
public TreeScanner(ITreeNodeManager <K, V> nodeManager, TreeNode <K, V> node,
int startIndex, TreeScanDirections direction)
{
if (nodeManager == null)
{
throw new ArgumentNullException("nodeManager");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
this.nodeManager = nodeManager;
this.node = node;
this.startIndex = startIndex;
this.direction = direction;
}
public DiskTreeNodeSerializer(ITreeNodeManager <K, V> nodeManager,
ISerializer <K> keySerializer, ISerializer <V> valueSerializer)
{
if (nodeManager == null)
{
throw new ArgumentNullException("nodeManager");
}
if (keySerializer == null)
{
throw new ArgumentNullException("keySerializer");
}
if (valueSerializer == null)
{
throw new ArgumentNullException("valueSerializer");
}
this.nodeManager = nodeManager;
this.keySerializer = keySerializer;
this.valueSerializer = valueSerializer;
}
public Tree(ITreeNodeManager <K, V> nodeManager, bool allowDuplicateKeys = false)
{
_nodeManager = nodeManager ?? throw new ArgumentNullException(nameof(nodeManager));
_allowDuplicateKeys = allowDuplicateKeys;
}
public MSSQLFiller(ITreeNodeManager treeNodeManager)
{
_treeNodeManager = treeNodeManager;
}
public IndexTree(ITreeNodeManager <byte[], uint> nodeManager, bool allowDuplicateKeys = false) : base(nodeManager, allowDuplicateKeys)
{
AllowDuplicateKeys = allowDuplicateKeys;
}
public TreeNodesController(ITreeNodeManager treeNodeManager)
{
_treeNodeManager = treeNodeManager;
}
