/*
    *  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.concurrent.atomic.AtomicInteger;
  
  
  /**
   * Store in memory the information associated with a B-tree. <br>
   * A B-tree Header on disk contains the following elements :
   * <pre>
   * +--------------------+-------------+
   * | revision           | 8 bytes     |
   * +--------------------+-------------+
   * | nbElems            | 8 bytes     |
   * +--------------------+-------------+
   * | rootPageOffset     | 8 bytes     |
   * +--------------------+-------------+
   * | BtreeHeaderOffset  | 8 bytes     |
   * +--------------------+-------------+
   * </pre>
   * Each B-tree Header will be written starting on a new page.
   * In memory, a B-tree Header store a bit more of information :
   * <li>
   * <ul>rootPage : the associated rootPage in memory</lu>
   * <ul>nbUsers : the number of readThreads using this revision</lu>
   * <ul>offset : the offset of this B-tre header</lu>
   * </li>
   *
   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
   */
  /* No qualifier*/class BTreeHeader<K, V> implements Cloneable
  {
      /** The current revision */
      private long revision = 0L;
  
      /** The number of elements in this B-tree */
      private Long nbElems = 0L;
  
      /** The offset of the B-tree RootPage */
      private long rootPageOffset;
  
      /** The position of the B-tree header in the file */
      private long btreeHeaderOffset = RecordManager.NO_PAGE;
  
      // Those are data which aren't serialized : they are in memory only */
      /** A Map containing the rootPage for this tree */
      private Page<K, V> rootPage;
  
      /** The number of users for this BtreeHeader */
      private AtomicInteger nbUsers = new AtomicInteger( 0 );
  
      /** The B-tree this header is associated with */
      private BTree<K, V> btree;
  
  
      /**
       * Creates a BTreeHeader instance
       */
      public BTreeHeader()
      {
      }
  
  
      /**
       * @return the B-tree info Offset
       */
      public long getBTreeInfoOffset()
      {
          return ( ( PersistedBTree<K, V> ) btree ).getBtreeInfoOffset();
      }
  
  
      /**
       * @return the B-tree header Offset
       */
      public long getBTreeHeaderOffset()
      {
          return btreeHeaderOffset;
      }
  
 
     /**
      * Clone the BTreeHeader
      * 
      * @return The cloned BTreeHeader
      */
     public BTreeHeader<K, V> clone()
     {
         try
         {
             BTreeHeader<K, V> copy = ( BTreeHeader<K, V> ) super.clone();
 
             return copy;
         }
         catch ( CloneNotSupportedException cnse )
         {
             return null;
         }
     }
 
 
     /**
      * Copy the current B-tree header and return the copy
      * @return The copied B-tree header
      */
     /* no qualifier */BTreeHeader<K, V> copy()
     {
         BTreeHeader<K, V> copy = clone();
 
         // Clear the fields that should not be copied
         copy.rootPage = null;
         copy.rootPageOffset = -1L;
         copy.btreeHeaderOffset = -1L;
         copy.nbUsers.set( 0 );
 
         return copy;
     }
 
 
     /**
      * Set the B-tree header offset
      * 
      * @param btreeOffset the B-tree header Offset to set
      */
     /* no qualifier */void setBTreeHeaderOffset( long btreeHeaderOffset )
     {
         this.btreeHeaderOffset = btreeHeaderOffset;
     }
 
 
     /**
      * @return the rootPageOffset
      */
     public long getRootPageOffset()
     {
         return rootPageOffset;
     }
 
 
     /**
      * Set the Root Page offset
      * 
      * @param rootPageOffset the rootPageOffset to set
      */
     /* no qualifier */void setRootPageOffset( long rootPageOffset )
     {
         this.rootPageOffset = rootPageOffset;
     }
 
 
     /**
      * @return the revision
      */
     public long getRevision()
     {
         return revision;
     }
 
 
     /**
      * Set the new revision
      * 
      * @param revision the revision to set
      */
     /* no qualifier */void setRevision( long revision )
     {
         this.revision = revision;
     }
 
 
     /**
      * @return the nbElems
      */
     public long getNbElems()
     {
         return nbElems;
     }
 
 
     /**
      * @param nbElems the nbElems to set
      */
     /* no qualifier */void setNbElems( long nbElems )
     {
         this.nbElems = nbElems;
     }
 
 
     /**
      * Increment the number of elements
      */
     /* no qualifier */void incrementNbElems()
     {
         nbElems++;
     }
 
 
     /**
      * Decrement the number of elements
      */
     /* no qualifier */void decrementNbElems()
     {
         nbElems--;
     }
 
 
     /**
      * Get the root page
      * @return the rootPage
      */
     /* no qualifier */Page<K, V> getRootPage()
     {
         return rootPage;
     }
 
 
     /**
      * Set the root page
      * @param rootPage the rootPage to set
      */
     /* no qualifier */void setRootPage( Page<K, V> rootPage )
     {
         this.rootPage = rootPage;
         this.rootPageOffset = ( ( AbstractPage<K, V> ) rootPage ).getOffset();
     }
 
 
     /**
      * Get the number of users
      * 
      * @return the nbUsers
      */
     /* no qualifier */int getNbUsers()
     {
         return nbUsers.get();
     }
 
 
     /**
      * Increment the number of users
      */
     /* no qualifier */void incrementNbUsers()
     {
         nbUsers.incrementAndGet();
     }
 
 
     /**
      * Decrement the number of users
      */
     /* no qualifier */void decrementNbUsers()
     {
         nbUsers.decrementAndGet();
     }
 
 
     /**
      * @return the B-tree
      */
     /* no qualifier */BTree<K, V> getBtree()
     {
         return btree;
     }
 
 
     /**
      * Associate a B-tree with this BTreeHeader instance
      * 
      * @param btree the B-tree to set
      */
     /* no qualifier */void setBtree( BTree<K, V> btree )
     {
         this.btree = btree;
     }
 
 
     /**
      * @see Object#toString()
      */
     public String toString()
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append( "B-treeHeader " );
         sb.append( ", offset[0x" ).append( Long.toHexString( btreeHeaderOffset ) ).append( "]" );
         sb.append( ", name[" ).append( btree.getName() ).append( "]" );
         sb.append( ", revision[" ).append( revision ).append( "]" );
         sb.append( ", btreeInfoOffset[0x" )
             .append( Long.toHexString( ( ( PersistedBTree<K, V> ) btree ).getBtreeInfoOffset() ) ).append( "]" );
         sb.append( ", rootPageOffset[0x" ).append( Long.toHexString( rootPageOffset ) ).append( "]" );
         sb.append( ", nbElems[" ).append( nbElems ).append( "]" );
         sb.append( ", nbUsers[" ).append( nbUsers.get() ).append( "]" );
 
         return sb.toString();
     }
 }