text:
/* Programmer:  Quincey Koziol <koziol@ncsa.uiuc.ued>
 *              Friday, May 29, 1998
 *
 * Purpose:	Dataspace selection functions.
 */

#define H5S_PACKAGE		/*suppress error about including H5Spkg	  */

#include "H5private.h"		/* Generic Functions			*/
#include "H5Dprivate.h"		/* Datasets				*/
#include "H5Eprivate.h"		/* Error handling		  	*/
#include "H5FLprivate.h"	/* Free Lists                           */
#include "H5Iprivate.h"		/* IDs			  		*/
#include "H5Spkg.h"		/* Dataspaces 				*/
#include "H5Vprivate.h"		/* Vector and array functions		*/
#include "H5WBprivate.h"        /* Wrapped Buffers                      */

/* Local functions */
#ifdef LATER
static herr_t H5S_select_iter_block (const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end);
static htri_t H5S_select_iter_has_next_block (const H5S_sel_iter_t *iter);
static herr_t H5S_select_iter_next_block(H5S_sel_iter_t *iter);
#endif /* LATER */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_offset
 PURPOSE
    Set the selection offset for a datapace
 USAGE
    herr_t H5S_select_offset(space, offset)
        H5S_t *space;	        IN/OUT: Dataspace object to set selection offset
        const hssize_t *offset; IN: Offset to position the selection at
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Sets the selection offset for the dataspace
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    Only works for simple dataspaces currently
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_offset(H5S_t *space, const hssize_t *offset)
{
    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_offset)

    /* Check args */
    HDassert(space);
    HDassert(space->extent.rank);
    HDassert(offset);

    /* Copy the offset over */
    HDmemcpy(space->select.offset, offset, sizeof(hssize_t)*space->extent.rank);

    /* Indicate that the offset was changed */
    space->select.offset_changed = TRUE;

    FUNC_LEAVE_NOAPI(SUCCEED)
}   /* H5S_select_offset() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_copy
 PURPOSE
    Copy a selection from one dataspace to another
 USAGE
    herr_t H5S_select_copy(dst, src)
        H5S_t *dst;  OUT: Pointer to the destination dataspace
        H5S_t *src;  IN: Pointer to the source dataspace
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Copies all the selection information (include offset) from the source
    dataspace to the destination dataspace.

    If the SHARE_SELECTION flag is set, then the selection can be shared
    between the source and destination dataspaces.  (This should only occur in
    situations where the destination dataspace will immediately change to a new
    selection)
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_copy (H5S_t *dst, const H5S_t *src, hbool_t share_selection)
{
    herr_t ret_value;     /* return value */

    FUNC_ENTER_NOAPI(H5S_select_copy, FAIL);

    /* Check args */
    assert(dst);
    assert(src);

    /* Copy regular fields */
    dst->select=src->select;

    /* Perform correct type of copy based on the type of selection */
    if((ret_value=(*src->select.type->copy)(dst,src,share_selection))<0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy selection specific information");

done:
    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_copy() */

/*-------------------------------------------------------------------------
 * Function:	H5S_select_release
 *
 * Purpose:	Releases all memory associated with a dataspace selection.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		Friday, May 30, 2003
 *
 * Note: This routine participates in the "Inlining C function pointers"
 *      pattern, don't call it directly, use the appropriate macro
 *      defined in H5Sprivate.h.
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5S_select_release(H5S_t *ds)
{
    herr_t ret_value;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_release);

    assert(ds);

    /* Call the selection type's release function */
    ret_value=(*ds->select.type->release)(ds);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* end H5S_select_release() */

/*-------------------------------------------------------------------------
 * Function:	H5S_select_get_seq_list
 *
 * Purpose:	Retrieves the next sequence of offset/length pairs for an
 *              iterator on a dataspace
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		Tuesday, May 18, 2004
 *
 * Note: This routine participates in the "Inlining C function pointers"
 *      pattern, don't call it directly, use the appropriate macro
 *      defined in H5Sprivate.h.
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5S_select_get_seq_list(const H5S_t *space, unsigned flags,
    H5S_sel_iter_t *iter, size_t maxseq, size_t maxbytes,
    size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len)
{
    herr_t ret_value;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_get_seq_list);

    assert(space);

    /* Call the selection type's get_seq_list function */
    ret_value=(*space->select.type->get_seq_list)(space,flags,iter,maxseq,maxbytes,nseq,nbytes,off,len);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* end H5S_select_get_seq_list() */

/*-------------------------------------------------------------------------
 * Function:	H5S_select_serial_size
 *
 * Purpose:	Determines the number of bytes required to store the current
 *              selection
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *		Tuesday, May 18, 2004
 *
 * Note: This routine participates in the "Inlining C function pointers"
 *      pattern, don't call it directly, use the appropriate macro
 *      defined in H5Sprivate.h.
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
hssize_t
H5S_select_serial_size(const H5S_t *space)
{
    hssize_t ret_value;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_serial_size);

    assert(space);

    /* Call the selection type's serial_size function */
    ret_value=(*space->select.type->serial_size)(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* end H5S_select_serial_size() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_serialize
 PURPOSE
    Serialize the selection for a dataspace into a buffer
 USAGE
    herr_t H5S_select_serialize(space, buf)
        const H5S_t *space;     IN: Dataspace with selection to serialize
        uint8_t *buf;           OUT: Buffer to put serialized selection
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Calls the appropriate dataspace selection callback to serialize the
    current selection into a buffer.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_serialize(const H5S_t *space, uint8_t *buf)
{
    herr_t ret_value=SUCCEED;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_serialize);

    assert(space);
    assert(buf);

    /* Call the selection type's serialize function */
    ret_value=(*space->select.type->serialize)(space,buf);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* end H5S_select_serialize() */

/*--------------------------------------------------------------------------
 NAME
    H5Sget_select_npoints
 PURPOSE
    Get the number of elements in current selection
 USAGE
    hssize_t H5Sget_select_npoints(dsid)
        hid_t dsid;             IN: Dataspace ID of selection to query
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Returns the number of elements in current selection for dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
hssize_t
H5Sget_select_npoints(hid_t spaceid)
{
    H5S_t *space;               /* Dataspace to modify selection of */
    hssize_t ret_value;         /* return value */

    FUNC_ENTER_API(H5Sget_select_npoints, FAIL)
    H5TRACE1("Hs", "i", spaceid);

    /* Check args */
    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")

    ret_value = (hssize_t)H5S_GET_SELECT_NPOINTS(space);

done:
    FUNC_LEAVE_API(ret_value)
}   /* H5Sget_select_npoints() */

/*--------------------------------------------------------------------------
 NAME
    H5S_get_select_npoints
 PURPOSE
    Get the number of elements in current selection
 USAGE
    hssize_t H5Sget_select_npoints(space)
        H5S_t *space;             IN: Dataspace of selection to query
 RETURNS
    The number of elements in selection on success, 0 on failure
 DESCRIPTION
    Returns the number of elements in current selection for dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
     This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
hssize_t
H5S_get_select_npoints(const H5S_t *space)
{
    FUNC_ENTER_NOAPI_NOFUNC(H5S_get_select_npoints)

    /* Check args */
    HDassert(space);

    FUNC_LEAVE_NOAPI((hssize_t)space->select.num_elem)
}   /* H5S_get_select_npoints() */

/*--------------------------------------------------------------------------
 NAME
    H5Sselect_valid
 PURPOSE
    Check whether the selection fits within the extent, with the current
    offset defined.
 USAGE
    htri_t H5Sselect_void(dsid)
        hid_t dsid;             IN: Dataspace ID to query
 RETURNS
    TRUE if the selection fits within the extent, FALSE if it does not and
        Negative on an error.
 DESCRIPTION
    Determines if the current selection at the current offet fits within the
    extent for the dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
    Christian Chilan 01/17/2007
    Changed the error return value from 0 to FAIL.
--------------------------------------------------------------------------*/
htri_t
H5Sselect_valid(hid_t spaceid)
{
    H5S_t *space;       /* Dataspace to modify selection of */
    htri_t ret_value;   /* return value */

    FUNC_ENTER_API(H5Sselect_valid, FAIL)
    H5TRACE1("t", "i", spaceid);

    /* Check args */
    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")

    ret_value = H5S_SELECT_VALID(space);

done:
    FUNC_LEAVE_API(ret_value)
}   /* H5Sselect_valid() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_valid
 PURPOSE
    Check whether the selection fits within the extent, with the current
    offset defined.
 USAGE
    htri_t H5S_select_void(space)
        H5S_t *space;           IN: Dataspace to query
 RETURNS
    TRUE if the selection fits within the extent, FALSE if it does not and
        Negative on an error.
 DESCRIPTION
    Determines if the current selection at the current offet fits within the
    extent for the dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
     This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
htri_t
H5S_select_valid(const H5S_t *space)
{
    htri_t ret_value;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_valid);

    assert(space);

    ret_value = (*space->select.type->is_valid)(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_valid() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_deserialize
 PURPOSE
    Deserialize the current selection from a user-provided buffer into a real
        selection in the dataspace.
 USAGE
    herr_t H5S_select_deserialize(space, buf)
        H5S_t *space;           IN/OUT: Dataspace pointer to place selection into
        uint8 *buf;             IN: Buffer to retrieve serialized selection from
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Deserializes the current selection into a buffer.  (Primarily for retrieving
    from disk).  This routine just hands off to the appropriate routine for each
    type of selection.  The format of the serialized information is shown in
    the H5S_select_serialize() header.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_deserialize (H5S_t *space, const uint8_t *buf)
{
    const uint8_t *tbuf;    /* Temporary pointer to the selection type */
    uint32_t sel_type;       /* Pointer to the selection type */
    herr_t ret_value=FAIL;  /* return value */

    FUNC_ENTER_NOAPI(H5S_select_deserialize, FAIL);

    assert(space);

    tbuf=buf;
    UINT32DECODE(tbuf, sel_type);
    switch(sel_type) {
        case H5S_SEL_POINTS:         /* Sequence of points selected */
            ret_value=(*H5S_sel_point->deserialize)(space,buf);
            break;

        case H5S_SEL_HYPERSLABS:     /* Hyperslab selection defined */
            ret_value=(*H5S_sel_hyper->deserialize)(space,buf);
            break;

        case H5S_SEL_ALL:            /* Entire extent selected */
            ret_value=(*H5S_sel_all->deserialize)(space,buf);
            break;

        case H5S_SEL_NONE:           /* Nothing selected */
            ret_value=(*H5S_sel_none->deserialize)(space,buf);
            break;

        default:
            break;
    }
    if(ret_value<0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "can't deserialize selection");

