| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| package org.apache.directory.mavibot.btree; |
| |
| |
| import java.util.LinkedList; |
| |
| import org.apache.directory.mavibot.btree.serializer.ElementSerializer; |
| |
| |
| /** |
| * This class construct a B-tree from a serialized version of a B-tree. We need it |
| * to avoid exposing all the methods of the B-tree class.<br> |
| * |
| * All its methods are static. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| * |
| * @param <K> The B-tree key type |
| * @param <V> The B-tree value type |
| */ |
| public class BTreeFactory<K, V> |
| { |
| //-------------------------------------------------------------------------------------------- |
| // Create persisted btrees |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Creates a new persisted B-tree, with no initialization. |
| * |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree() |
| { |
| BTree<K, V> btree = new PersistedBTree<K, V>(); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree, with no initialization. |
| * |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( BTreeTypeEnum type ) |
| { |
| BTree<K, V> btree = new PersistedBTree<K, V>(); |
| ( ( AbstractBTree<K, V> ) btree ).setType( type ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Sets the btreeHeader offset for a Persisted BTree |
| * |
| * @param btree The btree to update |
| * @param btreeHeaderOffset The offset |
| */ |
| public static <K, V> void setBtreeHeaderOffset( PersistedBTree<K, V> btree, long btreeHeaderOffset ) |
| { |
| btree.setBtreeHeaderOffset( btreeHeaderOffset ); |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the BTreeConfiguration to initialize the |
| * B-tree |
| * |
| * @param configuration The configuration to use |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( PersistedBTreeConfiguration<K, V> configuration ) |
| { |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setCacheSize( PersistedBTree.DEFAULT_CACHE_SIZE ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, boolean allowDuplicates ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setCacheSize( PersistedBTree.DEFAULT_CACHE_SIZE ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @param cacheSize The size to be used for this B-tree cache |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, boolean allowDuplicates, int cacheSize ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setCacheSize( cacheSize ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, int pageSize ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setCacheSize( PersistedBTree.DEFAULT_CACHE_SIZE ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, int pageSize, boolean allowDuplicates ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setCacheSize( PersistedBTree.DEFAULT_CACHE_SIZE ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new persisted B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @param cacheSize The size to be used for this B-tree cache |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createPersistedBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, int pageSize, boolean allowDuplicates, int cacheSize ) |
| { |
| PersistedBTreeConfiguration<K, V> configuration = new PersistedBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setCacheSize( cacheSize ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new PersistedBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Create in-memory B-trees |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Creates a new in-memory B-tree, with no initialization. |
| * |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree() |
| { |
| BTree<K, V> btree = new InMemoryBTree<K, V>(); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the BTreeConfiguration to initialize the |
| * B-tree |
| * |
| * @param configuration The configuration to use |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( InMemoryBTreeConfiguration<K, V> configuration ) |
| { |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, boolean allowDuplicates ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, int pageSize ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param filePath The name of the data directory with absolute path |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, String filePath, |
| ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setFilePath( filePath ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( BTree.DEFAULT_PAGE_SIZE ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param filePath The name of the data directory with absolute path |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, String filePath, |
| ElementSerializer<K> keySerializer, ElementSerializer<V> valueSerializer, int pageSize ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setFilePath( filePath ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( BTree.FORBID_DUPLICATES ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| /** |
| * Creates a new in-memory B-tree using the parameters to initialize the |
| * B-tree |
| * |
| * @param name The B-tree's name |
| * @param filePath The name of the data directory with absolute path |
| * @param keySerializer Key serializer |
| * @param valueSerializer Value serializer |
| * @param pageSize Size of the page |
| * @param allowDuplicates Tells if the B-tree allows multiple value for a given key |
| * @return a new B-tree instance |
| */ |
| public static <K, V> BTree<K, V> createInMemoryBTree( String name, String filePath, |
| ElementSerializer<K> keySerializer, |
| ElementSerializer<V> valueSerializer, int pageSize, boolean allowDuplicates ) |
| { |
| InMemoryBTreeConfiguration<K, V> configuration = new InMemoryBTreeConfiguration<K, V>(); |
| |
| configuration.setName( name ); |
| configuration.setFilePath( filePath ); |
| configuration.setKeySerializer( keySerializer ); |
| configuration.setValueSerializer( valueSerializer ); |
| configuration.setPageSize( pageSize ); |
| configuration.setAllowDuplicates( allowDuplicates ); |
| configuration.setWriteBufferSize( BTree.DEFAULT_WRITE_BUFFER_SIZE ); |
| |
| BTree<K, V> btree = new InMemoryBTree<K, V>( configuration ); |
| |
| return btree; |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Create Pages |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Create a new Leaf for the given B-tree. |
| * |
| * @param btree The B-tree which will contain this leaf |
| * @param revision The Leaf's revision |
| * @param nbElems The number or elements in this leaf |
| * |
| * @return A Leaf instance |
| */ |
| /* no qualifier*/static <K, V> Page<K, V> createLeaf( BTree<K, V> btree, long revision, int nbElems ) |
| { |
| if ( btree.getType() != BTreeTypeEnum.IN_MEMORY ) |
| { |
| return new PersistedLeaf<K, V>( btree, revision, nbElems ); |
| } |
| else |
| { |
| return new InMemoryLeaf<K, V>( btree, revision, nbElems ); |
| } |
| } |
| |
| |
| /** |
| * Create a new Node for the given B-tree. |
| * |
| * @param btree The B-tree which will contain this node |
| * @param revision The Node's revision |
| * @param nbElems The number or elements in this node |
| * @return A Node instance |
| */ |
| /* no qualifier*/static <K, V> Page<K, V> createNode( BTree<K, V> btree, long revision, int nbElems ) |
| { |
| if ( btree.getType() != BTreeTypeEnum.IN_MEMORY ) |
| { |
| //System.out.println( "Creating a node with nbElems : " + nbElems ); |
| return new PersistedNode<K, V>( btree, revision, nbElems ); |
| } |
| else |
| { |
| return new InMemoryNode<K, V>( btree, revision, nbElems ); |
| } |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Update pages |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Set the key at a give position |
| * |
| * @param btree The B-tree to update |
| * @param page The page to update |
| * @param pos The position in the keys array |
| * @param key The key to inject |
| */ |
| /* no qualifier*/static <K, V> void setKey( BTree<K, V> btree, Page<K, V> page, int pos, K key ) |
| { |
| KeyHolder<K> keyHolder; |
| |
| if ( btree.getType() != BTreeTypeEnum.IN_MEMORY ) |
| { |
| keyHolder = new PersistedKeyHolder<K>( btree.getKeySerializer(), key ); |
| } |
| else |
| { |
| keyHolder = new KeyHolder<K>( key ); |
| } |
| |
| ( ( AbstractPage<K, V> ) page ).setKey( pos, keyHolder ); |
| } |
| |
| |
| /** |
| * Set the value at a give position |
| * |
| * @param btree The B-tree to update |
| * @param page The page to update |
| * @param pos The position in the values array |
| * @param value the value to inject |
| */ |
| /* no qualifier*/static <K, V> void setValue( BTree<K, V> btree, Page<K, V> page, int pos, ValueHolder<V> value ) |
| { |
| if ( btree.getType() != BTreeTypeEnum.IN_MEMORY ) |
| { |
| ( ( PersistedLeaf<K, V> ) page ).setValue( pos, value ); |
| } |
| else |
| { |
| ( ( InMemoryLeaf<K, V> ) page ).setValue( pos, value ); |
| } |
| } |
| |
| |
| /** |
| * Set the page at a give position |
| * |
| * @param btree The B-tree to update |
| * @param page The page to update |
| * @param pos The position in the values array |
| * @param child the child page to inject |
| */ |
| /* no qualifier*/static <K, V> void setPage( BTree<K, V> btree, Page<K, V> page, int pos, Page<K, V> child ) |
| { |
| if ( btree.getType() != BTreeTypeEnum.IN_MEMORY ) |
| { |
| ( ( PersistedNode<K, V> ) page ).setValue( pos, new PersistedPageHolder<K, V>( btree, child ) ); |
| } |
| else |
| { |
| ( ( InMemoryNode<K, V> ) page ).setPageHolder( pos, new PageHolder<K, V>( btree, child ) ); |
| } |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Update B-tree |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Sets the KeySerializer into the B-tree |
| * |
| * @param btree The B-tree to update |
| * @param keySerializerFqcn the Key serializer FQCN to set |
| * @throws ClassNotFoundException If the key serializer class cannot be found |
| * @throws InstantiationException If the key serializer class cannot be instanciated |
| * @throws IllegalAccessException If the key serializer class cannot be accessed |
| * @throws NoSuchFieldException |
| * @throws SecurityException |
| * @throws IllegalArgumentException |
| */ |
| /* no qualifier*/static <K, V> void setKeySerializer( BTree<K, V> btree, String keySerializerFqcn ) |
| throws ClassNotFoundException, IllegalAccessException, InstantiationException, IllegalArgumentException, |
| SecurityException, NoSuchFieldException |
| { |
| Class<?> keySerializer = Class.forName( keySerializerFqcn ); |
| @SuppressWarnings("unchecked") |
| ElementSerializer<K> instance = null; |
| try |
| { |
| instance = ( ElementSerializer<K> ) keySerializer.getDeclaredField( "INSTANCE" ).get( null ); |
| } |
| catch ( NoSuchFieldException e ) |
| { |
| // ignore |
| } |
| |
| if ( instance == null ) |
| { |
| instance = ( ElementSerializer<K> ) keySerializer.newInstance(); |
| } |
| |
| btree.setKeySerializer( instance ); |
| } |
| |
| |
| /** |
| * Sets the ValueSerializer into the B-tree |
| * |
| * @param btree The B-tree to update |
| * @param valueSerializerFqcn the Value serializer FQCN to set |
| * @throws ClassNotFoundException If the value serializer class cannot be found |
| * @throws InstantiationException If the value serializer class cannot be instanciated |
| * @throws IllegalAccessException If the value serializer class cannot be accessed |
| * @throws NoSuchFieldException |
| * @throws SecurityException |
| * @throws IllegalArgumentException |
| */ |
| /* no qualifier*/static <K, V> void setValueSerializer( BTree<K, V> btree, String valueSerializerFqcn ) |
| throws ClassNotFoundException, IllegalAccessException, InstantiationException, IllegalArgumentException, |
| SecurityException, NoSuchFieldException |
| { |
| Class<?> valueSerializer = Class.forName( valueSerializerFqcn ); |
| @SuppressWarnings("unchecked") |
| ElementSerializer<V> instance = null; |
| try |
| { |
| instance = ( ElementSerializer<V> ) valueSerializer.getDeclaredField( "INSTANCE" ).get( null ); |
| } |
| catch ( NoSuchFieldException e ) |
| { |
| // ignore |
| } |
| |
| if ( instance == null ) |
| { |
| instance = ( ElementSerializer<V> ) valueSerializer.newInstance(); |
| } |
| |
| btree.setValueSerializer( instance ); |
| } |
| |
| |
| /** |
| * Set the new root page for this tree. Used for debug purpose only. The revision |
| * will always be 0; |
| * |
| * @param btree The B-tree to update |
| * @param root the new root page. |
| */ |
| /* no qualifier*/static <K, V> void setRootPage( BTree<K, V> btree, Page<K, V> root ) |
| { |
| ( ( AbstractBTree<K, V> ) btree ).setRootPage( root ); |
| } |
| |
| |
| /** |
| * Return the B-tree root page |
| * |
| * @param btree The B-tree we want to root page from |
| * @return The root page |
| */ |
| /* no qualifier */static <K, V> Page<K, V> getRootPage( BTree<K, V> btree ) |
| { |
| return btree.getRootPage(); |
| } |
| |
| |
| /** |
| * Update the B-tree number of elements |
| * |
| * @param btree The B-tree to update |
| * @param nbElems the nbElems to set |
| */ |
| /* no qualifier */static <K, V> void setNbElems( BTree<K, V> btree, long nbElems ) |
| { |
| ( ( AbstractBTree<K, V> ) btree ).setNbElems( nbElems ); |
| } |
| |
| |
| /** |
| * Update the B-tree revision |
| * |
| * @param btree The B-tree to update |
| * @param revision the revision to set |
| */ |
| /* no qualifier*/static <K, V> void setRevision( BTree<K, V> btree, long revision ) |
| { |
| ( ( AbstractBTree<K, V> ) btree ).setRevision( revision ); |
| } |
| |
| |
| /** |
| * Set the B-tree name |
| * |
| * @param btree The B-tree to update |
| * @param name the name to set |
| */ |
| /* no qualifier */static <K, V> void setName( BTree<K, V> btree, String name ) |
| { |
| btree.setName( name ); |
| } |
| |
| |
| /** |
| * Set the maximum number of elements we can store in a page. |
| * |
| * @param btree The B-tree to update |
| * @param pageSize The requested page size |
| */ |
| /* no qualifier */static <K, V> void setPageSize( BTree<K, V> btree, int pageSize ) |
| { |
| btree.setPageSize( pageSize ); |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Utility method |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Includes the intermediate nodes in the path up to and including the right most leaf of the tree |
| * |
| * @param btree the B-tree |
| * @return a LinkedList of all the nodes and the final leaf |
| */ |
| /* no qualifier*/static <K, V> LinkedList<ParentPos<K, V>> getPathToRightMostLeaf( BTree<K, V> btree ) |
| { |
| LinkedList<ParentPos<K, V>> stack = new LinkedList<ParentPos<K, V>>(); |
| |
| ParentPos<K, V> last = new ParentPos<K, V>( btree.getRootPage(), btree.getRootPage().getNbElems() ); |
| stack.push( last ); |
| |
| if ( btree.getRootPage().isLeaf() ) |
| { |
| Page<K, V> leaf = btree.getRootPage(); |
| ValueHolder<V> valueHolder = ( ( AbstractPage<K, V> ) leaf ).getValue( last.pos ); |
| last.valueCursor = valueHolder.getCursor(); |
| } |
| else |
| { |
| Page<K, V> node = btree.getRootPage(); |
| |
| while ( true ) |
| { |
| Page<K, V> p = ( ( AbstractPage<K, V> ) node ).getPage( node.getNbElems() ); |
| |
| last = new ParentPos<K, V>( p, p.getNbElems() ); |
| stack.push( last ); |
| |
| if ( p.isLeaf() ) |
| { |
| Page<K, V> leaf = last.page; |
| ValueHolder<V> valueHolder = ( ( AbstractPage<K, V> ) leaf ).getValue( last.pos ); |
| last.valueCursor = valueHolder.getCursor(); |
| break; |
| } |
| } |
| } |
| |
| return stack; |
| } |
| |
| |
| //-------------------------------------------------------------------------------------------- |
| // Persisted B-tree methods |
| //-------------------------------------------------------------------------------------------- |
| /** |
| * Set the rootPage offset of the B-tree |
| * |
| * @param btree The B-tree to update |
| * @param rootPageOffset The rootPageOffset to set |
| */ |
| /* no qualifier*/static <K, V> void setRootPageOffset( BTree<K, V> btree, long rootPageOffset ) |
| { |
| if ( btree instanceof PersistedBTree ) |
| { |
| ( ( PersistedBTree<K, V> ) btree ).getBtreeHeader().setRootPageOffset( rootPageOffset ); |
| } |
| else |
| { |
| throw new IllegalArgumentException( "The B-tree must be a PersistedBTree" ); |
| } |
| } |
| |
| |
| /** |
| * Set the RecordManager |
| * |
| * @param btree The B-tree to update |
| * @param recordManager The injected RecordManager |
| */ |
| /* no qualifier*/static <K, V> void setRecordManager( BTree<K, V> btree, RecordManager recordManager ) |
| { |
| if ( btree instanceof PersistedBTree ) |
| { |
| ( ( PersistedBTree<K, V> ) btree ).setRecordManager( recordManager ); |
| } |
| else |
| { |
| throw new IllegalArgumentException( "The B-tree must be a PersistedBTree" ); |
| } |
| } |
| |
| |
| /** |
| * Set the key at a give position |
| * |
| * @param btree The B-tree to update |
| * @param page The page to update |
| * @param pos The position of this key in the page |
| * @param buffer The byte[] containing the serialized key |
| */ |
| /* no qualifier*/static <K, V> void setKey( BTree<K, V> btree, Page<K, V> page, int pos, byte[] buffer ) |
| { |
| if ( btree instanceof PersistedBTree ) |
| { |
| KeyHolder<K> keyHolder = new PersistedKeyHolder<K>( btree.getKeySerializer(), buffer ); |
| ( ( AbstractPage<K, V> ) page ).setKey( pos, keyHolder ); |
| } |
| else |
| { |
| throw new IllegalArgumentException( "The B-tree must be a PersistedBTree" ); |
| } |
| } |
| |
| |
| /** |
| * Includes the intermediate nodes in the path up to and including the left most leaf of the tree |
| * |
| * @param btree The B-tree to process |
| * @return a LinkedList of all the nodes and the final leaf |
| */ |
| /* no qualifier*/static <K, V> LinkedList<ParentPos<K, V>> getPathToLeftMostLeaf( BTree<K, V> btree ) |
| { |
| if ( btree instanceof PersistedBTree ) |
| { |
| LinkedList<ParentPos<K, V>> stack = new LinkedList<ParentPos<K, V>>(); |
| |
| ParentPos<K, V> first = new ParentPos<K, V>( btree.getRootPage(), 0 ); |
| stack.push( first ); |
| |
| if ( btree.getRootPage().isLeaf() ) |
| { |
| Page<K, V> leaf = btree.getRootPage(); |
| ValueHolder<V> valueHolder = ( ( AbstractPage<K, V> ) leaf ).getValue( first.pos ); |
| first.valueCursor = valueHolder.getCursor(); |
| } |
| else |
| { |
| Page<K, V> node = btree.getRootPage(); |
| |
| while ( true ) |
| { |
| Page<K, V> page = ( ( AbstractPage<K, V> ) node ).getPage( 0 ); |
| |
| first = new ParentPos<K, V>( page, 0 ); |
| stack.push( first ); |
| |
| if ( page.isLeaf() ) |
| { |
| ValueHolder<V> valueHolder = ( ( AbstractPage<K, V> ) page ).getValue( first.pos ); |
| first.valueCursor = valueHolder.getCursor(); |
| break; |
| } |
| } |
| } |
| |
| return stack; |
| } |
| else |
| { |
| throw new IllegalArgumentException( "The B-tree must be a PersistedBTree" ); |
| } |
| } |
| } |
