text:
/*-------------------------------------------------------------------------
 *
 * Created:		H5HFiblock.c
 *			Apr 10 2006
 *			Quincey Koziol <koziol@ncsa.uiuc.edu>
 *
 * Purpose:		Indirect block routines for fractal heaps.
 *
 *-------------------------------------------------------------------------
 */

/****************/
/* Module Setup */
/****************/

#include "H5HFmodule.h"         /* This source code file is part of the H5HF module */

/***********/
/* Headers */
/***********/
#include "H5private.h"		/* Generic Functions			*/
#include "H5Eprivate.h"		/* Error handling		  	*/
#include "H5Fprivate.h"		/* File access				*/
#include "H5HFpkg.h"		/* Fractal heaps			*/
#include "H5MFprivate.h"	/* File memory management		*/
#include "H5VMprivate.h"		/* Vectors and arrays 			*/

/****************/
/* Local Macros */
/****************/

/******************/
/* Local Typedefs */
/******************/

/********************/
/* Package Typedefs */
/********************/

/********************/
/* Local Prototypes */
/********************/
static herr_t H5HF_iblock_pin(H5HF_indirect_t *iblock);
static herr_t H5HF_iblock_unpin(H5HF_indirect_t *iblock);
static herr_t H5HF_man_iblock_root_halve(H5HF_indirect_t *root_iblock, hid_t dxpl_id);
static herr_t H5HF_man_iblock_root_revert(H5HF_indirect_t *root_iblock, hid_t dxpl_id);

/*********************/
/* Package Variables */
/*********************/

/* Declare a free list to manage the H5HF_indirect_t struct */
H5FL_DEFINE(H5HF_indirect_t);

/* Declare a free list to manage the H5HF_indirect_ent_t sequence information */
H5FL_SEQ_DEFINE(H5HF_indirect_ent_t);

/* Declare a free list to manage the H5HF_indirect_filt_ent_t sequence information */
H5FL_SEQ_DEFINE(H5HF_indirect_filt_ent_t);

/* Declare a free list to manage the H5HF_indirect_t * sequence information */
H5FL_SEQ_DEFINE(H5HF_indirect_ptr_t);

/*****************************/
/* Library Private Variables */
/*****************************/

/*******************/
/* Local Variables */
/*******************/