done:
    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_deserialize() */

/*--------------------------------------------------------------------------
 NAME
    H5Sget_select_bounds
 PURPOSE
    Gets the bounding box containing the selection.
 USAGE
    herr_t H5S_get_select_bounds(space, start, end)
        hid_t dsid;             IN: Dataspace ID of selection to query
        hsize_t start[];        OUT: Starting coordinate of bounding box
        hsize_t end[];          OUT: Opposite coordinate of bounding box
 RETURNS
    Non-negative on success, negative on failure
 DESCRIPTION
    Retrieves the bounding box containing the current selection and places
    it into the user's buffers.  The start and end buffers must be large
    enough to hold the dataspace rank number of coordinates.  The bounding box
    exactly contains the selection, ie. if a 2-D element selection is currently
    defined with the following points: (4,5), (6,8) (10,7), the bounding box
    with be (4, 5), (10, 8).  Calling this function on a "none" selection
    returns fail.
        The bounding box calculations _does_ include the current offset of the
    selection within the dataspace extent.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5Sget_select_bounds(hid_t spaceid, hsize_t start[], hsize_t end[])
{
    H5S_t *space;       /* Dataspace to modify selection of */
    herr_t ret_value;   /* return value */

    FUNC_ENTER_API(H5Sget_select_bounds, FAIL)
    H5TRACE3("e", "i*h*h", spaceid, start, end);

    /* Check args */
    if(start == NULL || end == NULL)
        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer")
    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")

    ret_value = H5S_SELECT_BOUNDS(space, start, end);

done:
    FUNC_LEAVE_API(ret_value)
}   /* H5Sget_select_bounds() */

/*--------------------------------------------------------------------------
 NAME
    H5S_get_select_bounds
 PURPOSE
    Gets the bounding box containing the selection.
 USAGE
    herr_t H5S_get_select_bounds(space, start, end)
        H5S_t *space;           IN: Dataspace ID of selection to query
        hsize_t *start;         OUT: Starting coordinate of bounding box
        hsize_t *end;           OUT: Opposite coordinate of bounding box
 RETURNS
    Non-negative on success, negative on failure
 DESCRIPTION
    Retrieves the bounding box containing the current selection and places
    it into the user's buffers.  The start and end buffers must be large
    enough to hold the dataspace rank number of coordinates.  The bounding box
    exactly contains the selection, ie. if a 2-D element selection is currently
    defined with the following points: (4,5), (6,8) (10,7), the bounding box
    with be (4, 5), (10, 8).  Calling this function on a "none" selection
    returns fail.
        The bounding box calculations _does_ include the current offset of the
    selection within the dataspace extent.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_get_select_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_get_select_bounds);

    /* Check args */
    assert(space);
    assert(start);
    assert(end);

    ret_value = (*space->select.type->bounds)(space,start,end);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_get_select_bounds() */

/*--------------------------------------------------------------------------
 NAME
    H5S_get_select_offset
 PURPOSE
    Gets the linear offset of the first element for the selection.
 USAGE
    herr_t H5S_get_select_offset(space, offset)
        const H5S_t *space;     IN: Dataspace pointer of selection to query
        hsize_t *offset;        OUT: Linear offset of first element in selection
 RETURNS
    Non-negative on success, negative on failure
 DESCRIPTION
    Retrieves the linear offset (in "units" of elements) of the first element
    selected within the dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
        The offset calculation _does_ include the current offset of the
    selection within the dataspace extent.

        Calling this function on a "none" selection returns fail.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_get_select_offset(const H5S_t *space, hsize_t *offset)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_get_select_offset)

    /* Check args */
    HDassert(space);
    HDassert(offset);

    ret_value = (*space->select.type->offset)(space, offset);

    FUNC_LEAVE_NOAPI(ret_value)
}   /* H5S_get_select_offset() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_is_contiguous
 PURPOSE
    Determines if a selection is contiguous in the dataspace
 USAGE
    htri_t H5S_select_is_contiguous(space)
        const H5S_t *space;             IN: Dataspace of selection to query
 RETURNS
    Non-negative (TRUE/FALSE) on success, negative on failure
 DESCRIPTION
    Checks the selection to determine if the points to iterated over will be
    contiguous in the particular dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
htri_t
H5S_select_is_contiguous(const H5S_t *space)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_is_contiguous);

    /* Check args */
    assert(space);

    ret_value = (*space->select.type->is_contiguous)(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_is_contiguous() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_is_single
 PURPOSE
    Determines if a selection is a single block in the dataspace
 USAGE
    htri_t H5S_select_is_single(space)
        const H5S_t *space;             IN: Dataspace of selection to query
 RETURNS
    Non-negative (TRUE/FALSE) on success, negative on failure
 DESCRIPTION
    Checks the selection to determine if it occupies a single block in the
    particular dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
htri_t
H5S_select_is_single(const H5S_t *space)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_is_single);

    /* Check args */
    assert(space);

    ret_value = (*space->select.type->is_single)(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_is_single() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_is_regular
 PURPOSE
    Determines if a selection is "regular"  in the dataspace
 USAGE
    htri_t H5S_select_is_regular(space)
        const H5S_t *space;             IN: Dataspace of selection to query
 RETURNS
    Non-negative (TRUE/FALSE) on success, negative on failure
 DESCRIPTION
    Checks the selection to determine if it is "regular" (i.e. a single
    block or a strided pattern) in the particular dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
htri_t
H5S_select_is_regular(const H5S_t *space)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_is_regular);

    /* Check args */
    assert(space);

    ret_value = (*space->select.type->is_regular)(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_is_regular() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_adjust_u
 PURPOSE
    Adjust a selection by subtracting an offset
 USAGE
    herr_t H5S_select_adjust_u(space, offset)
        H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
        const hsize_t *offset; IN: Offset to subtract
 RETURNS
    Non-negative on success, negative on failure
 DESCRIPTION
    Moves a selection by subtracting an offset from it.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_adjust_u(H5S_t *space, const hsize_t *offset)
{
    herr_t ret_value;        /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_adjust_u)

    /* Check args */
    HDassert(space);

    ret_value = (*space->select.type->adjust_u)(space, offset);

    FUNC_LEAVE_NOAPI(ret_value)
}   /* H5S_select_adjust_u() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_init
 PURPOSE
    Initializes iteration information for a selection.
 USAGE
    herr_t H5S_select_iter_init(sel_iter, space, elmt_size)
        H5S_sel_iter_t *sel_iter; OUT: Selection iterator to initialize.
        H5S_t *space;           IN: Dataspace object containing selection to
                                    iterate over
        size_t elmt_size;       IN: Size of elements in the selection
 RETURNS
     Non-negative on success, negative on failure.
 DESCRIPTION
    Initialize the selection iterator object to point to the first element
    in the dataspace's selection.
--------------------------------------------------------------------------*/
herr_t
H5S_select_iter_init(H5S_sel_iter_t *sel_iter, const H5S_t *space, size_t elmt_size)
{
    herr_t ret_value;   /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_iter_init);

    /* Check args */
    assert(sel_iter);
    assert(space);

    /* Initialize common information */

    /* Save the dataspace's rank */
    sel_iter->rank=space->extent.rank;

    /* Point to the dataspace dimensions, if there are any */
    if(sel_iter->rank > 0)
        sel_iter->dims = space->extent.size;
    else
        sel_iter->dims = NULL;

    /* Save the element size */
    sel_iter->elmt_size=elmt_size;

    /* Call initialization routine for selection type */
    ret_value= (*space->select.type->iter_init)(sel_iter, space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_init() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_coords
 PURPOSE
    Get the coordinates of the current iterator position
 USAGE
    herr_t H5S_select_iter_coords(sel_iter,coords)
        H5S_sel_iter_t *sel_iter; IN: Selection iterator to query
        hsize_t *coords;         OUT: Array to place iterator coordinates in
 RETURNS
    Non-negative on success, negative on failure.
 DESCRIPTION
    The current location of the iterator within the selection is placed in
    the COORDS array.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_iter_coords (const H5S_sel_iter_t *sel_iter, hsize_t *coords)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_iter_coords);

    /* Check args */
    assert(sel_iter);
    assert(coords);

    /* Call iter_coords routine for selection type */
    ret_value = (*sel_iter->type->iter_coords)(sel_iter,coords);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_coords() */

#ifdef LATER

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_block
 PURPOSE
    Get the block of the current iterator position
 USAGE
    herr_t H5S_select_iter_block(sel_iter,start,end)
        const H5S_sel_iter_t *sel_iter; IN: Selection iterator to query
        hsize_t *start;    OUT: Array to place iterator start block coordinates
        hsize_t *end;      OUT: Array to place iterator end block coordinates
 RETURNS
    Non-negative on success, negative on failure.
 DESCRIPTION
    The current location of the iterator within the selection is placed in
    the COORDS array.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static herr_t
H5S_select_iter_block (const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_select_iter_block);

    /* Check args */
    assert(iter);
    assert(start);
    assert(end);

    /* Call iter_block routine for selection type */
    ret_value = (*iter->type->iter_block)(iter,start,end);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_block() */
#endif /* LATER */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_nelmts
 PURPOSE
    Get the number of elements left to iterate over in selection
 USAGE
    hssize_t H5S_select_iter_nelmts(sel_iter)
        H5S_sel_iter_t *sel_iter; IN: Selection iterator to query
 RETURNS
    The number of elements in selection on success, 0 on failure
 DESCRIPTION
    Returns the number of elements in current selection for dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
hsize_t
H5S_select_iter_nelmts (const H5S_sel_iter_t *sel_iter)
{
    hsize_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_iter_nelmts);

    /* Check args */
    assert(sel_iter);

    /* Call iter_nelmts routine for selection type */
    ret_value = (*sel_iter->type->iter_nelmts)(sel_iter);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_nelmts() */

#ifdef LATER

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_has_next_block
 PURPOSE
    Check if there is another block available in the selection iterator
 USAGE
    htri_t H5S_select_iter_has_next_block(sel_iter)
        const H5S_sel_iter_t *sel_iter; IN: Selection iterator to query
 RETURNS
    Non-negative on success, negative on failure.
 DESCRIPTION
    Check if there is another block available to advance to in the selection
    iterator.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static htri_t
H5S_select_iter_has_next_block (const H5S_sel_iter_t *iter)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_select_iter_has_next_block);

    /* Check args */
    assert(iter);

    /* Call iter_has_next_block routine for selection type */
    ret_value = (*iter->type->iter_has_next_block)(iter);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_has_next_block() */
#endif /* LATER */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_next
 PURPOSE
    Advance selection iterator to next element
 USAGE
    herr_t H5S_select_iter_next(iter, nelem)
        H5S_sel_iter_t *iter;   IN/OUT: Selection iterator to change
        size_t nelem;           IN: Number of elements to advance by
 RETURNS
    Non-negative on success, negative on failure.
 DESCRIPTION
    Move the current element for the selection iterator to the NELEM'th next
    element in the selection.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_iter_next(H5S_sel_iter_t *iter, size_t nelem)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_iter_next);

    /* Check args */
    assert(iter);
    assert(nelem>0);

    /* Call iter_next routine for selection type */
    ret_value = (*iter->type->iter_next)(iter,nelem);

    /* Decrement the number of elements left in selection */
    iter->elmt_left-=nelem;

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_next() */

#ifdef LATER

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_next_block
 PURPOSE
    Advance selection iterator to next block
 USAGE
    herr_t H5S_select_iter_next_block(iter)
        H5S_sel_iter_t *iter;   IN/OUT: Selection iterator to change
 RETURNS
    Non-negative on success, negative on failure.
 DESCRIPTION
    Move the current element for the selection iterator to the next
    block in the selection.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    Doesn't maintain the 'elmt_left' field of the selection iterator.

    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static herr_t
H5S_select_iter_next_block(H5S_sel_iter_t *iter)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_select_iter_next_block);

    /* Check args */
    assert(iter);

    /* Call iter_next_block routine for selection type */
    ret_value = (*iter->type->iter_next_block)(iter);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_next_block() */