/*-------------------------------------------------------------------------
 * Function:	H5HF_iblock_pin
 *
 * Purpose:	Pin an indirect block in memory
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@hdfgroup.org
 *		Aug 17 2006
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5HF_iblock_pin(H5HF_indirect_t *iblock)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity checks */
    HDassert(iblock);

    /* Mark block as un-evictable */
    if(H5AC_pin_protected_entry(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTPIN, FAIL, "unable to pin fractal heap indirect block")

    /* If this indirect block has a parent, update it's child iblock pointer */
    if(iblock->parent) {
        H5HF_indirect_t *par_iblock = iblock->parent;    /* Parent indirect block */
        unsigned indir_idx;             /* Index in parent's child iblock pointer array */

        /* Sanity check */
        HDassert(par_iblock->child_iblocks);
        HDassert(iblock->par_entry >= (iblock->hdr->man_dtable.max_direct_rows
                * iblock->hdr->man_dtable.cparam.width));

        /* Compute index in parent's child iblock pointer array */
        indir_idx = iblock->par_entry - (iblock->hdr->man_dtable.max_direct_rows
                * iblock->hdr->man_dtable.cparam.width);

        /* Set pointer to pinned indirect block in parent */
        HDassert(par_iblock->child_iblocks[indir_idx] == NULL);
        par_iblock->child_iblocks[indir_idx] = iblock;
    } /* end if */
    else {
        /* Check for pinning the root indirect block */
        if(iblock->block_off == 0) {
            /* Sanity check - shouldn't be recursively pinning root indirect block */
            HDassert(0 == (iblock->hdr->root_iblock_flags & H5HF_ROOT_IBLOCK_PINNED));

            /* Check if we should set the root iblock pointer */
            if(0 == iblock->hdr->root_iblock_flags) {
                HDassert(NULL == iblock->hdr->root_iblock);
                iblock->hdr->root_iblock = iblock;
            } /* end if */

            /* Indicate that the root indirect block is pinned */
            iblock->hdr->root_iblock_flags |= H5HF_ROOT_IBLOCK_PINNED;
        } /* end if */
    } /* end if */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_pin() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_iblock_unpin
 *
 * Purpose:	Unpin an indirect block in the metadata cache
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@hdfgroup.org
 *		Aug 17 2006
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5HF_iblock_unpin(H5HF_indirect_t *iblock)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity check */
    HDassert(iblock);

    /* If this indirect block has a parent, reset it's child iblock pointer */
    if(iblock->parent) {
        H5HF_indirect_t *par_iblock = iblock->parent;    /* Parent indirect block */
        unsigned indir_idx;             /* Index in parent's child iblock pointer array */

        /* Sanity check */
        HDassert(par_iblock->child_iblocks);
        HDassert(iblock->par_entry >= (iblock->hdr->man_dtable.max_direct_rows
                * iblock->hdr->man_dtable.cparam.width));

        /* Compute index in parent's child iblock pointer array */
        indir_idx = iblock->par_entry - (iblock->hdr->man_dtable.max_direct_rows
                * iblock->hdr->man_dtable.cparam.width);

        /* Reset pointer to pinned child indirect block in parent */
        HDassert(par_iblock->child_iblocks[indir_idx]);
        par_iblock->child_iblocks[indir_idx] = NULL;
    } /* end if */
    else {
        /* Check for root indirect block */
        if(iblock->block_off == 0) {
            /* Sanity check - shouldn't be recursively unpinning root indirect block */
            HDassert(iblock->hdr->root_iblock_flags & H5HF_ROOT_IBLOCK_PINNED);

            /* Check if we should reset the root iblock pointer */
            if(H5HF_ROOT_IBLOCK_PINNED == iblock->hdr->root_iblock_flags) {
                HDassert(NULL != iblock->hdr->root_iblock);
                iblock->hdr->root_iblock = NULL;
            } /* end if */

            /* Indicate that the root indirect block is unpinned */
            iblock->hdr->root_iblock_flags &= (unsigned)(~(H5HF_ROOT_IBLOCK_PINNED));
        } /* end if */
    } /* end else */

    /* Mark block as evictable again */
    if(H5AC_unpin_entry(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPIN, FAIL, "unable to unpin fractal heap indirect block")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_unpin() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_iblock_incr
 *
 * Purpose:	Increment reference count on shared indirect block
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Mar 27 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_iblock_incr(H5HF_indirect_t *iblock)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity checks */
    HDassert(iblock);
    HDassert(iblock->block_off == 0 || iblock->parent);

    /* Mark block as un-evictable when a child block is depending on it */
    if(iblock->rc == 0)
        if(H5HF_iblock_pin(iblock) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTPIN, FAIL, "unable to pin fractal heap indirect block")

    /* Increment reference count on shared indirect block */
    iblock->rc++;

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_incr() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_iblock_decr
 *
 * Purpose:	Decrement reference count on shared indirect block
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Mar 27 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_iblock_decr(H5HF_indirect_t *iblock)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity check */
    HDassert(iblock);

    /* Decrement reference count on shared indirect block */
    iblock->rc--;

    /* Mark block as evictable again when no child blocks depend on it */
    if(iblock->rc == 0) {
        H5HF_hdr_t *hdr;			/* Fractal heap header */
        haddr_t iblock_addr;		/* Address of fractal heap */
        hbool_t expunge_iblock = FALSE;     /* Whether to expunge indirect block from heap */

        /* Set up convenience variables */
        hdr = iblock->hdr;
        iblock_addr = iblock->addr;

        if(iblock->nchildren == 0) {
            /* Check for deleting root indirect block (and no root direct block) */
            if(iblock->block_off == 0 && hdr->man_dtable.curr_root_rows > 0) {
                /* Reset root pointer information */
                hdr->man_dtable.curr_root_rows = 0;
                hdr->man_dtable.table_addr = HADDR_UNDEF;

                /* Reset header information back to "empty heap" state */
                if(H5HF_hdr_empty(hdr) < 0)
                    HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't make heap empty")
            } /* end if */

            /* Detach from parent indirect block */
            if(iblock->parent) {
                /* Detach from parent indirect block */
                if(H5HF_man_iblock_detach(iblock->parent, H5AC_ind_read_dxpl_id, iblock->par_entry) < 0)
                    HGOTO_ERROR(H5E_HEAP, H5E_CANTATTACH, FAIL, "can't detach from parent indirect block")
                iblock->parent = NULL;
                iblock->par_entry = 0;
            } /* end if */

	    /* Mark indirect block for removal from the metadata cache */
	    expunge_iblock = TRUE;
        } /* end if */

	/* Unpin the indirect block */
        if(H5HF_iblock_unpin(iblock) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPIN, FAIL, "unable to unpin fractal heap indirect block")

	/* Check for expunging the indirect block from the metadata cache */
	if(expunge_iblock) {
            unsigned cache_flags = H5AC__NO_FLAGS_SET;

            /* if the indirect block is in real file space, tell
             * the cache to free its file space.
             */
            if (!H5F_IS_TMP_ADDR(hdr->f, iblock_addr))
                cache_flags |= H5AC__FREE_FILE_SPACE_FLAG;

            if(H5AC_expunge_entry(hdr->f, H5AC_ind_read_dxpl_id, H5AC_FHEAP_IBLOCK, iblock_addr, cache_flags) < 0)
                HGOTO_ERROR(H5E_HEAP, H5E_CANTREMOVE, FAIL, "unable to remove indirect block from cache")
        } /* end if */
    } /* end if */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_decr() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_iblock_dirty
 *
 * Purpose:	Mark indirect block as dirty
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Mar 21 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_iblock_dirty(H5HF_indirect_t *iblock)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity check */
    HDassert(iblock);

    /* Mark indirect block as dirty in cache */
    if(H5AC_mark_entry_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTMARKDIRTY, FAIL, "unable to mark fractal heap indirect block as dirty")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_dirty() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_root_create
 *
 * Purpose:	Create root indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		May  2 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_root_create(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_size)
{
    H5HF_indirect_t *iblock;        /* Pointer to indirect block */
    haddr_t iblock_addr;            /* Indirect block's address */
    hsize_t acc_dblock_free;        /* Accumulated free space in direct blocks */
    hbool_t have_direct_block;      /* Flag to indicate a direct block already exists */
    hbool_t did_protect;            /* Whether we protected the indirect block or not */
    unsigned nrows;                 /* Number of rows for root indirect block */
    unsigned u;                     /* Local index variable */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Check for allocating entire root indirect block initially */
    if(hdr->man_dtable.cparam.start_root_rows == 0)
        nrows = hdr->man_dtable.max_root_rows;
    else {
        unsigned rows_needed;   /* Number of rows needed to get to direct block size */
        unsigned block_row_off; /* Row offset from larger block sizes */

        nrows = hdr->man_dtable.cparam.start_root_rows;

        block_row_off = H5VM_log2_of2((uint32_t)min_dblock_size) - H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size);
        if(block_row_off > 0)
            block_row_off++;        /* Account for the pair of initial rows of the initial block size */
        rows_needed = 1 + block_row_off;
        if(nrows < rows_needed)
            nrows = rows_needed;
    } /* end else */

    /* Allocate root indirect block */
    if(H5HF_man_iblock_create(hdr, dxpl_id, NULL, 0, nrows, hdr->man_dtable.max_root_rows, &iblock_addr) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate fractal heap indirect block")

    /* Move current direct block (used as root) into new indirect block */

    /* Lock new indirect block */
    if(NULL == (iblock = H5HF_man_iblock_protect(hdr, dxpl_id, iblock_addr, nrows, NULL, 0, FALSE, H5AC__NO_FLAGS_SET, &did_protect)))
        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap indirect block")

    /* Check if there's already a direct block as root) */
    have_direct_block = H5F_addr_defined(hdr->man_dtable.table_addr);
    if(have_direct_block) {
        H5HF_direct_t *dblock;          /* Pointer to direct block to query */

        /* Lock first (root) direct block */
        if(NULL == (dblock = H5HF_man_dblock_protect(hdr, dxpl_id, hdr->man_dtable.table_addr, hdr->man_dtable.cparam.start_block_size, NULL, 0, H5AC__NO_FLAGS_SET)))
            HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap direct block")

        /* Attach direct block to new root indirect block */
        dblock->parent = iblock;
        dblock->fd_parent = iblock;
        dblock->par_entry = 0;

	/* destroy flush dependency between direct block and header */
	if(H5AC_destroy_flush_dependency(dblock->hdr, dblock) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, \
                        "unable to destroy flush dependency")

	/* create flush dependency between direct block and new root indirect block */
	if(H5AC_create_flush_dependency(dblock->parent, dblock) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, \
		        "unable to create flush dependency")

        if(H5HF_man_iblock_attach(iblock, 0, hdr->man_dtable.table_addr) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTATTACH, FAIL, "can't attach root direct block to parent indirect block")

        /* Check for I/O filters on this heap */
        if(hdr->filter_len > 0) {
            /* Set the pipeline filter information from the header */
            iblock->filt_ents[0].size = hdr->pline_root_direct_size;
            iblock->filt_ents[0].filter_mask = hdr->pline_root_direct_filter_mask;

            /* Reset the header's pipeline information */
            hdr->pline_root_direct_size = 0;
            hdr->pline_root_direct_filter_mask = 0;
        } /* end if */

        /* Scan free space sections to set any 'parent' pointers to new indirect block */
        if(H5HF_space_create_root(hdr, dxpl_id, iblock) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTSET, FAIL, "can't set free space section info to new root indirect block")

        /* Unlock first (previously the root) direct block */
        if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_FHEAP_DBLOCK, hdr->man_dtable.table_addr, dblock, H5AC__NO_FLAGS_SET) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap direct block")
        dblock = NULL;
    } /* end if */

    /* Start iterator at correct location */
    if(H5HF_hdr_start_iter(hdr, iblock, (hsize_t)(have_direct_block ? hdr->man_dtable.cparam.start_block_size : 0), have_direct_block) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize block iterator")

    /* Check for skipping over direct blocks, in order to get to large enough block */
    if(min_dblock_size > hdr->man_dtable.cparam.start_block_size) {
        /* Add skipped blocks to heap's free space */
        if(H5HF_hdr_skip_blocks(hdr, dxpl_id, iblock, have_direct_block,
                ((nrows - 1) * hdr->man_dtable.cparam.width) - have_direct_block) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't add skipped blocks to heap's free space")
    } /* end if */

    /* Mark indirect block as modified */
    if(H5HF_iblock_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark indirect block as dirty")

    /* Unprotect root indirect block (it's pinned by the iterator though) */
    if(H5HF_man_iblock_unprotect(iblock, dxpl_id, H5AC__DIRTIED_FLAG, did_protect) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap indirect block")
    iblock = NULL;

    /* Point heap header at new indirect block */
    hdr->man_dtable.curr_root_rows = nrows;
    hdr->man_dtable.table_addr = iblock_addr;

    /* Compute free space in direct blocks referenced from entries in root indirect block */
    acc_dblock_free = 0;
    for(u = 0; u < nrows; u++)
        acc_dblock_free += hdr->man_dtable.row_tot_dblock_free[u] * hdr->man_dtable.cparam.width;

    /* Account for potential initial direct block */
    if(have_direct_block)
        acc_dblock_free -= hdr->man_dtable.row_tot_dblock_free[0];

    /* Extend heap to cover new root indirect block */
    if(H5HF_hdr_adjust_heap(hdr, hdr->man_dtable.row_block_off[nrows], (hssize_t)acc_dblock_free) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, FAIL, "can't increase space to cover root direct block")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_root_create() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_root_double
 *
 * Purpose:	Double size of root indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Apr 17 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_root_double(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_size)
{
    H5HF_indirect_t *iblock;    /* Pointer to root indirect block */
    haddr_t new_addr;           /* New address of indirect block */
    hsize_t acc_dblock_free;    /* Accumulated free space in direct blocks */
    hsize_t next_size;          /* The previous value of the "next size" for the new block iterator */
    hsize_t old_iblock_size;    /* Old size of indirect block */
    unsigned next_row;          /* The next row to allocate block in */
    unsigned next_entry;        /* The previous value of the "next entry" for the new block iterator */
    unsigned new_next_entry = 0;/* The new value of the "next entry" for the new block iterator */
    unsigned min_nrows = 0;     /* Min. # of direct rows */
    unsigned old_nrows;         /* Old # of rows */
    unsigned new_nrows;         /* New # of rows */
    hbool_t skip_direct_rows = FALSE;   /* Whether we are skipping direct rows */
    size_t u;                   /* Local index variable */
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Get "new block" iterator information */
    if(H5HF_man_iter_curr(&hdr->next_block, &next_row, NULL, &next_entry, &iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "unable to retrieve current block iterator location")
    next_size = hdr->man_dtable.row_block_size[next_row];

    /* Make certain the iterator is at the root indirect block */
    HDassert(iblock->parent == NULL);
    HDassert(iblock->block_off == 0);

    /* Keep this for later */
    old_nrows = iblock->nrows;

    /* Check for skipping over direct block rows */
    if(iblock->nrows < hdr->man_dtable.max_direct_rows && min_dblock_size > next_size) {
        /* Sanity check */
        HDassert(min_dblock_size > hdr->man_dtable.cparam.start_block_size);

        /* Set flag */
        skip_direct_rows = TRUE;

        /* Make certain we allocate at least the required row for the block requested */
        min_nrows = 1 + H5HF_dtable_size_to_row(&hdr->man_dtable, min_dblock_size);

        /* Set the information for the next block, of the appropriate size */
        new_next_entry = (min_nrows - 1) * hdr->man_dtable.cparam.width;
    } /* end if */

    /* Compute new # of rows in indirect block */
    new_nrows = MAX(min_nrows, MIN(2 * iblock->nrows, iblock->max_rows));

    /* Check if the indirect block is NOT currently allocated in temp. file space */
    /* (temp. file space does not need to be freed) */
    if(!H5F_IS_TMP_ADDR(hdr->f, iblock->addr)) {
/* Currently, the old block data is "thrown away" after the space is reallocated,
* to avoid data copy in H5MF_realloc() call by just free'ing the space and
* allocating new space.
*
* This also keeps the file smaller, by freeing the space and then
* allocating new space, instead of vice versa (in H5MF_realloc).
*
* QAK - 3/14/2006
*/
        /* Free previous indirect block disk space */
        if(H5MF_xfree(hdr->f, H5FD_MEM_FHEAP_IBLOCK, dxpl_id, iblock->addr, (hsize_t)iblock->size) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap indirect block file space")
    } /* end if */

    /* Compute size of buffer needed for new indirect block */
    iblock->nrows = new_nrows;
    old_iblock_size = iblock->size;
    iblock->size = H5HF_MAN_INDIRECT_SIZE(hdr, iblock->nrows);

    /* Allocate [temporary] space for the new indirect block on disk */
    if(H5F_USE_TMP_SPACE(hdr->f)) {
        if(HADDR_UNDEF == (new_addr = H5MF_alloc_tmp(hdr->f, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end if */
    else {
        if(HADDR_UNDEF == (new_addr = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_IBLOCK, dxpl_id, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end else */

    /* Resize pinned indirect block in the cache, if its changed size */
    if(old_iblock_size != iblock->size) {
        if(H5AC_resize_entry(iblock, (size_t)iblock->size) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize fractal heap indirect block")
    } /* end if */

    /* Move object in cache, if it actually was relocated */
    if(H5F_addr_ne(iblock->addr, new_addr)) {
        if(H5AC_move_entry(hdr->f, H5AC_FHEAP_IBLOCK, iblock->addr, new_addr, dxpl_id) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTMOVE, FAIL, "unable to move fractal heap root indirect block")
        iblock->addr = new_addr;
    } /* end if */

    /* Re-allocate child block entry array */
    if(NULL == (iblock->ents = H5FL_SEQ_REALLOC(H5HF_indirect_ent_t, iblock->ents, (size_t)(iblock->nrows * hdr->man_dtable.cparam.width))))
        HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for direct entries")

    /* Check for skipping over rows and add free section for skipped rows */
    if(skip_direct_rows) {
        /* Add skipped blocks to heap's free space */
        if(H5HF_hdr_skip_blocks(hdr, dxpl_id, iblock, next_entry, (new_next_entry - next_entry)) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't add skipped blocks to heap's free space")
    } /* end if */

    /* Initialize new direct block entries in rows added */
    acc_dblock_free = 0;
    for(u = (old_nrows * hdr->man_dtable.cparam.width); u < (iblock->nrows * hdr->man_dtable.cparam.width); u++) {
        unsigned row = (unsigned)(u / hdr->man_dtable.cparam.width);        /* Row for current entry */

        iblock->ents[u].addr = HADDR_UNDEF;
        acc_dblock_free += hdr->man_dtable.row_tot_dblock_free[row];
    } /* end for */

    /* Check for needing to re-allocate filtered entry array */
    if(hdr->filter_len > 0 && old_nrows < hdr->man_dtable.max_direct_rows) {
        unsigned dir_rows;      /* Number of direct rows in this indirect block */

        /* Compute the number of direct rows for this indirect block */
        dir_rows = MIN(iblock->nrows, hdr->man_dtable.max_direct_rows);
        HDassert(dir_rows > old_nrows);

        /* Re-allocate filtered direct block entry array */
        if(NULL == (iblock->filt_ents = H5FL_SEQ_REALLOC(H5HF_indirect_filt_ent_t, iblock->filt_ents, (size_t)(dir_rows * hdr->man_dtable.cparam.width))))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for filtered direct entries")

        /* Initialize new entries allocated */
        for(u = (old_nrows * hdr->man_dtable.cparam.width); u < (dir_rows * hdr->man_dtable.cparam.width); u++) {
            iblock->filt_ents[u].size = 0;
            iblock->filt_ents[u].filter_mask = 0;
        } /* end for */
    } /* end if */

    /* Check for needing to re-allocate child iblock pointer array */
    if(iblock->nrows > hdr->man_dtable.max_direct_rows) {
        unsigned indir_rows;      /* Number of indirect rows in this indirect block */
        unsigned old_indir_rows;  /* Previous number of indirect rows in this indirect block */

        /* Compute the number of direct rows for this indirect block */
        indir_rows = iblock->nrows - hdr->man_dtable.max_direct_rows;

        /* Re-allocate child indirect block array */
        if(NULL == (iblock->child_iblocks = H5FL_SEQ_REALLOC(H5HF_indirect_ptr_t, iblock->child_iblocks, (size_t)(indir_rows * hdr->man_dtable.cparam.width))))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for filtered direct entries")

        /* Compute the previous # of indirect rows in this block */
        if(old_nrows < hdr->man_dtable.max_direct_rows)
            old_indir_rows = 0;
        else
            old_indir_rows = old_nrows - hdr->man_dtable.max_direct_rows;

        /* Initialize new entries allocated */
        for(u = (old_indir_rows * hdr->man_dtable.cparam.width); u < (indir_rows * hdr->man_dtable.cparam.width); u++)
            iblock->child_iblocks[u] = NULL;
    } /* end if */

    /* Mark indirect block as dirty */
    if(H5HF_iblock_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark indirect block as dirty")

    /* Update other shared header info */
    hdr->man_dtable.curr_root_rows = new_nrows;
    hdr->man_dtable.table_addr = new_addr;

    /* Extend heap to cover new root indirect block */
    if(H5HF_hdr_adjust_heap(hdr, 2 * hdr->man_dtable.row_block_off[new_nrows - 1], (hssize_t)acc_dblock_free) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, FAIL, "can't increase space to cover root direct block")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_root_double() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_root_halve
 *
 * Purpose:	Halve size of root indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Jun 12 2006
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5HF_man_iblock_root_halve(H5HF_indirect_t *iblock, hid_t dxpl_id)
{
    H5HF_hdr_t *hdr = iblock->hdr;      /* Pointer to heap header */
    haddr_t new_addr;                   /* New address of indirect block */
    hsize_t acc_dblock_free;            /* Accumulated free space in direct blocks */
    hsize_t old_size;                   /* Old size of indirect block */
    unsigned max_child_row;             /* Row for max. child entry */
    unsigned old_nrows;                 /* Old # of rows */
    unsigned new_nrows;                 /* New # of rows */
    unsigned u;                         /* Local index variable */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /* Sanity check */
    HDassert(iblock);
    HDassert(iblock->parent == NULL);
    HDassert(hdr);

    /* Compute maximum row used by child of indirect block */
    max_child_row = iblock->max_child / hdr->man_dtable.cparam.width;

    /* Compute new # of rows in root indirect block */
    new_nrows = (unsigned)1 << (1 + H5VM_log2_gen((uint64_t)max_child_row));

    /* Check if the indirect block is NOT currently allocated in temp. file space */
    /* (temp. file space does not need to be freed) */
    if(!H5F_IS_TMP_ADDR(hdr->f, iblock->addr)) {
/* Currently, the old block data is "thrown away" after the space is reallocated,
* to avoid data copy in H5MF_realloc() call by just free'ing the space and
* allocating new space.
*
* This also keeps the file smaller, by freeing the space and then
* allocating new space, instead of vice versa (in H5MF_realloc).
*
* QAK - 6/12/2006
*/
        /* Free previous indirect block disk space */
        if(H5MF_xfree(hdr->f, H5FD_MEM_FHEAP_IBLOCK, dxpl_id, iblock->addr, (hsize_t)iblock->size) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap indirect block file space")
    } /* end if */

    /* Compute free space in rows to delete */
    acc_dblock_free = 0;
    for(u = new_nrows; u < iblock->nrows; u++)
        acc_dblock_free += hdr->man_dtable.row_tot_dblock_free[u] * hdr->man_dtable.cparam.width;

    /* Compute size of buffer needed for new indirect block */
    old_nrows = iblock->nrows;
    iblock->nrows = new_nrows;
    old_size = iblock->size;
    iblock->size = H5HF_MAN_INDIRECT_SIZE(hdr, iblock->nrows);

    /* Allocate [temporary] space for the new indirect block on disk */
    if(H5F_USE_TMP_SPACE(hdr->f)) {
        if(HADDR_UNDEF == (new_addr = H5MF_alloc_tmp(hdr->f, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end if */
    else {
        if(HADDR_UNDEF == (new_addr = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_IBLOCK, dxpl_id, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end else */

    /* Resize pinned indirect block in the cache, if it has changed size */
    if(old_size != iblock->size) {
        if(H5AC_resize_entry(iblock, (size_t)iblock->size) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize fractal heap indirect block")
    } /* end if */

    /* Move object in cache, if it actually was relocated */
    if(H5F_addr_ne(iblock->addr, new_addr)) {
        if(H5AC_move_entry(hdr->f, H5AC_FHEAP_IBLOCK, iblock->addr, new_addr, dxpl_id) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTSPLIT, FAIL, "unable to move fractal heap root indirect block")
        iblock->addr = new_addr;
    } /* end if */

    /* Re-allocate child block entry array */
    if(NULL == (iblock->ents = H5FL_SEQ_REALLOC(H5HF_indirect_ent_t, iblock->ents, (size_t)(iblock->nrows * hdr->man_dtable.cparam.width))))
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for direct entries")

    /* Check for needing to re-allocate filtered entry array */
    if(hdr->filter_len > 0 && new_nrows < hdr->man_dtable.max_direct_rows) {
        /* Re-allocate filtered direct block entry array */
        if(NULL == (iblock->filt_ents = H5FL_SEQ_REALLOC(H5HF_indirect_filt_ent_t, iblock->filt_ents, (size_t)(iblock->nrows * hdr->man_dtable.cparam.width))))
            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for filtered direct entries")
    } /* end if */

    /* Check for needing to re-allocate child iblock pointer array */
    if(old_nrows > hdr->man_dtable.max_direct_rows) {
        /* Check for shrinking away child iblock pointer array */
        if(iblock->nrows > hdr->man_dtable.max_direct_rows) {
            unsigned indir_rows;      /* Number of indirect rows in this indirect block */

            /* Compute the number of direct rows for this indirect block */
            indir_rows = iblock->nrows - hdr->man_dtable.max_direct_rows;

            /* Re-allocate child indirect block array */
            if(NULL == (iblock->child_iblocks = H5FL_SEQ_REALLOC(H5HF_indirect_ptr_t, iblock->child_iblocks, (size_t)(indir_rows * hdr->man_dtable.cparam.width))))
                HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for filtered direct entries")
        } /* end if */
        else
            iblock->child_iblocks = (H5HF_indirect_ptr_t *)H5FL_SEQ_FREE(H5HF_indirect_ptr_t, iblock->child_iblocks);
    } /* end if */

    /* Mark indirect block as dirty */
    if(H5HF_iblock_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark indirect block as dirty")

    /* Update other shared header info */
    hdr->man_dtable.curr_root_rows = new_nrows;
    hdr->man_dtable.table_addr = new_addr;

    /* Shrink heap to only cover new root indirect block */
    if(H5HF_hdr_adjust_heap(hdr, 2 * hdr->man_dtable.row_block_off[new_nrows - 1], -(hssize_t)acc_dblock_free) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't reduce space to cover root direct block")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_root_halve() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_root_revert
 *
 * Purpose:	Revert root indirect block back to root direct block
 *
 * Note:	Any sections left pointing to the  old root indirect block
 *              will be cleaned up by the free space manager
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		May 31 2006
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5HF_man_iblock_root_revert(H5HF_indirect_t *root_iblock, hid_t dxpl_id)
{
    H5HF_hdr_t *hdr;                    /* Pointer to heap's header */
    H5HF_direct_t *dblock = NULL;       /* Pointer to new root indirect block */
    haddr_t dblock_addr;                /* Direct block's address in the file */
    size_t dblock_size;                 /* Direct block's size */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(root_iblock);

    /* Set up local convenience variables */
    hdr = root_iblock->hdr;
    dblock_addr = root_iblock->ents[0].addr;
    dblock_size = hdr->man_dtable.cparam.start_block_size;

    /* Get pointer to last direct block */
    if(NULL == (dblock = H5HF_man_dblock_protect(hdr, dxpl_id, dblock_addr, dblock_size, root_iblock, 0, H5AC__NO_FLAGS_SET)))
        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap direct block")
    HDassert(dblock->parent == root_iblock);
    HDassert(dblock->par_entry == 0);

    /* Check for I/O filters on this heap */
    if(hdr->filter_len > 0) {
        /* Set the header's pipeline information from the indirect block */
        hdr->pline_root_direct_size = root_iblock->filt_ents[0].size;
        hdr->pline_root_direct_filter_mask = root_iblock->filt_ents[0].filter_mask;
    } /* end if */

    /* Detach direct block from parent */
    if(H5HF_man_iblock_detach(dblock->parent, dxpl_id, 0) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTATTACH, FAIL, "can't detach direct block from parent indirect block")
    dblock->parent = NULL;
    dblock->par_entry = 0;

    /* destroy flush dependency between old root iblock and new root direct block*/
    if(H5AC_destroy_flush_dependency(dblock->fd_parent, dblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, \
                    "unable to destroy flush dependency")

    /* create flush dependency between header and new root direct block */
    if(H5AC_create_flush_dependency(dblock->hdr, dblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, \
                    "unable to create flush dependency")

    dblock->fd_parent = NULL;

    /* Point root at direct block */
    hdr->man_dtable.curr_root_rows = 0;
    hdr->man_dtable.table_addr = dblock_addr;

    /* Reset 'next block' iterator */
    if(H5HF_hdr_reset_iter(hdr, (hsize_t)dblock_size) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't reset block iterator")

    /* Extend heap to just cover first direct block */
    if(H5HF_hdr_adjust_heap(hdr, (hsize_t)hdr->man_dtable.cparam.start_block_size, (hssize_t)hdr->man_dtable.row_tot_dblock_free[0]) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, FAIL, "can't increase space to cover root direct block")

    /* Scan free space sections to reset any 'parent' pointers */
    if(H5HF_space_revert_root(hdr, dxpl_id) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTRESET, FAIL, "can't reset free space section info")

done:
    if(dblock && H5AC_unprotect(hdr->f, dxpl_id, H5AC_FHEAP_DBLOCK, dblock_addr, dblock, H5AC__NO_FLAGS_SET) < 0)
        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap direct block")

    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_root_revert() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_alloc_row
 *
 * Purpose:	Allocate a "single" section for an object, out of a
 *              "row" section.
 *
 * Note:	Creates necessary direct & indirect blocks
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		July  6 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_alloc_row(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t **sec_node)
{
    H5HF_indirect_t *iblock = NULL;     /* Pointer to indirect block */
    H5HF_free_section_t *old_sec_node = *sec_node; /* Pointer to old indirect section node */
    unsigned dblock_entry;              /* Entry for direct block */
    hbool_t iblock_held = FALSE;        /* Flag to indicate that indirect block is held */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(hdr);
    HDassert(sec_node && old_sec_node);
    HDassert(old_sec_node->u.row.row < hdr->man_dtable.max_direct_rows);

    /* Check for serialized section */
    if(old_sec_node->sect_info.state == H5FS_SECT_SERIALIZED) {
        /* Revive indirect section */
        if(H5HF_sect_row_revive(hdr, dxpl_id, old_sec_node) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTREVIVE, FAIL, "can't revive indirect section")
    } /* end if */

    /* Get a pointer to the indirect block covering the section */
    if(NULL == (iblock = H5HF_sect_row_get_iblock(old_sec_node)))
        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't retrieve indirect block for row section")

    /* Hold indirect block in memory, until direct block can point to it */
    if(H5HF_iblock_incr(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block")
    iblock_held = TRUE;

    /* Reduce (& possibly re-add) 'row' section */
    if(H5HF_sect_row_reduce(hdr, dxpl_id, old_sec_node, &dblock_entry) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't reduce row section node")

    /* Create direct block & single section */
    if(H5HF_man_dblock_create(dxpl_id, hdr, iblock, dblock_entry, NULL, sec_node) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate fractal heap direct block")

done:
    /* Release hold on indirect block */
    if(iblock_held)
        if(H5HF_iblock_decr(iblock) < 0)
            HDONE_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared indirect block")

    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_alloc_row() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_create
 *
 * Purpose:	Allocate & initialize a managed indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Mar  6 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_create(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_indirect_t *par_iblock,
    unsigned par_entry, unsigned nrows, unsigned max_rows, haddr_t *addr_p)
{
    H5HF_indirect_t *iblock = NULL;     /* Pointer to indirect block */
    size_t u;                           /* Local index variable */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(hdr);
    HDassert(nrows > 0);
    HDassert(addr_p);

    /*
     * Allocate file and memory data structures.
     */
    if(NULL == (iblock = H5FL_MALLOC(H5HF_indirect_t)))
	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fractal heap indirect block")

    /* Reset the metadata cache info for the heap header */
    HDmemset(&iblock->cache_info, 0, sizeof(H5AC_info_t));

    /* Share common heap information */
    iblock->hdr = hdr;
    if(H5HF_hdr_incr(hdr) < 0)
	HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared heap header")

    /* Set info for direct block */
    iblock->rc = 0;
    iblock->nrows = nrows;
    iblock->max_rows = max_rows;

    /* Compute size of buffer needed for indirect block */
    iblock->size = H5HF_MAN_INDIRECT_SIZE(hdr, iblock->nrows);

    /* Allocate child block entry array */
    if(NULL == (iblock->ents = H5FL_SEQ_MALLOC(H5HF_indirect_ent_t, (size_t)(iblock->nrows * hdr->man_dtable.cparam.width))))
	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for block entries")

    /* Initialize indirect block entry tables */
    for(u = 0; u < (iblock->nrows * hdr->man_dtable.cparam.width); u++)
        iblock->ents[u].addr = HADDR_UNDEF;

    /* Check for I/O filters to apply to this heap */
    if(hdr->filter_len > 0) {
        unsigned dir_rows;      /* Number of direct rows in this indirect block */

        /* Compute the number of direct rows for this indirect block */
        dir_rows = MIN(iblock->nrows, hdr->man_dtable.max_direct_rows);

        /* Allocate & initialize indirect block filtered entry array */
        if(NULL == (iblock->filt_ents = H5FL_SEQ_CALLOC(H5HF_indirect_filt_ent_t, (size_t)(dir_rows * hdr->man_dtable.cparam.width))))
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for block entries")
    } /* end if */
    else
        iblock->filt_ents = NULL;

    /* Check if we have any indirect block children */
    if(iblock->nrows > hdr->man_dtable.max_direct_rows) {
        unsigned indir_rows;      /* Number of indirect rows in this indirect block */

        /* Compute the number of indirect rows for this indirect block */
        indir_rows = iblock->nrows - hdr->man_dtable.max_direct_rows;

        /* Allocate & initialize child indirect block pointer array */
        if(NULL == (iblock->child_iblocks = H5FL_SEQ_CALLOC(H5HF_indirect_ptr_t, (size_t)(indir_rows * hdr->man_dtable.cparam.width))))
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for block entries")
    } /* end if */
    else
        iblock->child_iblocks = NULL;

    /* Allocate [temporary] space for the indirect block on disk */
    if(H5F_USE_TMP_SPACE(hdr->f)) {
        if(HADDR_UNDEF == (*addr_p = H5MF_alloc_tmp(hdr->f, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end if */
    else {
        if(HADDR_UNDEF == (*addr_p = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_IBLOCK, dxpl_id, (hsize_t)iblock->size)))
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
    } /* end else */
    iblock->addr = *addr_p;

    /* Attach to parent indirect block, if there is one */
    iblock->parent = par_iblock;
    iblock->fd_parent = par_iblock; /* this copy of the parent pointer is */
				    /* needed by the notify callback so   */
				    /* that it can take down flush        */
				    /* dependencies on eviction even if   */
				    /* the parent pointer has been nulled */
				    /* out.		JRM -- 5/18/14    */
    iblock->par_entry = par_entry;
    if(iblock->parent) {
        /* Attach new block to parent */
        if(H5HF_man_iblock_attach(iblock->parent, par_entry, *addr_p) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTATTACH, FAIL, "can't attach indirect block to parent indirect block")

        /* Compute the indirect block's offset in the heap's address space */
        /* (based on parent's block offset) */
        iblock->block_off = par_iblock->block_off;
        iblock->block_off += hdr->man_dtable.row_block_off[par_entry / hdr->man_dtable.cparam.width];
        iblock->block_off += hdr->man_dtable.row_block_size[par_entry / hdr->man_dtable.cparam.width] * (par_entry % hdr->man_dtable.cparam.width);
    } /* end if */
    else
        iblock->block_off = 0;  /* Must be the root indirect block... */

    /* Update indirect block's statistics */
    iblock->nchildren = 0;
    iblock->max_child = 0;

    /* Cache the new indirect block */
    if(H5AC_insert_entry(hdr->f, dxpl_id, H5AC_FHEAP_IBLOCK, *addr_p, iblock, H5AC__NO_FLAGS_SET) < 0)
	HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't add fractal heap indirect block to cache")

done:
    if(ret_value < 0)
        if(iblock)
            if(H5HF_man_iblock_dest(iblock) < 0)
                HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap indirect block")

    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_create() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_protect
 *
 * Purpose:	Convenience wrapper around H5AC_protect on an indirect block
 *
 * Return:	Pointer to indirect block on success, NULL on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Apr 17 2006
 *
 *-------------------------------------------------------------------------
 */
H5HF_indirect_t *
H5HF_man_iblock_protect(H5HF_hdr_t *hdr, hid_t dxpl_id, haddr_t iblock_addr,
    unsigned iblock_nrows, H5HF_indirect_t *par_iblock, unsigned par_entry,
    hbool_t must_protect, unsigned flags, hbool_t *did_protect)
{
    H5HF_parent_t par_info;             /* Parent info for loading block */
    H5HF_indirect_t *iblock = NULL;     /* Indirect block from cache */
    hbool_t should_protect = FALSE;     /* Whether we should protect the indirect block or not */
    H5HF_indirect_t *ret_value = NULL;  /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(hdr);
    HDassert(H5F_addr_defined(iblock_addr));
    HDassert(iblock_nrows > 0);
    HDassert(did_protect);

    /* only H5AC__READ_ONLY_FLAG may appear in flags */
    HDassert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0);

    /* Check if we are allowed to use existing pinned iblock pointer */
    if(!must_protect) {
        /* Check for this block already being pinned */
        if(par_iblock) {
            unsigned indir_idx;             /* Index in parent's child iblock pointer array */

            /* Sanity check */
            HDassert(par_iblock->child_iblocks);
            HDassert(par_entry >= (hdr->man_dtable.max_direct_rows
                    * hdr->man_dtable.cparam.width));

            /* Compute index in parent's child iblock pointer array */
            indir_idx = par_entry - (hdr->man_dtable.max_direct_rows
                    * hdr->man_dtable.cparam.width);

            /* Check for pointer to pinned indirect block in parent */
            if(par_iblock->child_iblocks[indir_idx])
                iblock = par_iblock->child_iblocks[indir_idx];
            else
                should_protect = TRUE;
        } /* end if */
        else {
            /* Check for root indirect block */
            if(H5F_addr_eq(iblock_addr, hdr->man_dtable.table_addr)) {
                /* Check for valid pointer to pinned indirect block in root */
                if(H5HF_ROOT_IBLOCK_PINNED == hdr->root_iblock_flags) {
                    /* Sanity check */
                    HDassert(NULL != hdr->root_iblock);

                    /* Return the pointer to the pinned root indirect block */
                    iblock = hdr->root_iblock;
                } /* end if */
                else {
                    /* Sanity check */
                    HDassert(NULL == hdr->root_iblock);

                    should_protect = TRUE;
                } /* end else */
            } /* end if */
            else
                should_protect = TRUE;
        } /* end else */
    } /* end if */

    /* Check for protecting indirect block */
    if(must_protect || should_protect) {
        H5HF_iblock_cache_ud_t cache_udata; /* User-data for callback */

        /* Set up parent info */
        par_info.hdr = hdr;
        par_info.iblock = par_iblock;
        par_info.entry = par_entry;

        /* Set up user data for protect call */
        cache_udata.f = hdr->f;
        cache_udata.par_info = &par_info;
        cache_udata.nrows = &iblock_nrows;

        /* Protect the indirect block */
        if(NULL == (iblock = (H5HF_indirect_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_FHEAP_IBLOCK, iblock_addr, &cache_udata, flags)))
            HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, NULL, "unable to protect fractal heap indirect block")

        /* Set the indirect block's address */
        iblock->addr = iblock_addr;

        /* Check for root indirect block */
        if(iblock->block_off == 0) {
            /* Sanity check - shouldn't be recursively protecting root indirect block */
            HDassert(0 == (hdr->root_iblock_flags & H5HF_ROOT_IBLOCK_PROTECTED));

            /* Check if we should set the root iblock pointer */
            if(0 == hdr->root_iblock_flags) {
                HDassert(NULL == hdr->root_iblock);
                hdr->root_iblock = iblock;
            } /* end if */

            /* Indicate that the root indirect block is protected */
            hdr->root_iblock_flags |= H5HF_ROOT_IBLOCK_PROTECTED;
        } /* end if */

        /* Indicate that the indirect block was protected */
        *did_protect = TRUE;
    } /* end if */
    else
        /* Indicate that the indirect block was _not_ protected */
        *did_protect = FALSE;

    /* Set the return value */
    ret_value = iblock;

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_protect() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_unprotect
 *
 * Purpose:	Convenience wrapper around H5AC_unprotect on an indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@hdfgroup.org
 *		Aug 17 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_unprotect(H5HF_indirect_t *iblock, hid_t dxpl_id,
    unsigned cache_flags, hbool_t did_protect)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(iblock);

    /* Check if we previously protected this indirect block */
    /* (as opposed to using an existing pointer to a pinned child indirect block) */
    if(did_protect) {
        /* Check for root indirect block */
        if(iblock->block_off == 0) {
            /* Sanity check - shouldn't be recursively unprotecting root indirect block */
            HDassert(iblock->hdr->root_iblock_flags & H5HF_ROOT_IBLOCK_PROTECTED);

            /* Check if we should reset the root iblock pointer */
            if(H5HF_ROOT_IBLOCK_PROTECTED == iblock->hdr->root_iblock_flags) {
                HDassert(NULL != iblock->hdr->root_iblock);
                iblock->hdr->root_iblock = NULL;
            } /* end if */

            /* Indicate that the root indirect block is unprotected */
            iblock->hdr->root_iblock_flags &= (unsigned)(~(H5HF_ROOT_IBLOCK_PROTECTED));
        } /* end if */

        /* Unprotect the indirect block */
        if(H5AC_unprotect(iblock->hdr->f, dxpl_id, H5AC_FHEAP_IBLOCK, iblock->addr, iblock, cache_flags) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap indirect block")
    } /* end if */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_unprotect() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_attach
 *
 * Purpose:	Attach a child block (direct or indirect) to an indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		May 30 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_attach(H5HF_indirect_t *iblock, unsigned entry, haddr_t child_addr)
{
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(iblock);
    HDassert(H5F_addr_defined(child_addr));
    HDassert(!H5F_addr_defined(iblock->ents[entry].addr));

    /* Increment the reference count on this indirect block */
    if(H5HF_iblock_incr(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block")

    /* Point at the child block */
    iblock->ents[entry].addr = child_addr;

    /* Check for I/O filters on this heap */
    if(iblock->hdr->filter_len > 0) {
        unsigned row;           /* Row for entry */

        /* Sanity check */
        HDassert(iblock->filt_ents);

        /* Compute row for entry */
        row = entry / iblock->hdr->man_dtable.cparam.width;

        /* If this is a direct block, set its initial size */
        if(row < iblock->hdr->man_dtable.max_direct_rows)
            iblock->filt_ents[entry].size = iblock->hdr->man_dtable.row_block_size[row];
    } /* end if */

    /* Check for max. entry used */
    if(entry > iblock->max_child)
        iblock->max_child = entry;

    /* Increment the # of child blocks */
    iblock->nchildren++;

    /* Mark indirect block as modified */
    if(H5HF_iblock_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark indirect block as dirty")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_attach() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_detach
 *
 * Purpose:	Detach a child block (direct or indirect) from an indirect block
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		May 31 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_detach(H5HF_indirect_t *iblock, hid_t dxpl_id, unsigned entry)
{
    unsigned row;                       /* Row for entry */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(iblock);
    HDassert(iblock->nchildren);

    /* Reset address of entry */
    iblock->ents[entry].addr = HADDR_UNDEF;

    /* Compute row for entry */
    row = entry / iblock->hdr->man_dtable.cparam.width;

    /* Check for I/O filters on this heap */
    if(iblock->hdr->filter_len > 0) {
        /* Sanity check */
        HDassert(iblock->filt_ents);

        /* If this is a direct block, reset its initial size */
        if(row < iblock->hdr->man_dtable.max_direct_rows) {
            iblock->filt_ents[entry].size = 0;
            iblock->filt_ents[entry].filter_mask = 0;
        } /* end if */
    } /* end if */

    /* Check for indirect block being detached */
    if(row >= iblock->hdr->man_dtable.max_direct_rows) {
        unsigned indir_idx;             /* Index in parent's child iblock pointer array */

        /* Sanity check */
        HDassert(iblock->child_iblocks);

        /* Compute index in child iblock pointer array */
        indir_idx = entry - (iblock->hdr->man_dtable.max_direct_rows
                * iblock->hdr->man_dtable.cparam.width);

        /* Sanity check */
        HDassert(iblock->child_iblocks[indir_idx]);

        /* Reset pointer to child indirect block in parent */
        iblock->child_iblocks[indir_idx] = NULL;
    } /* end if */

    /* Decrement the # of child blocks */
    /* (If the number of children drop to 0, the indirect block will be
     *  removed from the heap when its ref. count drops to zero and the
     *  metadata cache calls the indirect block destructor)
     */
    iblock->nchildren--;

    /* Reduce the max. entry used, if necessary */
    if(entry == iblock->max_child) {
        if(iblock->nchildren > 0)
            while(!H5F_addr_defined(iblock->ents[iblock->max_child].addr))
                iblock->max_child--;
        else
            iblock->max_child = 0;
    } /* end if */

    /* If this is the root indirect block handle some special cases */
    if(iblock->block_off == 0) {
        /* If the number of children drops to 1, and that child is the first
         *      direct block in the heap, convert the heap back to using a root
         *      direct block
         */
        if(iblock->nchildren == 1 && H5F_addr_defined(iblock->ents[0].addr))
            if(H5HF_man_iblock_root_revert(iblock, dxpl_id) < 0)
                HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't convert root indirect block back to root direct block")

        /* Check for reducing size of root indirect block */
        if(iblock->nchildren > 0 && iblock->hdr->man_dtable.cparam.start_root_rows != 0
                && entry > iblock->max_child) {
            unsigned max_child_row;         /* Row for max. child entry */

            /* Compute information needed for determining whether to reduce size of root indirect block */
            max_child_row = iblock->max_child / iblock->hdr->man_dtable.cparam.width;

            /* Check if the root indirect block should be reduced */
            if(iblock->nrows > 1 && max_child_row <= (iblock->nrows / 2))
                if(H5HF_man_iblock_root_halve(iblock, dxpl_id) < 0)
                    HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't reduce size of root indirect block")
        } /* end if */
    } /* end if */

    /* Mark indirect block as modified */
    if(H5HF_iblock_dirty(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark indirect block as dirty")

    /* Decrement the reference count on this indirect block */
    /* (should be last, so that potential 'unpin' on this indirect block
     *  doesn't invalidate the 'iblock' variable)
     */
    if(H5HF_iblock_decr(iblock) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared indirect block")

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_detach() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_entry_addr
 *
 * Purpose:	Retrieve the address of an indirect block's child
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		July 10 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_entry_addr(H5HF_indirect_t *iblock, unsigned entry, haddr_t *child_addr)
{
    FUNC_ENTER_NOAPI_NOINIT_NOERR

    /*
     * Check arguments.
     */
    HDassert(iblock);
    HDassert(child_addr);

    /* Retrieve address of entry */
    *child_addr = iblock->ents[entry].addr;

    FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5HF_man_iblock_entry_addr() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_delete
 *
 * Purpose:	Delete a managed indirect block
 *
 * Note:	This routine does _not_ modify any indirect block that points
 *              to this indirect block, it is assumed that the whole heap is
 *              being deleted in a top-down fashion.
 *
 * Return:	SUCCEED/FAIL
 *
 * Programmer:	Quincey Koziol
 *		koziol@hdfgroup.org
 *		Aug  7 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_delete(H5HF_hdr_t *hdr, hid_t dxpl_id, haddr_t iblock_addr,
    unsigned iblock_nrows, H5HF_indirect_t *par_iblock, unsigned par_entry)
{
    H5HF_indirect_t *iblock;            /* Pointer to indirect block */
    unsigned row, col;                  /* Current row & column in indirect block */
    unsigned entry;                     /* Current entry in row */
    unsigned cache_flags = H5AC__NO_FLAGS_SET;      /* Flags for unprotecting indirect block */
    hbool_t did_protect;                /* Whether we protected the indirect block or not */
    herr_t ret_value = SUCCEED;         /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(hdr);
    HDassert(H5F_addr_defined(iblock_addr));
    HDassert(iblock_nrows > 0);

    /* Lock indirect block */
    if(NULL == (iblock = H5HF_man_iblock_protect(hdr, dxpl_id, iblock_addr, iblock_nrows, par_iblock, par_entry, TRUE, H5AC__NO_FLAGS_SET, &did_protect)))
        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap indirect block")
    HDassert(iblock->nchildren > 0);
    HDassert(did_protect == TRUE);

    /* Iterate over rows in this indirect block */
    entry = 0;
    for(row = 0; row < iblock->nrows; row++) {
        /* Iterate over entries in this row */
        for(col = 0; col < hdr->man_dtable.cparam.width; col++, entry++) {
            /* Check for child entry at this position */
            if(H5F_addr_defined(iblock->ents[entry].addr)) {
                hsize_t row_block_size;         /* The size of blocks in this row */

                /* Get the row's block size */
                row_block_size = (hsize_t)hdr->man_dtable.row_block_size[row];

                /* Are we in a direct or indirect block row */
                if(row < hdr->man_dtable.max_direct_rows) {
                    hsize_t dblock_size;        /* Size of direct block on disk */

                    /* Check for I/O filters on this heap */
                    if(hdr->filter_len > 0)
                        dblock_size = iblock->filt_ents[entry].size;
                    else
                        dblock_size = row_block_size;

                    /* Delete child direct block */
                    if(H5HF_man_dblock_delete(hdr->f, dxpl_id, iblock->ents[entry].addr, dblock_size) < 0)
                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to release fractal heap child direct block")
                } /* end if */
                else {
                    unsigned child_nrows;   /* Number of rows in new indirect block */

                    /* Compute # of rows in next child indirect block to use */
                    child_nrows = H5HF_dtable_size_to_rows(&hdr->man_dtable, row_block_size);

                    /* Delete child indirect block */
                    if(H5HF_man_iblock_delete(hdr, dxpl_id, iblock->ents[entry].addr, child_nrows, iblock, entry) < 0)
                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to release fractal heap child indirect block")
                } /* end else */
            } /* end if */
        } /* end for */
    } /* end row */

#ifndef NDEBUG
{
    unsigned iblock_status = 0;         /* Indirect block's status in the metadata cache */

    /* Check the indirect block's status in the metadata cache */
    if(H5AC_get_entry_status(hdr->f, iblock_addr, &iblock_status) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "unable to check metadata cache status for indirect block")

    /* Check if indirect block is pinned */
    HDassert(!(iblock_status & H5AC_ES__IS_PINNED));
}
#endif /* NDEBUG */

    /* Indicate that the indirect block should be deleted  */
    cache_flags |= H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG;

    /* If the indirect block is in real file space, tell
     * the cache to free its file space as well.
     */
    if (!H5F_IS_TMP_ADDR(hdr->f, iblock_addr))
        cache_flags |= H5AC__FREE_FILE_SPACE_FLAG;

done:
    /* Unprotect the indirect block, with appropriate flags */
    if(iblock && H5HF_man_iblock_unprotect(iblock, dxpl_id, cache_flags, did_protect) < 0)
        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap indirect block")

    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_delete() */

/*-------------------------------------------------------------------------
 *
 * Function:    H5HF_man_iblock_size
 *
 * Purpose:     Gather storage used for the indirect block in fractal heap
 *
 * Return:      non-negative on success, negative on error
 *
 * Programmer:  Vailin Choi
 *              July 12 2007
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_size(H5F_t *f, hid_t dxpl_id, H5HF_hdr_t *hdr, haddr_t iblock_addr,
    unsigned nrows, H5HF_indirect_t *par_iblock, unsigned par_entry, hsize_t *heap_size)
{
    H5HF_indirect_t     *iblock = NULL;         /* Pointer to indirect block */
    hbool_t             did_protect;            /* Whether we protected the indirect block or not */
    herr_t              ret_value = SUCCEED;    /* Return value */

    FUNC_ENTER_NOAPI(FAIL)

    /*
     * Check arguments.
     */
    HDassert(f);
    HDassert(hdr);
    HDassert(H5F_addr_defined(iblock_addr));
    HDassert(heap_size);

    /* Protect the indirect block */
    if(NULL == (iblock = H5HF_man_iblock_protect(hdr, dxpl_id, iblock_addr, nrows, par_iblock, par_entry, FALSE, H5AC__READ_ONLY_FLAG, &did_protect)))
        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load fractal heap indirect block")

    /* Accumulate size of this indirect block */
    *heap_size += iblock->size;

    /* Indirect entries in this indirect block */
    if(iblock->nrows > hdr->man_dtable.max_direct_rows) {
	unsigned    first_row_bits;     /* Number of bits used bit addresses in first row */
        unsigned    num_indirect_rows;  /* Number of rows of blocks in each indirect block */
        unsigned    entry;              /* Current entry in row */
        size_t      u;                  /* Local index variable */

        entry = hdr->man_dtable.max_direct_rows * hdr->man_dtable.cparam.width;
	first_row_bits = H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
			    H5VM_log2_of2(hdr->man_dtable.cparam.width);
        num_indirect_rows =
	    (H5VM_log2_gen(hdr->man_dtable.row_block_size[hdr->man_dtable.max_direct_rows]) - first_row_bits) + 1;
        for(u = hdr->man_dtable.max_direct_rows; u < iblock->nrows; u++, num_indirect_rows++) {
            size_t      v;                      /* Local index variable */

	    for(v = 0; v < hdr->man_dtable.cparam.width; v++, entry++)
		if(H5F_addr_defined(iblock->ents[entry].addr))
		    if(H5HF_man_iblock_size(f, dxpl_id, hdr, iblock->ents[entry].addr, num_indirect_rows, iblock, entry, heap_size) < 0)
			HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to get fractal heap storage info for indirect block")
        } /* end for */
    } /* end if */

done:
    /* Release the indirect block */
    if(iblock && H5HF_man_iblock_unprotect(iblock, dxpl_id, H5AC__NO_FLAGS_SET, did_protect) < 0)
	HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap indirect block")
    iblock = NULL;

   FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_size() */

/*-------------------------------------------------------------------------
 * Function:	H5HF_man_iblock_dest
 *
 * Purpose:	Destroys a fractal heap indirect block in memory.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		koziol@ncsa.uiuc.edu
 *		Mar  6 2006
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5HF_man_iblock_dest(H5HF_indirect_t *iblock)
{
    herr_t      ret_value = SUCCEED;    /* Return value */

    FUNC_ENTER_NOAPI_NOINIT

    /*
     * Check arguments.
     */
    HDassert(iblock);
    HDassert(iblock->rc == 0);

    /* Decrement reference count on shared info */
    HDassert(iblock->hdr);
    if(H5HF_hdr_decr(iblock->hdr) < 0)
        HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared heap header")
    if(iblock->parent)
        if(H5HF_iblock_decr(iblock->parent) < 0)
            HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared indirect block")

    /* Release entry tables */
    if(iblock->ents)
        iblock->ents = H5FL_SEQ_FREE(H5HF_indirect_ent_t, iblock->ents);
    if(iblock->filt_ents)
        iblock->filt_ents = H5FL_SEQ_FREE(H5HF_indirect_filt_ent_t, iblock->filt_ents);
    if(iblock->child_iblocks)
        iblock->child_iblocks = H5FL_SEQ_FREE(H5HF_indirect_ptr_t, iblock->child_iblocks);

    /* Free fractal heap indirect block info */
    iblock = H5FL_FREE(H5HF_indirect_t, iblock);

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_iblock_dest() */


text:
ADVANCED SEARCH

FIND PAGES WITH...

			        All these words:
			        <input type="text" ng-model="query.allWords" placeholder="Important words" />

			        This exact word or phrase:
			        <input type="text" ng-model="query.exactPhrase" placeholder='Exact words' />

			        Any of these words:
			        <input type="text" ng-model="query.anyWords" placeholder="Any of these words" />

			        None of these words:
			        <input type="text" ng-model="query.noneWords" placeholder="None of these words" />

NARROW RESULTS BY...

				    Key value pairs:

				        <input type="text" ng-model="pair.key" placeholder="Enter value" />
				        with
				        <input type="text" ng-model="pair.value" placeholder="Enter value" />

	        Cancel

<toaster-container></toaster-container>

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using Newtonsoft.Json;

namespace Systran.GeographicClientLib.Model {

  /// <summary>
  /// Event with only basic information
  /// </summary>
  [DataContract]
  public class LiteEvent {

    /* Event Identifier */
    [DataMember(Name="id", EmitDefaultValue=false)]
    public string Id { get; set; }

    /* Location */
    [DataMember(Name="location", EmitDefaultValue=false)]
    public LiteLocation Location { get; set; }

    /* Name */
    [DataMember(Name="name", EmitDefaultValue=false)]
    public string Name { get; set; }

    /* Opening dates */
    [DataMember(Name="openingDates", EmitDefaultValue=false)]
    public OpeningDates OpeningDates { get; set; }

    /* Main type */
    [DataMember(Name="mainType", EmitDefaultValue=false)]
    public string MainType { get; set; }

    /* Types, ordered from general to specific */
    [DataMember(Name="types", EmitDefaultValue=false)]
    public List<string> Types { get; set; }

    /* Rating */
    [DataMember(Name="rating", EmitDefaultValue=false)]
    public int? Rating { get; set; }

    /* Price Level */
    [DataMember(Name="priceLevel", EmitDefaultValue=false)]
    public int? PriceLevel { get; set; }

    /// <summary>
    /// Get the string presentation of the object
    /// </summary>
    /// <returns>String presentation of the object</returns>
    public override string ToString()  {
      var sb = new StringBuilder();
      sb.Append("class LiteEvent {\n");

      sb.Append("  Id: ").Append(Id).Append("\n");

      sb.Append("  Location: ").Append(Location).Append("\n");

      sb.Append("  Name: ").Append(Name).Append("\n");

      sb.Append("  OpeningDates: ").Append(OpeningDates).Append("\n");

      sb.Append("  MainType: ").Append(MainType).Append("\n");

      sb.Append("  Types: ").Append(Types).Append("\n");

      sb.Append("  Rating: ").Append(Rating).Append("\n");

      sb.Append("  PriceLevel: ").Append(PriceLevel).Append("\n");

      sb.Append("}\n");
      return sb.ToString();
    }

    /// <summary>
    /// Get the JSON string presentation of the object
    /// </summary>
    /// <returns>JSON string presentation of the object</returns>
    public string ToJson() {
      return JsonConvert.SerializeObject(this, Formatting.Indented);
    }

}

}


text:
package com.github.gserv.serv.wx.service;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

import javax.annotation.Resource;

import com.github.gserv.serv.wx.service.manager.WxServiceManager;
import com.github.gserv.serv.wx.support.api.userinfo.WeixinUser;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.github.gserv.serv.commons.JsonUtils;
import com.github.gserv.serv.wx.support.WxApiInvorkException;
import com.github.gserv.serv.wx.support.api.userinfo.WxUserInfoService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "/com/github/gserv/serv/wx/applicationContext-wx-server-single.xml")
public class TestWxUserInfoService {

//	@Resource
	private WxUserInfoService wxUserInfoService;

	@Resource
	private WxServiceManager wxServiceManager;

	@Test
	public void test() throws WxApiInvorkException {
		wxUserInfoService = wxServiceManager.getWxService(WxUserInfoService.class);
		List<WeixinUser> user = wxUserInfoService.getUserInfo(new HashSet<String>(Arrays.asList(new String[] {"oRVwHuIA8N8MaHb_12K3HCNmOs9E"})));
		System.out.println(JsonUtils.toJson(user));
	}

}


text:
/**
 * Diseases.java
 *
 * Project: projecth
 *
 * @author mobileman
 * @date 14.1.2011
 * @version 1.0
 *
 * (c) 2010 MobileMan GmbH
 */

package com.mobileman.projecth.util.disease;

/**
 * @author mobileman
 *
 */
public interface DiseaseCodes {

	/**
	 * Rheuma
	 */
	static final String RHEUMA_CODE = "M79.0";

	/**
	 * Morbus Bechterew
	 */
	static final String MORBUS_BECHTEREW_CODE = "M45";

	/**
	 * Psoriasis
	 */
	static final String PSORIASIS_CODE = "L40.0";
}


text:
package oauth2

type ClientCredentialsGrantStorage interface {
	AccessTokenStorage
}


text:
<md-card>
    <md-card-content>

Hello!

            Making graph theory's learning more enjoyable.

            <md-button ng-click="go('/graph')">Let's begin!</md-button>

    </md-card-content>

</md-card>


text:
using UnityEngine;
using System.Collections;

public class PixelPerfectCamera : MonoBehaviour {

	public static float pixelsToUnits = 1f;
	public static float scale = 1f;

	public Vector2 nativeResolution = new Vector2 (720, 576);

	//this is called before Start()
	void Awake() {
		var camera = GetComponent<Camera> ();
		if(camera.orthographic) {
			scale = Screen.height / nativeResolution.y;
			pixelsToUnits *= scale;
			camera.orthographicSize = (Screen.height / 2.0f) / pixelsToUnits;
		}
	}

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
            Application.Quit();
    }
}


text:
package io.freefair.android.injection.ui;

import android.content.res.Configuration;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Menu;
import android.view.View;
import android.view.ViewGroup;

import io.freefair.android.injection.Injector;
import io.freefair.android.injection.InjectorProvider;
import io.freefair.android.injection.annotation.Inject;
import io.freefair.android.injection.annotation.XmlLayout;
import io.freefair.android.injection.annotation.XmlMenu;
import io.freefair.android.injection.platform.ActivityInjector;
import io.freefair.android.util.Optional;

/**
 * An {@link AppCompatActivity} with support for dependency injection
 */
public class InjectionAppCompatActivity extends AppCompatActivity implements InjectorProvider {
	ActivityInjector injector;

	@Inject protected Optional<XmlMenu> xmlMenuAnnotation;
	@Inject protected Optional<XmlLayout> xmlLayoutAnnotation;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		injector = new ActivityInjector(this);
		injector.inject(this);

		if(xmlLayoutAnnotation.isPresent()){
			setContentView(xmlLayoutAnnotation.get().value());
		}

		injector.injectResources();
		injector.injectAttributes();
	}

	@Override
	public void setContentView(int layoutResID) {
		super.setContentView(layoutResID);
		tryInjectViews();
	}

	private void tryInjectViews() {
		injector.injectViews();
	}

	@Override
	public void setContentView(View view) {
		super.setContentView(view);
		tryInjectViews();
	}

	@Override
	public void setContentView(View view, ViewGroup.LayoutParams params) {
		super.setContentView(view, params);
		tryInjectViews();
	}

	@Override
	public void onConfigurationChanged(Configuration newConfig) {
		super.onConfigurationChanged(newConfig);
		injector.injectResources();
		injector.injectAttributes();
	}

	@Override
	public void setTheme(int resid) {
		super.setTheme(resid);
		if (injector != null) {
			injector.injectResources();
			injector.injectAttributes();
		}
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		if (xmlMenuAnnotation.isPresent()) {
			getMenuInflater().inflate(xmlMenuAnnotation.get().value(), menu);
			super.onCreateOptionsMenu(menu);
			return true;
		}
		return super.onCreateOptionsMenu(menu);
	}

	@Override
	public ActivityInjector getInjector() {
		return injector;
	}
}


text:
<!DOCTYPE html>

    <meta charset="gb2312" />
    <meta name="robots" content="all" />
    <meta name="author" content="www.123itools.com" />
    <meta name="360-site-verification" content="4d7c97467fc2d215cd2bae44e63ec76e" />
    <meta name="google-site-verification" content="wJHmpaG5IpZT-QrPKHh6ugEQWmu8jCePnavT_xHchMM" />
    <title>json格式化,json压缩,json转义</title>
    <?php include('meta.php');?>
    <meta property="og:type" content="article" />
    <meta property="og:title" content="JSON格式,JS,CSS压缩,Md5编码,Base64编码,URL编码,时间戳转换,正则表达式在线解析,Linux命令大全,Git命令大全,Redis命令大全" />
    <meta property="og:description" content="JSON格式,JS,CSS压缩,Md5编码,Base64编码,URL编码,时间戳转换,正则表达式在线解析,Linux命令大全,Git命令大全,Redis命令大全" />
    <meta property="og:url" content="www.123itools.com" />

    <link rel="stylesheet" type="text/css" href="<?php echo base_url();?>style/css/index.css" />
    <link rel="stylesheet" type="text/css" href="<?php echo base_url();?>style/css/bootstrap.min.css" />
    <link rel="stylesheet" type="text/css" href="<?php echo base_url();?>style/css/numberedtextarea.css" />
    <link rel="stylesheet" type="text/css" href="<?php echo base_url();?>style/css/font-awesome.min.css" />

        <?php include('nav.php');?>

                <textarea id="json-src" style="line-height:15px"></textarea>

压缩结果

复制结果

转义

反转义

        <?php include('bottom_map.php');?>
        <?php include('footer.php');?>


text:
package cn.org.bachelor.up.oauth2.rsserver.util;

import org.apache.commons.lang3.StringUtils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisUtil {

	private static JedisPool jedisPool = null;

	private static String ADDR = "127.0.0.1";
	private static int PORT = 6379;
	private static String AUTH;
	private static int MAX_ACTIVE = 1024;
	private static int MAX_IDLE = 200;
	private static int MAX_WAIT = 10000;
	private static int TIMEOUT = 10000;
	private static boolean TEST_ON_BORROW = true;
	private static int CYCLE = 30 ;

	/**
	 * 初始化连接池
	 */
	static {
		try {
			/**
			 * 获取redis配置
			 */
			ADDR = ApplicationUtil.getValue("addr", ADDR);
			PORT = Integer.parseInt(ApplicationUtil.getValue("port",
					String.valueOf(PORT)));
			AUTH = ApplicationUtil.getValue("auth", AUTH);
			MAX_ACTIVE = Integer.parseInt(ApplicationUtil.getValue(
					"max_active", String.valueOf(MAX_ACTIVE)));
			MAX_IDLE = Integer.parseInt(ApplicationUtil.getValue("max_idle",
					String.valueOf(MAX_IDLE)));
			MAX_WAIT = Integer.parseInt(ApplicationUtil.getValue("max_wait",
					String.valueOf(MAX_WAIT)));
			TIMEOUT = Integer.parseInt(ApplicationUtil.getValue("timeout",
					String.valueOf(TIMEOUT)));
			TEST_ON_BORROW = Boolean.parseBoolean(ApplicationUtil.getValue(
					"test_on_borrow", String.valueOf(TEST_ON_BORROW)));
			CYCLE = Integer.parseInt(ApplicationUtil.getValue("session_life_cycle",
					String.valueOf(CYCLE)));
			/**
			 * 初始化redis配置
			 */
			JedisPoolConfig config = new JedisPoolConfig() ;
			config.setMaxTotal(MAX_ACTIVE);
			config.setMinIdle(MAX_IDLE);
			config.setMaxWaitMillis(MAX_WAIT);
			config.setTestOnBorrow(TEST_ON_BORROW);
			jedisPool = new JedisPool(config,ADDR,PORT,TIMEOUT,AUTH) ;

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取Jedis实例
	 */
	private synchronized static Jedis getJedis(){
		try{
			if(jedisPool!=null){
				Jedis resource = jedisPool.getResource() ;
				return resource ;
			}else{
				return null ;
			}
		}catch(Exception ex){
			ex.printStackTrace();
			return null ;
		}
	}

	/**
	 * 释放资源
	 */
	public static void freeResource(final Jedis jedis){
		if(jedis!=null){
			jedisPool.returnResourceObject(jedis);
		}
	}

	public static String saveString(String key, String value) {
		return saveString(key, value, CYCLE * 60);
	}

	public static String saveString(String key, String value, Integer seconds) {
		String result = "FAIL" ;
		if(StringUtils.isNotBlank(key) && value!=null){
			final Jedis jedis = getJedis() ;
			int cycle = seconds;
			result = jedis.setex(key, cycle, value);
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * redis 存储对象
	 */
	public static String saveObject(String key,Object obj){
		String result = "FAIL" ;
		if(StringUtils.isNotBlank(key) && obj!=null){
			final Jedis jedis = getJedis() ;
			int cycle = CYCLE * 60 ;
			result = jedis.setex(key.getBytes(), cycle,SerializeUtil.serialize(obj)) ;
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * redis 存储对象
	 */
	public static String saveObject(String key,Object obj,Integer seconds){
		String result = "FAIL" ;
		if(StringUtils.isNotBlank(key) && obj!=null){
			final Jedis jedis = getJedis() ;
			int cycle = seconds ;
			result = jedis.setex(key.getBytes(), cycle, SerializeUtil.serialize(obj)) ;
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * redis 获取对象
	 * @return 返回索取对象
	 */
	public static String getString(String key){
		String result = "" ;
		if(StringUtils.isNotBlank(key)){
			final Jedis jedis = getJedis() ;
			result = jedis.get(key) ;
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * redis 获取对象
	 * @return 返回索取对象
	 */
	public static Object getObject(String key){
		Object result = null ;
		if(StringUtils.isNotBlank(key)){
			final Jedis jedis = getJedis() ;
			byte[] bytes = jedis.get(key.getBytes()) ;
			result = SerializeUtil.unserialize(bytes) ;
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * 移除存储对象
	 */
	public static long removeObject(String key){
		long result = 0 ;
		if(StringUtils.isNotBlank(key)){
			final Jedis jedis = getJedis() ;
			result = jedis.del(key);
			freeResource(jedis) ;
		}
		return result ;
	}

	/**
	 * 刷新存储对象
	 */
	public static long refreshObject(String key,Integer seconds){
		long result = 0 ;
		if(StringUtils.isNotBlank(key)){
			final Jedis jedis = getJedis() ;
			result = jedis.expire(key,seconds);
			freeResource(jedis) ;
		}
		return result ;
	}

	public static void main(String[] args){
		final Jedis jedis = JedisUtil.getJedis() ;
//		// 存储简单对象
//		jedis.set("test_key", "本市日前公布2014年度全市职工年平均工资为77560元,月平均工资为6463元,与其相关的社保缴费基数的上下限、工伤保险定期待遇等均会照此标准进行调整") ;
//		// 存储带有生命周期的对象
//		jedis.setex("ex", 25, "setex") ;
//		System.out.println(jedis.get("ex")+","+jedis.ttl("ex")) ;
//		JedisUtil.freeResource(jedis);

//		// 创建对象
//		UserBasicInfo bui = new UserBasicInfo() ;
//		bui.setAccount("zhangsan");
//		bui.setCode("111");
//		jedis.setex(bui.getCode().getBytes(), 100,SerializeUtil.serialize(bui)) ;
//		byte[] person = jedis.get(bui.getCode().getBytes()) ;
//		System.out.println(person);
//		UserBasicInfo user = (UserBasicInfo)SerializeUtil.unserialize(person) ;
//		System.out.println(user.getCode()+","+user.getAccount());
	}
}


text:
package ru.otus.timer;

import ru.otus.TemplateProcessor;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class TimerServlet extends HttpServlet {

    private static final String REFRESH_VARIABLE_NAME = "refreshPeriod";
    private static final String TIME_VARIABLE_NAME = "time";
    private static final String TIMER_PAGE_TEMPLATE = "timer.html";

    private static final int PERIOD_MS = 1000;

    public void doGet(HttpServletRequest request,
                      HttpServletResponse response) throws ServletException, IOException {
        Map<String, Object> pageVariables = new HashMap<>();
        pageVariables.put(REFRESH_VARIABLE_NAME, String.valueOf(PERIOD_MS));
        pageVariables.put(TIME_VARIABLE_NAME, getTime());

        response.getWriter().println(TemplateProcessor.instance().getPage(TIMER_PAGE_TEMPLATE, pageVariables));

        response.setContentType("text/html;charset=utf-8");
        response.setStatus(HttpServletResponse.SC_OK);
    }

    private static String getTime() {
        Date date = new Date();
        date.getTime();
        DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
        return formatter.format(date);
    }

}


text:
package com.pungwe.cms.core.entity.services;

import com.pungwe.cms.core.entity.EntityInstance;

/**
 * Created by ian on 13/03/2016.
 */
public interface EntityInstanceService<EI extends EntityInstance> {
}


text:
<?xml version="1.0" encoding="ascii"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "DTD/xhtml1-transitional.dtd">

  <title>killerbee</title>
  <link rel="stylesheet" href="epydoc.css" type="text/css" />

Module killerbee

Classes

    KillerBee

Variables

    KB_CAPAB_INJECT
    KB_CAPAB_NONE
    KB_CAPAB_PHYJAM
    KB_CAPAB_SELFACK
    KB_CAPAB_SETCHAN
    KB_CAPAB_SNIFF
    RESPONSE_MAP
    RZ_CMD_CLOSE_STREAM
    RZ_CMD_INJECT_FRAME
    RZ_CMD_JAMMER_OFF
    RZ_CMD_JAMMER_ON
    RZ_CMD_MODE_AC
    RZ_CMD_MODE_NONE
    RZ_CMD_OPEN_STREAM
    RZ_CMD_SET_CHANNEL
    RZ_CMD_SET_MODE
    RZ_EVENT_STREAM_AC_DATA
    RZ_RESP_BOOT_PARAM
    RZ_RESP_BUSY_CAPTURING
    RZ_RESP_BUSY_JAMMING
    RZ_RESP_BUSY_SCANING
    RZ_RESP_COMMAND_UNKNOWN
    RZ_RESP_GET_PARAMETER
    RZ_RESP_HW_TIMEOUT
    RZ_RESP_LOCAL_TIMEOUT
    RZ_RESP_NOT_IMPLEMENTED
    RZ_RESP_NOT_INITIALIZED
    RZ_RESP_OUT_OF_MEMORY
    RZ_RESP_PRIMITIVE_FAILED
    RZ_RESP_PRITMITIVE_FAILED
    RZ_RESP_PRITMITIVE_UNKNOWN
    RZ_RESP_SEMANTICAL_ERROR
    RZ_RESP_SIGN_ON
    RZ_RESP_SUCCESS
    RZ_RESP_SYNTACTICAL_ERROR
    RZ_RESP_TRX_BUSY
    RZ_RESP_TRX_GET_PIN
    RZ_RESP_TRX_READ_FRAME
    RZ_RESP_TRX_READ_REGISTER
    RZ_RESP_TRX_READ_SRAM
    RZ_RESP_VRT_KERNEL_ERROR
    RZ_USB_COMMAND_EP
    RZ_USB_PACKET_EP
    RZ_USB_PROD_ID
    RZ_USB_RESPONSE_EP
    RZ_USB_VEND_ID
    __package__

[hide private]


text:
package cpu

const cacheLineSize = 32

func initOptions() {}


text:
{% extends "base.html" %}

{% block title %}School Closings in Vermont | VPR{% endblock %}
{% block header_title %}School Closings{% endblock %}

{% block content %}

School Closings

Last Update: {{ timestamp }}

This list is purged daily at 11AM

            {% if school_closings %}

See Closings By State:

                    {% if 'Vermont' in school_closings %}

Vermont

                    {% endif %}
                    {% if 'New York' in school_closings %}

New York

                    {% endif %}
                    {% if 'New Hampshire' in school_closings %}

New Hampshire

                    {% endif %}

            {% else %}

No Reported Closings

There are no reported school closings at this time.

            {% endif %}

 Read the forecast

 Listen to the forecast

 EOTS on Facebook

            {% include "underwriter1.html" %}
            {% include "underwriter2.html" %}
            {% include "underwriter3.html" %}

            {% include "vab.html" %}

            {% include "closings.html" %}

            {% include "vab.html" %}

{% endblock %}

{% block scripts %}

{% endblock %}


text:
package com.mongodb;

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Level;

/**
 * Concrete extension of abstract {@code DB} class.
 *
 * @deprecated This class is NOT part of the public API. It will be dropped in 3.x releases.
 */
@Deprecated
@SuppressWarnings("deprecation")
public class DBApiLayer extends DB {

    /** The maximum number of cursors allowed */
    static final int NUM_CURSORS_BEFORE_KILL = 100;
    static final int NUM_CURSORS_PER_BATCH = 20000;

    DBTCPConnector getConnector() {
        return _connector;
    }

    /**
     * @param mongo the Mongo instance
     * @param name the database name
     * @param connector the connector.  This must be an instance of DBTCPConnector.
     */
    protected DBApiLayer( Mongo mongo, String name , DBConnector connector ){
        super( mongo, name );

        if ( connector == null )
            throw new IllegalArgumentException( "need a connector: " + name );

        _root = name;
        _rootPlusDot = _root + ".";

        _connector = (DBTCPConnector) connector;
    }

    public void requestStart(){
        _connector.requestStart();
    }

    public void requestDone(){
        _connector.requestDone();
    }

    public void requestEnsureConnection(){
        _connector.requestEnsureConnection();
    }

    public WriteResult addUser( String username , char[] passwd, boolean readOnly ){
        requestStart();
        try {
            if (useUserCommands(_connector.getPrimaryPort())) {
                CommandResult userInfoResult = command(new BasicDBObject("usersInfo", username));
                userInfoResult.throwOnError();
                DBObject userCommandDocument = getUserCommandDocument(username, passwd, readOnly,
                                                                      ((List) userInfoResult.get("users")).isEmpty()
                                                                      ? "createUser" : "updateUser");
                CommandResult commandResult = command(userCommandDocument);
                commandResult.throwOnError();
                return new WriteResult(commandResult, getWriteConcern());
            } else {
                return super.addUser(username, passwd, readOnly);
            }
        } finally {
            requestDone();
        }
    }

    public WriteResult removeUser( String username ){
        requestStart();
        try {
            if (useUserCommands(_connector.getPrimaryPort())) {
                CommandResult res = command(new BasicDBObject("dropUser", username));
                res.throwOnError();
                return new WriteResult(res, getWriteConcern());
            }
            else {
                return super.removeUser(username);
            }
        } finally {
            requestDone();
        }
    }

    private DBObject getUserCommandDocument(String username, char[] passwd, boolean readOnly, final String commandName) {
        return new BasicDBObject(commandName, username)
               .append("pwd", _hash(username, passwd))
               .append("digestPassword", false)
               .append("roles", Arrays.asList(getUserRoleName(readOnly)));
    }

    private String getUserRoleName(boolean readOnly) {
        return getName().equals("admin") ? (readOnly ? "readAnyDatabase" : "root") : (readOnly ? "read" : "dbOwner");
    }

    protected DBCollectionImpl doGetCollection( String name ){
        DBCollectionImpl c = _collections.get(name);
        if ( c != null )
            return c;

        c = new DBCollectionImpl(this, name );
        DBCollectionImpl old = _collections.putIfAbsent(name, c);
        return old != null ? old : c;
    }

    /**
     * @param force true if should clean regardless of number of dead cursors
     * @throws MongoException
     */
    public void cleanCursors( boolean force ){

        int sz = _deadCursorIds.size();

        if ( sz == 0 || ( ! force && sz < NUM_CURSORS_BEFORE_KILL))
            return;

        Bytes.LOGGER.info( "going to kill cursors : " + sz );

        Map<ServerAddress,List<Long>> m = new HashMap<ServerAddress,List<Long>>();
        DeadCursor c;
        while (( c = _deadCursorIds.poll()) != null ){
            List<Long> x = m.get( c.host );
            if ( x == null ){
                x = new LinkedList<Long>();
                m.put( c.host , x );
            }
            x.add( c.id );
        }

        for ( Map.Entry<ServerAddress,List<Long>> e : m.entrySet() ){
            try {
                killCursors( e.getKey() , e.getValue() );
            }
            catch ( Throwable t ){
                Bytes.LOGGER.log( Level.WARNING , "can't clean cursors" , t );
                for ( Long x : e.getValue() )
                        _deadCursorIds.add( new DeadCursor( x , e.getKey() ) );
            }
        }
    }

    void killCursors( ServerAddress addr , List<Long> all ){
        if ( all == null || all.size() == 0 )
            return;

        OutMessage om = OutMessage.killCursors(_mongo, Math.min( NUM_CURSORS_PER_BATCH , all.size()));

        int soFar = 0;
        int totalSoFar = 0;
        for (Long l : all) {
            om.writeLong(l);

            totalSoFar++;
            soFar++;

            if ( soFar >= NUM_CURSORS_PER_BATCH ){
                _connector.say( this , om ,com.mongodb.WriteConcern.NONE );
                om = OutMessage.killCursors(_mongo, Math.min( NUM_CURSORS_PER_BATCH , all.size() - totalSoFar));
                soFar = 0;
            }
        }

        _connector.say( this , om ,com.mongodb.WriteConcern.NONE , addr );
    }

    @Override
    CommandResult doAuthenticate(MongoCredential credentials) {
        return _connector.authenticate(credentials);
    }

    private boolean useUserCommands(final DBPort port) {
        return _connector.getServerDescription(port.getAddress()).getVersion().compareTo(new ServerVersion(2, 6)) >= 0;
    }

    void addDeadCursor(final DeadCursor deadCursor) {
        _deadCursorIds.add(deadCursor);
    }

    static class DeadCursor {

        DeadCursor( long a , ServerAddress b ){
            id = a;
            host = b;
        }

        final long id;
        final ServerAddress host;
    }

    final String _root;
    final String _rootPlusDot;
    final DBTCPConnector _connector;
    final ConcurrentHashMap<String,DBCollectionImpl> _collections = new ConcurrentHashMap<String,DBCollectionImpl>();

    ConcurrentLinkedQueue<DeadCursor> _deadCursorIds = new ConcurrentLinkedQueue<DeadCursor>();

}


text:
<?php

namespace RabbitEvents\Tests\Listener\Stubs;

class ListenerWithAttributeMiddleware
{
    public array $middleware = [
        'RabbitEvents\Tests\Listener\Stubs\ListenerMiddleware@action',
        ListenerMiddleware::class
    ];

    public function __construct()
    {
        ListenerMiddleware::$calledTimes = 0;
    }

    public function handle($payload): int
    {
        return ListenerMiddleware::$calledTimes;
    }
}


text:
{% extends "layout.html" %} {% block page_title %} Example - Forms {% endblock %} {% block content %}

  {% include "includes/phase_banner_alpha.html" %}
  <form action="/" method="post" class="form">

    {% include "custom_inc/backlink.html" %}

          Way to find a grid reference

Way 1

Way 2

Way 3

Way 4

Way 5

  </form>

{% endblock %}