#endif /* LATER */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iter_release
 PURPOSE
    Release a selection iterator's resources.
 USAGE
    hssize_t H5S_select_iter_release(sel_iter)
        H5S_sel_iter_t *sel_iter; IN: Selection iterator to query
 RETURNS
    The number of elements in selection on success, 0 on failure
 DESCRIPTION
    Returns the number of elements in current selection for dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_iter_release(H5S_sel_iter_t *sel_iter)
{
    herr_t ret_value;         /* return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_select_iter_release);

    /* Check args */
    assert(sel_iter);

    /* Call selection type-specific release routine */
    ret_value = (*sel_iter->type->iter_release)(sel_iter);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* H5S_select_iter_release() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_iterate
 PURPOSE
    Iterate over the selected elements in a memory buffer.
 USAGE
    herr_t H5S_select_iterate(buf, type_id, space, operator, operator_data)
        void *buf;      IN/OUT: Buffer containing elements to iterate over
        hid_t type_id;  IN: Datatype ID of BUF array.
        H5S_t *space;   IN: Dataspace object containing selection to iterate over
        H5D_operator_t op; IN: Function pointer to the routine to be
                                called for each element in BUF iterated over.
        void *operator_data;    IN/OUT: Pointer to any user-defined data
                                associated with the operation.
 RETURNS
    Returns the return value of the last operator if it was non-zero, or zero
    if all elements were processed. Otherwise returns a negative value.
 DESCRIPTION
    Iterates over the selected elements in a memory buffer, calling the user's
    callback function for each element.  The selection in the dataspace is
    modified so that any elements already iterated over are removed from the
    selection if the iteration is interrupted (by the H5D_operator_t function
    returning non-zero) in the "middle" of the iteration and may be re-started
    by the user where it left off.

    NOTE: Until "subtracting" elements from a selection is implemented,
        the selection is not modified.
--------------------------------------------------------------------------*/
herr_t
H5S_select_iterate(void *buf, hid_t type_id, const H5S_t *space, H5D_operator_t op,
        void *operator_data)
{
    H5T_t *dt;                  /* Datatype structure */
    H5S_sel_iter_t iter;        /* Selection iteration info */
    hbool_t iter_init = FALSE;  /* Selection iteration info has been initialized */
    uint8_t *loc;               /* Current element location in buffer */
    hsize_t coords[H5O_LAYOUT_NDIMS];  /* Coordinates of element in dataspace */
    hssize_t nelmts;            /* Number of elements in selection */
    hsize_t space_size[H5O_LAYOUT_NDIMS]; /* Dataspace size */
    hsize_t off[H5D_IO_VECTOR_SIZE];          /* Array to store sequence offsets */
    hsize_t curr_off;           /* Current offset within sequence */
    hsize_t tmp_off;            /* Temporary offset within sequence */
    size_t len[H5D_IO_VECTOR_SIZE];           /* Array to store sequence lengths */
    size_t curr_len;            /* Length of bytes left to process in sequence */
    size_t nseq;                /* Number of sequences generated */
    size_t curr_seq;            /* Current sequnce being worked on */
    size_t nelem;               /* Number of elements used in sequences */
    size_t max_elem;            /* Maximum number of elements allowed in sequences */
    size_t elmt_size;           /* Datatype size */
    unsigned ndims;             /* Number of dimensions in dataspace */
    int	i;			/* Local Index variable */
    herr_t user_ret=0;          /* User's return value */
    herr_t ret_value=SUCCEED;   /* Return value */

    FUNC_ENTER_NOAPI(H5S_select_iterate, FAIL);

    /* Check args */
    HDassert(buf);
    HDassert(H5I_DATATYPE == H5I_get_type(type_id));
    HDassert(space);
    HDassert(op);

    /* Get the datatype size */
    if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an valid base datatype")
    if(0 == (elmt_size = H5T_get_size(dt)))
        HGOTO_ERROR(H5E_DATATYPE, H5E_BADSIZE, FAIL, "datatype size invalid")

    /* Initialize iterator */
    if(H5S_select_iter_init(&iter, space, elmt_size) < 0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
    iter_init = TRUE;	/* Selection iteration info has been initialized */

    /* Get the number of elements in selection */
    if((nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(space)) < 0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't get number of elements selected")

    /* Get the rank of the dataspace */
    ndims = space->extent.rank;

    if(ndims > 0) {
	/* Copy the size of the space */
	HDassert(space->extent.size);
	HDmemcpy(space_size, space->extent.size, ndims * sizeof(hsize_t));
    } /* end if */
    space_size[ndims] = elmt_size;

    /* Compute the maximum number of bytes required */
    H5_ASSIGN_OVERFLOW(max_elem, nelmts, hssize_t, size_t);

    /* Loop, while elements left in selection */
    while(max_elem > 0 && user_ret == 0) {
        /* Get the sequences of bytes */
        if(H5S_SELECT_GET_SEQ_LIST(space, 0, &iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
            HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")

        /* Loop, while sequences left to process */
        for(curr_seq=0; curr_seq<nseq && user_ret==0; curr_seq++) {
            /* Get the current offset */
            curr_off = off[curr_seq];

            /* Get the number of bytes in sequence */
            curr_len = len[curr_seq];

            /* Loop, while bytes left in sequence */
            while(curr_len > 0 && user_ret == 0) {
                /* Compute the coordinate from the offset */
                for(i = (int)ndims, tmp_off = curr_off; i >= 0; i--) {
                    coords[i] = tmp_off % space_size[i];
                    tmp_off /= space_size[i];
                } /* end for */

                /* Get the location within the user's buffer */
                loc = (unsigned char *)buf + curr_off;

                /* Call user's callback routine */
                user_ret=(*op)(loc,type_id,ndims,coords,operator_data);

                /* Increment offset in dataspace */
                curr_off+=elmt_size;

                /* Decrement number of bytes left in sequence */
                curr_len-=elmt_size;
            } /* end while */
        } /* end for */

        /* Decrement number of elements left to process */
        max_elem-=nelem;
    } /* end while */

    /* Set return value */
    ret_value=user_ret;

done:
    /* Release selection iterator */
    if(iter_init && H5S_SELECT_ITER_RELEASE(&iter) < 0)
        HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")

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

/*--------------------------------------------------------------------------
 NAME
    H5Sget_select_type
 PURPOSE
    Retrieve the type of selection in a dataspace
 USAGE
    H5S_sel_type H5Sget_select_type(space_id)
        hid_t space_id;	        IN: Dataspace object to query
 RETURNS
    Non-negative on success/Negative on failure.  Return value is from the
    set of values in the H5S_sel_type enumerated type.
 DESCRIPTION
	This function retrieves the type of selection currently defined for
    a dataspace.
--------------------------------------------------------------------------*/
H5S_sel_type
H5Sget_select_type(hid_t space_id)
{
    H5S_t *space;	        /* dataspace to modify */
    H5S_sel_type ret_value;     /* Return value */

    FUNC_ENTER_API(H5Sget_select_type, H5S_SEL_ERROR)
    H5TRACE1("St", "i", space_id);

    /* Check args */
    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, H5S_SEL_ERROR, "not a dataspace")

    /* Set return value */
    ret_value = H5S_GET_SELECT_TYPE(space);

done:
    FUNC_LEAVE_API(ret_value)
}   /* end H5Sget_select_type() */

/*--------------------------------------------------------------------------
 NAME
    H5S_get_select_type
 PURPOSE
    Retrieve the type of selection in a dataspace
 USAGE
    H5S_sel_type H5Sget_select_type(space)
        const H5S_t *space;	        IN: Dataspace object to query
 RETURNS
    Non-negative on success/Negative on failure.  Return value is from the
    set of values in the H5S_sel_type enumerated type.
 DESCRIPTION
	This function retrieves the type of selection currently defined for
    a dataspace.
 COMMENTS
     This routine participates in the "Inlining C function pointers"
        pattern, don't call it directly, use the appropriate macro
        defined in H5Sprivate.h.
--------------------------------------------------------------------------*/
H5S_sel_type
H5S_get_select_type(const H5S_t *space)
{
    H5S_sel_type        ret_value;       /* Return value */

    FUNC_ENTER_NOAPI_NOFUNC(H5S_get_select_type);

    /* Check args */
    assert(space);

    /* Set return value */
    ret_value=H5S_GET_SELECT_TYPE(space);

    FUNC_LEAVE_NOAPI(ret_value);
}   /* end H5S_get_select_type() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_shape_same
 PURPOSE
    Check if two selections are the same shape
 USAGE
    htri_t H5S_select_shape_same(space1, space2)
        const H5S_t *space1;         IN: 1st Dataspace pointer to compare
        const H5S_t *space2;         IN: 2nd Dataspace pointer to compare
 RETURNS
    TRUE/FALSE/FAIL
 DESCRIPTION
    Checks to see if the current selection in the dataspaces are the same
    dimensionality and shape.
    This is primarily used for reading the entire selection in one swoop.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    Assumes that there is only a single "block" for hyperslab selections.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
htri_t
H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
{
    H5S_sel_iter_t iter1;               /* Selection #1 iteration info */
    H5S_sel_iter_t iter2;               /* Selection #2 iteration info */
    hbool_t iter1_init = 0;             /* Selection #1 iteration info has been initialized */
    hbool_t iter2_init = 0;             /* Selection #2 iteration info has been initialized */
    unsigned u;                         /* Index variable */
    htri_t ret_value = TRUE;            /* Return value */

    FUNC_ENTER_NOAPI(H5S_select_shape_same, FAIL)

    /* Check args */
    HDassert(space1);
    HDassert(space2);

    /* Special case for one or both dataspaces being scalar */
    if(space1->extent.rank == 0 || space2->extent.rank == 0) {
        /* Check for different number of elements selected */
        if(H5S_GET_SELECT_NPOINTS(space1) != H5S_GET_SELECT_NPOINTS(space2))
            HGOTO_DONE(FALSE)
    } /* end if */
    else {
        /* Check for different dimensionality */
        if(space1->extent.rank != space2->extent.rank)
            HGOTO_DONE(FALSE)

        /* Check for different number of elements selected */
        if(H5S_GET_SELECT_NPOINTS(space1) != H5S_GET_SELECT_NPOINTS(space2))
            HGOTO_DONE(FALSE)

        /* Check for "easy" cases before getting into generalized block iteration code */
        if(H5S_GET_SELECT_TYPE(space1)==H5S_SEL_ALL && H5S_GET_SELECT_TYPE(space2)==H5S_SEL_ALL) {
            hsize_t dims1[H5O_LAYOUT_NDIMS];             /* End point of selection block in dataspace #1 */
            hsize_t dims2[H5O_LAYOUT_NDIMS];             /* End point of selection block in dataspace #2 */

            if(H5S_get_simple_extent_dims(space1, dims1, NULL)<0)
                HGOTO_ERROR (H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get dimensionality");
            if(H5S_get_simple_extent_dims(space2, dims2, NULL)<0)
                HGOTO_ERROR (H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get dimensionality");

            /* Check that the sizes are the same */
            for (u=0; u<space1->extent.rank; u++)
                if(dims1[u]!=dims2[u])
                    HGOTO_DONE(FALSE);
        } /* end if */
        else if(H5S_GET_SELECT_TYPE(space1)==H5S_SEL_NONE || H5S_GET_SELECT_TYPE(space2)==H5S_SEL_NONE) {
            HGOTO_DONE(TRUE);
        } /* end if */
        else if((H5S_GET_SELECT_TYPE(space1)==H5S_SEL_HYPERSLABS && space1->select.sel_info.hslab->diminfo_valid)
                && (H5S_GET_SELECT_TYPE(space2)==H5S_SEL_HYPERSLABS && space2->select.sel_info.hslab->diminfo_valid)) {

            /* Check that the shapes are the same */
            for (u=0; u<space1->extent.rank; u++) {
                if(space1->select.sel_info.hslab->opt_diminfo[u].stride!=space2->select.sel_info.hslab->opt_diminfo[u].stride)
                    HGOTO_DONE(FALSE);
                if(space1->select.sel_info.hslab->opt_diminfo[u].count!=space2->select.sel_info.hslab->opt_diminfo[u].count)
                    HGOTO_DONE(FALSE);
                if(space1->select.sel_info.hslab->opt_diminfo[u].block!=space2->select.sel_info.hslab->opt_diminfo[u].block)
                    HGOTO_DONE(FALSE);
            } /* end for */
        } /* end if */
        /* Iterate through all the blocks in the selection */
        else {
            hsize_t start1[H5O_LAYOUT_NDIMS];      /* Start point of selection block in dataspace #1 */
            hsize_t start2[H5O_LAYOUT_NDIMS];      /* Start point of selection block in dataspace #2 */
            hsize_t end1[H5O_LAYOUT_NDIMS];        /* End point of selection block in dataspace #1 */
            hsize_t end2[H5O_LAYOUT_NDIMS];        /* End point of selection block in dataspace #2 */
            hsize_t off1[H5O_LAYOUT_NDIMS];        /* Offset of selection #1 blocks */
            hsize_t off2[H5O_LAYOUT_NDIMS];        /* Offset of selection #2 blocks */
            htri_t status1,status2;         /* Status from next block checks */
            unsigned first_block=1;         /* Flag to indicate the first block */

            /* Initialize iterator for each dataspace selection
             * Use '0' for element size instead of actual element size to indicate
             * that the selection iterator shouldn't be "flattened", since we
             * aren't actually going to be doing I/O with the iterators.
             */
            if(H5S_select_iter_init(&iter1, space1, (size_t)0) < 0)
                HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator");
            iter1_init = 1;
            if(H5S_select_iter_init(&iter2, space2, (size_t)0) < 0)
                HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator");
            iter2_init = 1;

            /* Iterate over all the blocks in each selection */
            while(1) {
                /* Get the current block for each selection iterator */
                if(H5S_SELECT_ITER_BLOCK(&iter1,start1,end1)<0)
                    HGOTO_ERROR (H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get iterator block");
                if(H5S_SELECT_ITER_BLOCK(&iter2,start2,end2)<0)
                    HGOTO_ERROR (H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get iterator block");

                /* The first block only compares the sizes and sets the relative offsets for later blocks */
                if(first_block) {
                    /* If the block sizes from each selection doesn't match, get out */
                    for (u=0; u<space1->extent.rank; u++) {
                        if((end1[u]-start1[u])!=(end2[u]-start2[u]))
                            HGOTO_DONE(FALSE);

                        /* Set the relative locations of the selections */
                        off1[u]=start1[u];
                        off2[u]=start2[u];
                    } /* end for */

                    /* Reset "first block" flag */
                    first_block=0;
                } /* end if */
                else {
                    /* Check over the blocks for each selection */
                    for (u=0; u<space1->extent.rank; u++) {
                        /* Check if the blocks are in the same relative location */
                        if((start1[u]-off1[u])!=(start2[u]-off2[u]))
                            HGOTO_DONE(FALSE);

                        /* If the block sizes from each selection doesn't match, get out */
                        if((end1[u]-start1[u])!=(end2[u]-start2[u]))
                            HGOTO_DONE(FALSE);
                    } /* end for */
                } /* end else */

                /* Check if we are able to advance to the next selection block */
                if((status1=H5S_SELECT_ITER_HAS_NEXT_BLOCK(&iter1))<0)
                    HGOTO_ERROR (H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to check iterator block");
                if((status2=H5S_SELECT_ITER_HAS_NEXT_BLOCK(&iter2))<0)
                    HGOTO_ERROR (H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to check iterator block");

                /* Did we run out of blocks at the same time? */
                if(status1==FALSE && status2==FALSE)
                    break;
                else if(status1!=status2) {
                    HGOTO_DONE(FALSE);
                } /* end if */
                else {
                    /* Advance to next block in selection iterators */
                    if(H5S_SELECT_ITER_NEXT_BLOCK(&iter1)<0)
                        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to advance to next iterator block");
                    if(H5S_SELECT_ITER_NEXT_BLOCK(&iter2)<0)
                        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to advance to next iterator block");
                } /* end else */
            } /* end while */
        } /* end else */
    } /* end else */

done:
    if(iter1_init) {
        if (H5S_SELECT_ITER_RELEASE(&iter1)<0)
            HDONE_ERROR (H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
    } /* end if */
    if(iter2_init) {
        if (H5S_SELECT_ITER_RELEASE(&iter2)<0)
            HDONE_ERROR (H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
    } /* end if */

    FUNC_LEAVE_NOAPI(ret_value)
}   /* H5S_select_shape_same() */

/*--------------------------------------------------------------------------
 NAME
    H5S_select_fill
 PURPOSE
    Fill a selection in memory with a value
 USAGE
    herr_t H5S_select_fill(fill,fill_size,space,buf)
        const void *fill;       IN: Pointer to fill value to use
        size_t fill_size;       IN: Size of elements in memory buffer & size of
                                    fill value
        H5S_t *space;           IN: Dataspace describing memory buffer &
                                    containing selection to use.
        void *buf;              IN/OUT: Memory buffer to fill selection in
 RETURNS
    Non-negative on success/Negative on failure.
 DESCRIPTION
    Use the selection in the dataspace to fill elements in a memory buffer.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    The memory buffer elements are assumed to have the same datatype as the
    fill value being placed into them.
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_buf)
{
    H5S_sel_iter_t iter;        /* Selection iteration info */
    hbool_t iter_init = 0;      /* Selection iteration info has been initialized */
    hssize_t nelmts;            /* Number of elements in selection */
    size_t max_elem;            /* Total number of elements in selection */
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_NOAPI(H5S_select_fill, FAIL)

    /* Check args */
    HDassert(fill);
    HDassert(fill_size > 0);
    HDassert(space);
    HDassert(_buf);

    /* Initialize iterator */
    if(H5S_select_iter_init(&iter, space, fill_size) < 0)
        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
    iter_init = 1;	/* Selection iteration info has been initialized */

    /* Get the number of elements in selection */
    if((nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(space)) < 0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't get number of elements selected")

    /* Compute the number of bytes to process */
    H5_ASSIGN_OVERFLOW(max_elem, nelmts, hssize_t, size_t);

    /* Loop, while elements left in selection */
    while(max_elem > 0) {
        hsize_t off[H5D_IO_VECTOR_SIZE];          /* Array to store sequence offsets */
        size_t len[H5D_IO_VECTOR_SIZE];           /* Array to store sequence lengths */
        size_t nseq;                /* Number of sequences generated */
        size_t curr_seq;            /* Current sequnce being worked on */
        size_t nelem;               /* Number of elements used in sequences */

        /* Get the sequences of bytes */
        if(H5S_SELECT_GET_SEQ_LIST(space, 0, &iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
            HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")

        /* Loop over sequences */
        for(curr_seq = 0; curr_seq < nseq; curr_seq++) {
            uint8_t *buf;               /* Current location in buffer */

            /* Get offset in memory buffer */
            buf = (uint8_t *)_buf + off[curr_seq];

            /* Fill each sequence in memory with fill value */
            HDassert((len[curr_seq] % fill_size) == 0);
            H5V_array_fill(buf, fill, fill_size, (len[curr_seq] / fill_size));
        } /* end for */

        /* Decrement number of elements left to process */
        max_elem -= nelem;
    } /* end while */

done:
    /* Release resouces */
    if(iter_init && H5S_SELECT_ITER_RELEASE(&iter) < 0)
        HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")

    FUNC_LEAVE_NOAPI(ret_value)
}   /* H5S_select_fill() */

redpajama_set_name: RedPajamaGithub


I believe at this point we are expected to have the appropriate number of significant figures. I would imagine the grading/marking off for incorrect significant figures will be similar to the midterm.
For this last homework assignment, can we still do problems from outline #4 (Molecular Shape & Structure) or are we expected to only do problems from outlines 5 (Coordination Compounds and their Biological Importance) and 6 (Acid and Base Structures and Properties)? Thanks in advance!
I am having a little trouble remembering the reasoning behind cis-diamine-dichloro-platinum(II) being an effective cancer treatment, while trans-diamide-dichloro-platinum(II) is not. Can anyone clarify? Thanks in advance!
I actually had the same question because it seemed like such a dramatic change in how its depicted. From what I've read they only mention there was "a change in convention", which doesn't really answer the question. Maybe Lavelle or other Chemmods are able to add more insight.
Just a minor correction, for the asked (e-) configuration of Bi^3+ you would get [Xe] 4f14 5d10 6s2 since the (+3) removes the last three (e-)s from the original (e-) configuration of Bi ([Xe] 4f14 5d10 6s2 6p3).
The octet rule simply states that 3rd period elements will either want to accept or give away (e-)'s to obtain a full octet, to have an (e-) configuration of a noble gas.
Just to clarify for part (d),would we just state that we found the values by adding and subtracting electrons to obtain a full octet, or is other reasoning? Thanks in advance!
Hey, so I am still having a little trouble with this problem. I know we must use the equation λ=(h/p) = (h/ (m*v)), but could anyone clarify how to solve this problem? Thanks in advance!
For my section (1E) our teaching assistant said we could and should turn in problems from outline 2 since they would serve as good practice for our midterm. However, it may vary from section to section, so it might be best to ask your teaching assistant directly.
Hey! So I didn't get a chance to attend the UA's review session last Friday (12:00 - 1:50 LaKretz 110), but does anyone know where we can find the answer key to the Practice Test (Lyndon's) they were going to review? Thanks in advance!
So from what I have read, the Bohr radius is a given constant with a value of a = 5.29177 x 10^-11 meters. What the Bohr constant represents is the average radius of a ground state hydrogen atom's orbit.
When an electron shifts position from one subshell to another they have undergone a change in energy. Movement to a higher energy subshell means that the electron has absorbed (gained) energy, and movement to a lower subshell would reflect the electrons' emission (loss) of energy.
Presenting the electron configuration of Br- as [Kr] would be correct, but keep in mind that they may be expecting you to give the full electron configuration rather than just the shorthand.
I believe the purpose of a vacuum in this experiment ensures that the ejection of the electrons from the metal observed was a result of the applied photons, and not other variables that could have potentially contributed to the ejection of the electrons if not removed (i.e. air molecules).
As a sidenote, for those that read like 4(O2)3, you would first multiply the subscripts then multiply by the coefficient. In this example, you'd get 6 oxygen from multiplying the subscript (2 x 3= 6), then multiply the result by the coefficient (4 x 6 = 24) giving you a total of 24 Oxygens.


text:
Pacu-caranha ou Pacuguaçu: originário  principalmente do Rio Paraguai e no Rio Paraná ocorre desde a província de Entre Rios na Argentina até a represa de Itaipu. A sinonímia para este peixe é: Piaractus mesopotamicus = Colossoma mitrei.

Pacu preto ou pacu negro

O pacu-caranha apresenta a cor negra quando encontrado em rios do Pantanal de águas cristalinas e  isto também ocorre na Amazônia com o tambaqui (Colossoma macropomus) em alguns rios (mesmo a cor comum ao tambaqui ser outra) e também ocorre com (Colossoma bidens). Já o pacu-caranha do Rio Aquidauana não apresenta a cor negra sendo bem mais claro.

Hibridação

Tambacu: Híbrido entre tambaqui (Colossoma macropomus) e pacu-caranha (Colossoma mitrei).
Foi criado para combinar o maior crescimento do tambaqui e a resistência ao frio do pacu.

Introdução em novas áreas
Devido a qualidade da carne, o pacu-caranha, foi introduzido em vários cursos de água na região sudeste e nordeste do Brasil.

Caracídeos
Peixes do Brasil
Peixes descritos em 1887

redpajama_set_name: RedPajamaWikipedia


Our week of pumps continues with a stunning and eye-catching, black and white graphic pump from a sensational designer. We just love the black and white trend in footwear, there are just so many ways this trend can be celebrated. With these Vivienne Westwood Maggie Pumps, the black and white trend is showcased in a fabric upper with an allover squiggle design; these pumps also boasts the gold-tone Vivienne Westwood orb detail, and a slim 4 1/4" stiletto heel with 1/2" platform. We are torn between the above black and white, which is on sale for $156.99 or the stunning bone/coral (pictured below - you can't have spring/summer without a lovely pastel), which retails for $242.99.
Both of these pumps (there is a third color called petrol) are available on 6pm.com but we know they will sell out quickly.


text:
Q: How to validate ROC and UENO Company Type with Input? (Singapore) I am supposed to select the Company Type, let's say UENO then the input will be validated. Company ROC or UENO  can be differentiate as follows:
UENO: it must start with alphabet "R" or "S" or "T" followed by 2 numeric, followed by 2 alphabets and 4 numeric and end with 1 alphabet.
ROC : - it must start with 9 numeric and end with 1 alphabet; OR
- start with "F" followed by 8 numeric and end with 1 alphabet.
Currently, this is what I have.
    public static bool IsValidUeno(string ueno)
    {
        if (string.IsNullOrWhiteSpace(ueno))
        {
            return false;
        }

        // Check length

        if (ueno.Length != 10)
        {
            return false;
        }

        char first = ueno.First();

        if (first != 'R' || first != 'S' || first != 'T')
        {
            return false;
        }

        return true;
    }

A: You'll need regex to do this. For UENO it will be
(^R{1}|^S{1}|^T{1})(\d{2})([a-zA-Z]{2})(\d{4})([a-zA-Z]{1}$)
For ROC it will be
(^\d{9})([a-zA-Z]$)|(^F{1})(\d{8})([a-zA-Z]$)

redpajama_set_name: RedPajamaStackExchange


The new crest also adopts a modern shield design as Coventry City look to the future ahead of the club's move to their brand new 32,000-seater home in August.
Said chairman Mike McGinnity: "We feel that with the move to the Arena this summer, Coventry City Football Club is making strides forward and it is an ideal time to introduce a new badge.
"Our existing crest has been in use for over 20 years and while it symbolises much of the tradition of our past, we felt that a change was needed to symbolise our future.
"This was not a decision we arrived at lightly and we are aware of how much the badge means to our supporters. I hope that given time, they will take this new design to their hearts."
The new badge will begin to appear on club literature immediately and will be phased in completely by the time the Sky Blues play their first game at the Arena.
It will also feature on the 2005-06 playing kit.


We take a look at the Dalesman, finding out how a Quaker from Plymouth became one of the biggest voice for the Yorkshire Dales.
Born into a Quaker family in Plymouth in 1903, Harry J Scott moved with his parents to Leeds as a young boy, with the family soon settling in the Hyde Park area of the city. Having been prevented from a career in architecture due to the cost of training, he went into accountancy, before becoming a journalist with the Yorkshire Evening Post then the Yorkshire Post.
Harry soon settled down to raise a family with his wife, Dorothy, bearing two children – Martin and Margaret. They were both great lovers of the Dales, and each summer would rent part of a farm at Folly Hall in the Washburn Valley. While staying there, Harry would still travel to work in Leeds. As they had no car, he had to walk into Otley in order to get the bus. It was during this time that he started taking notes of everyday Dales life, local customs, and the interesting folk he met, along with their equally interesting tales. Around this time he failed to get a job with Robertson Scott – founders of the Countryman magazine in Banbury, Oxfordshire.
This setback prompted Harry to decide that he would like to start his own magazine in the Dales for the people who lived there. He discovered an advertisement in the Yorkshire Post for a little house to rent in Clapham at the foot of Ingleborough. His previous accounting experience came to good use here, for he realised that by earning £3 a week in Leeds, he could easily afford the 10 shillings a week rent. They fell in love with the property and moved there immediately, with Harry making the daily commute to Leeds by train.
At the start of 1939, Harry showed his shoebox full of notes to a few journalist friends, such as Linton Andrews, then editor of the Leeds Mercury (and later editor of the Yorkshire Post). He gave Harry a loan of £50 to begin the project. Boosted by similar loans from six other friends, he was now in a position to be able to start his magazine. He set about putting together the first edition in the front parlour of his house, which they had named 'Fellside'. Having hand-set the 28-pages himself in March of the same year, he had the Yorkshire Dalesman magazine printed by Lamberts of Settle at a cost of £25 for 3,000 copies.
The first issue also featured a letter from Bradford born Playwright J.B. Priestley, who gave a shining endorsement for the new publication, stating "I am glad to learn that our beloved Dales are to have their own magazine and I wish the venture the success it deserves". Many of the popular features of the magazine today were included such as 'A Yorkshire Dalesman's Diary' and 'Reader's Club'.
Despite increased readership over the first few months, during World War Two, production was limited to no more than 4,000 copies, with fewer pages, on poor quality paper. Although times were tough, the family business survived; and in 1947, due to increased pressure from readers, coverage was expanded from just the Western Dales to the whole of rural Yorkshire – from Cleveland and Teeside in the North East to the Pennine valleys of the Yorkshire-Lancashire border in the South West. In 1948 it was renamed simply The Dalesman, and in 1955 with a circulation of over 25,000 moved to new premises in Clapham, where it remained until a move to Skipton in 2000.
Today, along with The Dalesman magazine, the company is also one of the North of England's biggest publishers of books and calendars; and has a number of sister publications including the Countryman which declined Harry J Scott employment in his early career. The magazine is also one of the biggest regional publications in the North. In 2011 The Dalesman had a readership of over 140,000 worldwide and continues to entertain its loyal band of followers with stories, competitions and features from all the Ridings.
In 2014 it celebrated 75 years of publications, with endorsements from both the Queen and David Cameron. The magazine continues to publish monthly from its headquarters in Skipton.
In the next post in this series, we will look at Cats Eyes.


text:
Exploring Southern Modernism in downtown Charleston
Late last year, the downtown district of Charleston, South Carolina, welcomed a significant addition to its historic Marion Square with the opening of The Dewberry, a one-of-a-kind boutique hotel in the heart of the city's peninsula.
Housed in a former Federal Office Building commissioned by President John F. Kennedy in 1963, The Dewberry's owner, John Dewberry, spent eight years transforming the building into a 155-room hotel with the help of the New York and Charleston-based design agency Workstead, the masterminds behind the transformation of another 12hrs favorite, Brooklyn's Wythe Hotel.
Workstead describes the style of the Dewberry as an "expression of Southern Modernism," mixing traditional Southern materials and bespoke details that enhance the modernist architecture and finishes of the former federal building. Replicas of the building's original wood paneling, art déco furniture and hand-painted wallpaper by local artist Becca Barnet contribute to the originality and timelessness of the hotel's design.
Guest rooms at the Dewberry range from Standard King suites to 50 square meter big flats, with a luxurious but straight-forward approach that mixes hand-crafted mahogany furniture with quarry marble finishes sourced from Vermont. Each of the hotel's guestrooms offers visitors scenic views onto Marion Square and many other signature landmarks across Charleston.
At the heart of the Dewberry is the Living Room, a bar and gathering space for guests and visitors that mixes mid-century Danish antiques with contemporary design pieces, a selection of which was created especially for this location. The hotel's common areas also include a ballroom, nightclub and the hotel's brasserie Henrietta's, a Charleston institution serving a contemporary take on classic regional dishes in the heart of this southern food capital.
The Dewberry // 334 Meeting Street // Charleston // website
By Alex Rodríguez|2018-04-22T16:39:54+02:00December 6th, 2017|Charleston|
©2014-2019 All Rights Reserved. 12hrs - Travel guides for people like you!

redpajama_set_name: RedPajamaCommonCrawl


Lifting Group pakub tooteid ja teenuseid üle kogu Euroopa, olles hetkel aktiivne Eestis, Lätis, Leedus, Soomes, Rootsis, Norras, Taanis, Saksamaal, Ühendkuningriikides, Venemaal, Belgias, Hollandis, Prantsusmaal ja Hispaanias. Igat nimetatud riiki katab võrgustik esindustest ning teenindusbussidest, tänu millele saame pakkuda oma klientidele parimat teadmiste põhist teenindust toetudes oma pikaajalisele kogemusele.
"Lifting Solutions is a global player specialising in lifting equipment, steel wire rope and services. It operates as a group of companies that supply wire rope, hoists, overhead cranes and other lifting products together with connected services. The companies serve local clients and global customers in ports and the energy, manufacturing and construction sectors"
Axel Johnson International koondab endas peale Lifting Solutions'i veel kolme valdkonda: Industrial Solutions, Fluid Handling Solutions ja Transport Solutions.
"The business concept has a long-term ownership horizon without an exit strategy. This means that we concentrate on companies with a sustainable business model that we can support through active ownership. Maintaining sustainable business models means keeping a watchful eye at all times on market dynamics to ensure we move and adapt in accordance with the customer needs. We build and develop business groups with companies that complement and strengthen each other. Our approach enables them to share information, experience, and know-how to underpin long-term growth and profitability."
Me oleme seal, kus teie!
Kliendile olemas olla on Certexis väga oluline. Meie esindustes töötavad oma ala spetsialistid, kes on kursis kohaliku turu vajadustega. Iga Certexi esindus on varustatud just selle piirkonna vajadustele vastava kauba ja teenustega, et pakkuda kiiret ja efektiivset lahendust igas olukorras. Meie The Lifting KnowHow tooted on Teile kättesaadavad üle terve Eesti.


Opening hours: The working week is generally from Sun-Thu with some businesses open Saturday mornings. Government offices: 7:30am-2:30pm. Banks: 9:30am-4:30pm. Private businesses: 8am-12pm and 4pm-8pm.
Tourist information: Saudi Tourist & Travel Bureau Ltd.
The constant buzz of life on the 35km-long Corniche is a microcosm for the whole city. There is no better place in the city for people-watching, as throngs of students, lovers, families and elderly couples stroll along the coast or enjoy a picnic and the sea breeze.
The city of Jeddah dates back to the 7th century, when it was founded by fishermen in what is now the Al-Balad neighborhood. The area still retains its ancient feel, boasting some of the oldest and most beautiful buildings in the city, made of traditional coral stones and wood.
Located just off the Corniche in the waters of the Red Sea, King Fahd's Fountain is the tallest of its kind in the world. The water reaches a dizzying height of almost 300 metres. No walk along the Corniche would be complete without stopping to admire it.
Also known as the White Mosque because of its beautiful while marble exterior, this impressive architectural feat juts out over the water, creating the illusion that it is floating, particularly when lit up at night. Pilgrims on their way to Mecca often make a point to stop here to admire the building and worship.
For a look at the rich sea life in the area and around the world, check out the Fakieh Aquarium. It showcases a wide range of aquatic species, including turtles, sharks, an array of colourful fish and many more forms of marine life. There are also some entertainment options for children and a buffet restaurant in the complex. The dolphin show should not to be missed.
Jeddah's massive old walls were built to protect the city from Portuguese attacks coming from the Red Sea. Although the wall no longer stands, the six impressive gates and towers can still be admired throughout the city. The gates are attractively illuminated after dark, so a nighttime stroll through the old town in search of the gates is a great way to explore Jeddah.
Seafood lovers will not want to skip Jeddah's famous fish market. It can get a bit hectic (not to mention smelly), especially during the morning's catch sale which takes place every day, where the absolute freshest specimens can be bought. Even if you end up not buying anything, the market is a unique experience.
The nearly 2,500-year old history of the Jeddah area is showcased in this superb museum, which has exhibitions on everything from pre-islamic history, though pre-modern civilizations, to the rich Islamic cultural heritage of the city. The complex also contains a mosque and the facade of an old castle.


text:
This will close in 10 seconds skip ×
Closes in 10 seconds skip ×
UB Tech® Conference
Admin & Management
Access & Enrollment
IT & AV
Writing for University Business
Be a Source for a University Business story
Working with Editorial
Register – PR Agency
Subscribe to University Business
Web replica of the print magazine.
View Digital Edition.
This search is limited to articles published in the last three years. For a more comprehensive search of every issue, please visit our nxtbook media page. Type your search term above
Dozens of 'elites' urged to add Pell Grant students
A small change in admissions could make a big difference to low-income learners
By: Matt Zalaznick | Issue: July, 2017
A small change in admissions at many of the most selective colleges and universities could make a big difference to low-income learners.
To meet a goal of having all schools enroll at least 20 percent Pell Grant recipients, about 350 "elite" institutions would have to admit about 20,000 low-income students, says a new report from the Georgetown Center for Education and the Workforce.
"A lot of has been given to the wealthiest colleges in terms of property tax breaks, endowments that accumulate without being taxed, participation in federal student loans and research funding," says Martin Van Der Werf, a co-author of the report and the center's associate director of editorial and postsecondary policy.
"We think that builds a public responsibility at these places to pay back across society."
The report spotlighted these institutions because they often provide the wide range of support services—such as mentoring and more comprehensive advising—that less-prepared but academically qualified students need to succeed in college.
Institutions that enroll large numbers of these students don't always have the capacity to offer intensive academic assistance, Van Der Werf says.
Highly competitive colleges should be able to afford the shift. The report found the budget surplus at the 69 most selective institutions averages $139 million annually.
The report's 20 percent figure comes from two places: A bipartisan Senate bill proposes fining schools, via federal financial aid, that don't enroll a certain number of Pell students. Early estimates indicate that threshold would be around 20 percent.
Also, about 39 percent of all undergraduates receive Pell Grants; the center believes 20 percent—about half that rate—is a fair and attainable goal for elite institutions.
That benchmark was achieved long ago by the University of Southern California, one of the country's most selective, private institutions. Around 22 percent to 24 percent of its students receive Pell Grants, says Thomas McWhorter, USC's dean of financial aid.
The work starts with USC recruiters, who visit some 2,100 high schools annually."It's a combination of extensive recruiting and finding the brightest students everywhere we can find them, regardless of their socioeconomic status," McWhorter says. "It's also about having good pipeline programs."
One those programs, the Neighborhood Academic Initiative, focuses on middle and high schools students from the impoverished communities near campus. Students and their families begin preparing for college in sixth grade.
Starting in high school, the students attend college-oriented math and English classes on campus each morning before heading to their regular high schools. They must also participate with their parents in a Saturday academy that covers topics around supporting college students academically, financially and emotionally.
USC guarantees full scholarships to students who complete the program.
The university has articulation agreements with many area community colleges. More than 40 percent of USC transfer students receive Pell Grants. Simply enrolling Pell Grant students, of course, is not the end goal. "When they get to USC," McWhorter says, "these students are all graduating at the same rates as others."
Highly selective colleges that enroll more than 20 percent Pell Grant recipients:
University of California, Los Angeles- 35.9%
University of California, Berkeley- 31.4%
Vassar College- 23.3%
Ohio State University-Columbus 22.4%
Smith College- 22.2%
Amherst College- 21.9%
New York University- 21.5%
Columbia University- 21.4%
University of Missouri-Columbia 21.4%
Emory University- 21.3%
The University of North Carolina at Chapel Hill- 21.3%
Source: Georgetown University Center on Education and the Workforce
Topics: Uncategorized
7 ways rightsizing (not downsizing) can help save colleges
Two tsunamis are about to hit higher ed
Will your institution hold on through 2020?
More from University Business
Key Strategies to Migrate Analog Video to Digital on Your Campus
When UW-La Crosse saw the analog writing on the wall, it embarked on a multiyear project to transform tens of thousands of hours of video footage into searchable digital files. […]
Jacques: Men face discrimination on campus
A Michigan university professor is on a mission to fight campus discrimination. Against men.
College Presidents and Chief Enrollment Officers: A strategic bond
Enrollment management presents one of the most pressing challenges for many institutions in the current higher education landscape. Uncertain economic conditions, stretched institutional budgets, dependence on tuition revenue, increased competition […]
Go to Homepage >
© 2020. University Business. All rights reserved. 35 Nutmeg Drive, Suite 205, Trumbull, CT, 06611
We use cookies to ensure we give you the best experience on our site. By continuing to use our site without changing your settings, you're agreeing to our cookie policy. Click to view our cookie policy.


text:
Time limit is exhausted. Please reload CAPTCHA. + one =
Frankie Carrera – "Noche" Featuring Khalil
Growing up in a musical family, R&B/Hip-Hop artist Frankie Carerra was always around music. But it wasn't until he blew up on his college campus at Arizona State University that he really started taking his career more seriously as an artist.
Gaining exposure with his song "Motherland," Frankie Carrera dropped the viral video during Spring Break at ASU, but when he came back he was unexpectedly an overnight celebrity on campus. Gaining followers, plays and likes, from a whole new legion off fans, Frankie Carrera began regularly traveling to LA to record and in order to gain more exposure through networking.
"Music has always been in my family, my dad was a drummer and then I started doing classical piano at a really early age. In high school I started listening to Rockie Fresh and that really set it off for me writing more R&B/Hip-Hop styled music. Then I went to Arizona State University that escalated to more shows and opportunities," Frankie Carrera said.
As kid Frankie's father played the drums and Frankie Carrera was trained on classical piano, which eventually lead to him writing more R&B/Hip-Hop styled songs in high school, but his unexpected success in college was on a whole new level as he was quickly becoming a viral sensation.
"When I did my song and video Motherland and it blew up on campus at ASU, I was getting a lot of comparisons to Sammy Adams and artists like Asher Roth who had experienced success in their college years. I was like an overnight celebrity on campus after Spring Break. When I got back to school I had a shitload of new followers, it was really a crazy time. " Frankie Carrera said.
Finally after expanding his fan base with various releases on campus and trips back and forth to LA, Frankie Carrera was able to connect with longtime manager for Khalil, Blake Robbins.
"I ended up meeting Blake and Khalil, they knew of me and they were amazing people and really helped me get started. I needed a place to record in LA and they helped pull that all together so that I could realize my dreams of recording and taking this to another level," Frankie said.
Frankie Carerra ended up writing his song "Noche" shorty after meeting the guys and recorded the song separately while Khalil was touring abroad with Justin Bieber.
"While Khalil was in London recording and traveling with Justin, I began to record at their studio in LA and had actually recorded the song Noche really quickly just stepping in the booth messing around. But when Khalil came back he jumped on the record and that was pretty much it. Brandon the engineer said 'he heard the record and Khalil got on it in like 20 minutes.'"
Now with anticipation building on the single, the guys are pepared to release the highly anticipated visual which was directed by rising video director Louie Knows.
"It wasn't a huge budget for the video but it really came out crazy," Frankie Carrera said. " The key is organization and doing it the right way. I'm so focused on my craft, that right now I feel like I can jump on any genre of music. I went to Brazil and I worked with producers down there. I know that R&B and Hip-Hop are my background but I am so diverse, I feel like I can do so many things. I always put my tastes into whatever environment I'm around and I think you can hear that on Noche."
Frankie Carrera- "Noche" Featuring Khalil
JDope – "Cold"
Swain Releases "Blue Stop" Single
P. Phileston – Girl I'm Zoe #HipHop @kellafellaent
(Video) Serena Kern – Drop Top ft. Ms Banks @Serena_Kern @MsBanks94


text:
mother! | New York Premiere
Jennifer Lawrence, Javier Bardem and Director Darren Aronofsky walked the red carpet at the New York Premiere of mother! on September 13, 2017 at Radio City Music Hall.
Related Topics:Darren AronofskyJavier BardemJennifer Lawrence
Kel'Thuzad – Heroes Of The Storm Review
John Woo Would Direct a James Bond Movie
Red Sparrow Review
Red Sparrow Australian Release Date & Trailer
Mother! Review
Red Sparrow Trailer Starring Jennifer Lawrence & Joel Edgerton
mother! UK Premiere in London
Sonic Is Getting Redesigned
Recently Paramount released a trailer for its upcoming Sonic film based on the popular video game character. The film's release is some months away, but fans went mad online, on Twitter and YouTube and basically everywhere about the character's design. There just wasn't something right about it.
He's a whole new speed of hero. Watch the new trailer for Sonic The Hedgehog, in theatres this November. #SonicMovie pic.twitter.com/mogO8hfRaX
— Sonic The Hedgehog (@SonicMovie) April 30, 2019
It seems now though that the makers of the film have listened and the design is being changed. The director, Jeff Fowler, recently tweeted that everyone at Paramount and Sega listened and now things are changing.
Thank you for the support. And the criticism. The message is loud and clear… you aren't happy with the design & you want changes. It's going to happen. Everyone at Paramount & Sega are fully committed to making this character the BEST he can be… #sonicmovie #gottafixfast 🔧✌
— Jeff Fowler (@fowltown) May 2, 2019
Australian Release Dates
IT Chapter Two Australian Release Date + Filming Begins
The IT Chapter Two Australian release date is September 5, 2019.
The IT Chapter Two Australian release date is September 5, 2019. Filming begins this week for IT Chapter Two. The film from New Line Cinema takes place 27 years after the first one ended as the evil returns to Derry every 27 years.
The first film grossed more than 700 million dollars globally and was a massive success for the horror film genre. The second film does however feature a different cast as the characters we saw in the first are now all grown up. IT Chapter Two stars James McAvoy (Bill), Jessica Chastain (Beverly), Bill Hader (Richie), Isiah Mustafa (Mike), Jay Ryan (Ben). James Ransone (Eddie) and Andy Bean (Stanley).
Andy Muschietti will direct the film based on a screenplay by Gary Dauberman ("IT," "Annabelle: Creation").
Jessica Chastain shared an image related to the film on her Instagram today
LOSERS Shoot Day 1 ✔
A post shared by Jessica Chastain (@jessicachastain) on Jul 2, 2018 at 10:03am PDT
Clint Eastwood's "The Mule" Begins Production
Cameras started filming today on esteemed filmmaker Clint Eastwood's next feature film, a drama entitled "The Mule," from Warner Bros. Pictures and Imperative Entertainment. The film will be shooting primarily in Georgia and New Mexico. The director also stars, alongside Bradley Cooper, Laurence Fishburne, Michael Peña, Dianne Wiest, Alison Eastwood, Taissa Farmiga and Ignacio Serricchio.
Roadshow films says that "Eastwood stars as Earl Stone, a man in his 80's who is broke, alone, and facing foreclosure of his business when he is offered a job that simply requires him to drive. Easy enough, but, unbeknownst to Earl, he's just signed on as a drug courier for a Mexican cartel. He does well—so well, in fact, that his cargo increases exponentially, and Earl is assigned a handler. But he isn't the only one keeping tabs on Earl; the mysterious new drug mule has also hit the radar of hard-charging DEA agent Colin Bates. And even as his money problems become a thing of the past, Earl's past mistakes start to weigh heavily on him, and it's uncertain if he'll have time to right those wrongs before law enforcement, or the cartel's enforcers, catch up to him."


Warehouse Supervisor Russell Tollison paid forward $500 to Laurens resident Debbie Green and her daughter Jordan, who have struggled through Debbie's diabetes and heart surgery.
Laurens Electric Cooperative's May recipient of the employee Pay it Forward funds is Warehouse Supervisor Russell Tollison.
Russell paid forward $500 to the Debbie Green and her daughter Jordan.
"Debbie has had heart surgery and is a diabetic and now resides at an assisted living facility because she is no longer able to be alone," said Russell.
Green's youngest daughter Jordan worked at the YMCA while also caring for her mother and attending college.


Ali, Farhana. 2005. "Muslim Female Fighters: An Emerging Trend." Terrorism Monitor 3 (21): online.
Muslim women are increasingly joining the global jihad, some motivated by religious conviction to change the plight of Muslims under occupation, and recruited by al-Qaeda and local terrorist groups strained by increased arrests and deaths of male operatives. Attacks by female fighters, also known as the mujahidaat, are arguably more deadly than those conducted by male jihadists, attributed in part to the perception that women are unlikely to commit such acts of horror, and when they do, the shock or "CNN factor" of their attacks draws far greater media attention than male bombers. Increasing awareness with instant media attention can motivate other women to commit similar attacks.


Searches are continuing in Moray today as part of efforts to trace missing Aberdeen man Wayne Macmillan.
The 45-year-old was reported missing last week after friends raised concerns that they had not heard from him.
Police now know he has travelled between Inverness and Aberdeen during the past week before arriving by Stagecoach bus no. 10 service outside Brodie Countryfare at around 1pm on Saturday.
There has been no sightings of Wayne since, nor has he been in touch with anyone. A significant search operation has been launched in the area led by specialist officers assisted by police dogs.
Wayne is described as being around 6ft and has a tattoo of a face on the rear of his head. He has a stud piercing under his bottom lip and both his ear lobes are stretched.
When last seen he was wearing a black T-shirt and black trousers or dark blue jeans.
Detective Inspector Allen Shaw said: "Wayne has some distinctive features which we would hope that members of the public who have seen him would remember.
"I would urge anyone who has seen a man matching his description or if you know where he might be to please get in touch as soon as possible by contacting police on 101.
"We would also appeal to Wayne directly to get in touch if he sees this appeal – we want to ensure you are safe and well.
"I would also ask anyone who lives in the vicinity of Brodie Countryfare to check any outbuildings, garages or sheds you have incase Wayne has taken shelter.


Maybe you have questions about baptism, or maybe you're ready to step into the waters to profess your own faith in Jesus Christ! Whatever the case, we hope this page gives you some insight into this powerful experience. Be sure to contact us using the form at the bottom of the page if we can help you in your journey with Christ!
Baptism is the immersion in water of a believer in the name of the Father, and the Son, and the Holy Spirit to illustrate the believer's faith in the crucified, buried, and risen Savior. When we get baptized, we are publicly identifying ourselves as followers of Jesus Christ, and we are confessing that Jesus is our only Lord and Savior.
Jesus commanded His followers to make disciples by baptizing people and teaching them to observe everything that He commanded (Matthew 28:18-20). The first step of obedience in following Christ for someone who has repented of sin and received Jesus as Lord and Savior is therefore to be baptized. Baptism does not save us, but if we have given our lives to Jesus Christ, our first step in following Jesus is to be baptized.
Before being immersed in the water, the baptismal candidate is given the opportunity to affirm his/her sinfulness and need for a Savior by answering the question, "Do you believe that God created you and loves you deeply, but that you have broken His commandments, and as a result, were separated from Him?"
The baptismal candidate is then given the opportunity to publicly profess his/her belief in Jesus Christ by answering the question, "Do you believe that Jesus is the Only-Begotten Son of God who came to rescue you by living a sinless life and then dying on the cross in your place to pay the price for your sin?" and "Do you believe that Jesus rose from the grave the third day and lives today?"
The Apostle Paul wrote, "I have been crucified with Christ. It is no longer I who live, but Christ who lives in me. And the life I now live in the flesh I live by faith in the Son of God, who loved me and gave himself for me" (Galatians 2:20). All who have received Christ have been crucified with Christ. God the Father has judged us guilty of sin, and our sentence has been carried out on Jesus at the cross. The Bible teaches that our "old self" has been crucified and buried with Christ, and being immersed in the water symbolizes this death and burial of the old self. The water represents the grave into which our old self has been buried. "For you died," the Bible says, "and your life is now hidden with Christ in God" (Colossians 3:3).
Not only have we been buried in Christ, but we have also been raised with Him. Paul wrote, "We were therefore buried with Him by baptism into death, in order that, just as Christ was raised from the dead by the glory of the Father, we too might walk in newness of life" (Romans 6:4). Because Jesus has been raised from the dead, we who have received Him have also been raised to eternal life in Christ. Jesus lives in us, and we walk with Him eternally. Jesus said, "I am the resurrection and the life. Whoever believes in me, though he die, yet shall he live, and everyone who lives and believes in me shall never die" (John 11:25-26). We who live and believe in Jesus have already died with Him, and we have been raised to eternal life. Baptism illustrates this truth by illustrating our being raised from the watery tomb into which we were lowered.
Baptism is a profound blessing that initiates the believer into the disciple-making ministry to which they have been commissioned by Christ. Jesus commanded His followers to make disciples by baptizing them and teaching them to observe all that he has commanded (Matthew 28:19-20). We are to be His disciples—who have been baptized and who learn His commands—and we are to make disciples of others. Everyone who follows Christ has been given this commission, and its fulfillment begins as we leave the baptismal waters. We have taken the first step of obedience in following Christ by being baptized, and we leave the water to continue obeying Christ's commands. Soon, if we are faithful, we will lead other new believers to Jesus and into the water so that they, too, might follow Christ in biblical baptism. At First Baptist Church, we symbolize this calling to carry the light of Christ into the world by giving you a candle to carry out of the water.


Tipard TS Converter serial is the latest version of TS Converter which can convert your files to others formate. We provide you better Tipard TS converter keygen with serial key for you is worth mentioning that application supports and processes not only TS files. Tipard TS Converter also converts following formats such as MP4, AVI, WMV, MKV, MPEG, etc. Changing the resolution and aspect ratio of the screen is possible.
Tipard MPEG TS Converter is given as a free download on our software library. The actual developer of the application is Tipard Studio. This powerful TS Converter for Mac provides the function of adjusting both video settings and audio settings. It could not miss the unique profiles containing a ready Setup output files, as well as additional configuration options-which hand improves the individual parameters encoding bit-rate, resolution, speed; and FPS is the proportion of the screen.
Tipard TS Converter crack is the most common filename for this program's installer. Our antivirus dissection shows that this download is safe. This computer tool works fine with 32-bit versions of Windows XP/7/8/10. Tipard TS Converter enables you to convert TS video to HD MKV, HD AVI, HD H.264, HD MOV, HD WMV, and another 1080p HD video. The program is involved in Multimedia Tools. It can also input M2TS, MTS, and other videos, and convert them into TS file or other general video formats. You can also download Tipard TS Converter Key.
Tipard TS Converter for Mac can support you trim video file and combine several pieces into a single one.
You can add pictures or images to contrast.
This powerful TS Converter for Mac provides the function of adjusting both video settings and audio settings.


text:
import { EventEmitter } from '@angular/core';
export declare class PermissionService {
    private _permissionStore;
    private _permissionStoreChange;
    constructor();
    define(permissions: Array<string>): void;
    add(permission: string): void;
    remove(permission: string): void;
    hasDefined(permission: string): boolean;
    hasOneDefined(permissions: Array<string>): boolean;
    clearStore(): void;
    readonly store: Array<string>;
    readonly permissionStoreChangeEmitter: EventEmitter<any>;
}