Beispiel #1
0
void cleanup_file()
{
    HDremove(FILE1.c_str());
    HDremove(FILE2.c_str());
    HDremove(FILE3.c_str());
    HDremove(FILE4.c_str());
}   // cleanup_file
Beispiel #2
0
//--------------------------------------------------------------------------
// Function:	Attribute::write
///\brief	This is an overloaded member function, provided for convenience.
///		It writes a \a H5std_string to this attribute.
///\param	mem_type  - IN: Attribute datatype (in memory)
///\param	strg      - IN: Data to be written
///\exception	H5::AttributeIException
// Programmer	Binh-Minh Ribler - Apr, 2003
//--------------------------------------------------------------------------
void Attribute::write(const DataType& mem_type, const H5std_string& strg) const
{
    // Check if this attribute has variable-len string or fixed-len string and
    // proceed appropriately.
    htri_t is_variable_len = H5Tis_variable_str(mem_type.getId());
    if (is_variable_len < 0)
    {
	throw AttributeIException("Attribute::write", "H5Tis_variable_str failed");
    }
    // Convert string to C-string
    const char* strg_C;
    strg_C = strg.c_str();  // strg_C refers to the contents of strg as a C-str
    herr_t ret_value = 0;

    // Pass string in differently depends on variable or fixed length
    if (!is_variable_len)
    {
	ret_value = H5Awrite(id, mem_type.getId(), strg_C);
    }
    else
    {
	// passing third argument by address
	ret_value = H5Awrite(id, mem_type.getId(), &strg_C);
    }
    if (ret_value < 0)
    {
	throw AttributeIException("Attribute::write", "H5Awrite failed");
    }
}
Beispiel #3
0
//--------------------------------------------------------------------------
// Function:	Attribute::getName
///\brief	Gets the name of this attribute, returning its length.
///\param	attr_name - OUT: Buffer for the name string as \a H5std_string
///\param	len  -  IN: Desired length of the name, default to 0
///\return	Actual length of the attribute name
///\exception	H5::AttributeIException
///\par Description
///		This function retrieves the attribute's name as a string.  The
///		buf_size can specify a specific length or default to 0, in
///		which case the entire name will be retrieved.
// Programmer	Binh-Minh Ribler - Nov, 2001
// Modification
//	Mar 2014 - BMR
//		Added to replace getName(size_t, H5std_string&) so that it'll
//		allow the argument "len" to be skipped.
//--------------------------------------------------------------------------
ssize_t Attribute::getName(H5std_string& attr_name, size_t len) const
{
    ssize_t name_size = 0;

    // If no length is provided, get the entire attribute name
    if (len == 0)
    {
        attr_name = getName();
	name_size = attr_name.length();
    }
    // If length is provided, get that number of characters in name
    else
    {
        char* name_C = new char[len+1];  // temporary C-string
        HDmemset(name_C, 0, len+1); // clear buffer

        // Use overloaded function
        name_size = getName(name_C, len+1);

        // Convert the C attribute name to return
        attr_name = name_C;

        // Clean up resource
        delete []name_C;
    }
    // Otherwise, keep attr_name intact

    // Return name size
    return(name_size);
}
Beispiel #4
0
//--------------------------------------------------------------------------
// Function:	H5File overloaded constructor
///\brief	This is another overloaded constructor.  It differs from the
///		above constructor only in the type of the \a name argument.
///\param	name - IN: Name of the file - \c H5std_string
///\param	flags - IN: File access flags
///\param	create_plist - IN: File creation property list, used when
///		modifying default file meta-data.  Default to
///		FileCreatPropList::DEFAULT
///\param	access_plist - IN: File access property list.  Default to
///		FileAccPropList::DEFAULT
// Notes	With a PGI compiler (~2012-2013), the exception thrown by p_get_file
//		could not be caught in the applications.  Added try block here
//		to catch then re-throw it. -BMR 2013/03/21
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
H5File::H5File( const H5std_string& name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist ) : H5Location(), id(0)
{
    try {
	p_get_file(name.c_str(), flags, create_plist, access_plist);
    } catch (FileIException open_file) {
	throw open_file;
    }
}
Beispiel #5
0
//--------------------------------------------------------------------------
// Function:	H5Location::reference
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
///\param	ref - IN: Reference pointer
///\param	name - IN: Name of the object to be referenced
///\param	dataspace - IN: Dataspace with selection
///\param	ref_type - IN: Type of reference to query, valid values are:
///		\li \c H5R_OBJECT         - Reference is an object reference.
///		\li \c H5R_DATASET_REGION - Reference is a dataset region
///			reference. (default)
///\exception	H5::ReferenceException
///\note	This method is more suitable for a dataset region reference.
// Programmer	Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void H5Location::reference(void* ref, const H5std_string& name, const DataSpace& dataspace, H5R_type_t ref_type) const
{
   try {
      p_reference(ref, name.c_str(), dataspace.getId(), ref_type);
   }
   catch (ReferenceException E) {
      throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
   }
}
Beispiel #6
0
/****************************************************************
**
**  test_attr_compound_write(): Tests compound datatype attributes
**
****************************************************************/
static void test_attr_compound_write()
{

	// Output message about test being performed
    SUBTEST("Multiple Attribute Functions");

    try {
	// Create file
	H5File fid1(FILENAME.c_str(), H5F_ACC_TRUNC);

	// Create dataspace for dataset
	hsize_t		dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
	DataSpace sid1(SPACE1_RANK, dims1);

	// Create a dataset
	DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR,sid1);

	// Create the attribute datatype.
	CompType comp_type(sizeof(struct attr4_struct));

	attr4_field1_off = HOFFSET(struct attr4_struct, i);
	comp_type.insertMember(ATTR4_FIELDNAME1, attr4_field1_off, PredType::NATIVE_INT);

	attr4_field2_off = HOFFSET(struct attr4_struct, d);
	comp_type.insertMember(ATTR4_FIELDNAME2, attr4_field2_off, PredType::NATIVE_DOUBLE);

	attr4_field3_off = HOFFSET(struct attr4_struct, c);
	comp_type.insertMember(ATTR4_FIELDNAME3, attr4_field3_off, PredType::NATIVE_SCHAR);

	// Create dataspace for 1st attribute
	hsize_t		dims2[] = {ATTR4_DIM1,ATTR4_DIM2};
	DataSpace sid2(ATTR4_RANK, dims2);

	// Create complex attribute for the dataset
	Attribute attr = dataset.createAttribute(ATTR4_NAME, comp_type, sid2);

	// Try to create the same attribute again (should fail)
	try {
	    Attribute invalid_attr = dataset.createAttribute (ATTR4_NAME, comp_type, sid2);
	}
        catch (AttributeIException E) // catching invalid creating attribute
        {} // do nothing, exception expected

	// Write complex attribute data
	attr.write(comp_type, attr_data4);

	PASSED();
    } // end try block

    catch (Exception E) {
	issue_fail_msg("test_attr_compound_write()", __LINE__, __FILE__, E.getCDetailMsg());
    }
}   // test_attr_compound_write()
Beispiel #7
0
/*-------------------------------------------------------------------------
 * Function:	test_get_objtype
 *
 * Purpose:	Tests getting object type
 *
 * Return:	Success:	0
 *		Failure:	-1
 *
 * Programmer:	Binh-Minh Ribler
 *		Friday, March 4, 2014
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static void test_get_objtype()
{
    SUBTEST("H5File::childObjType and H5Group::childObjType");

    try {
	// Open file
	H5File file(FILE_OBJECTS, H5F_ACC_RDWR);

	// Open the top group
	Group grp1 = file.openGroup(GROUP1);

	// Create a datatype and save it
	DataType dtype(PredType::STD_I32LE);
	dtype.commit(grp1, "STD_I32LE");

	// Get and verify object type with
	// H5O_type_t childObjType(const H5std_string& objname)
	H5O_type_t objtype = file.childObjType(DSET_IN_FILE);
	verify_val(objtype, H5O_TYPE_DATASET, "DataSet::childObjType", __LINE__, __FILE__);

	// Get and verify object type with
	// H5O_type_t childObjType(const char* objname)
	objtype = grp1.childObjType(GROUP1_1.c_str());
	verify_val(objtype, H5O_TYPE_GROUP, "DataSet::childObjType", __LINE__, __FILE__);

	// Get and verify object type with
	// H5O_type_t childObjType(hsize_t index, H5_index_t index_type,
	// H5_iter_order_t order, const char* objname=".")
	objtype = grp1.childObjType((hsize_t)1, H5_INDEX_NAME, H5_ITER_INC);
	verify_val(objtype, H5O_TYPE_NAMED_DATATYPE, "DataSet::childObjType", __LINE__, __FILE__);

	// Get and verify object type with
	// H5O_type_t childObjType(hsize_t index,
	// H5_index_t index_type=H5_INDEX_NAME,
	// H5_iter_order_t order=H5_ITER_INC, const char* objname=".")
	objtype = grp1.childObjType((hsize_t)2);
	verify_val(objtype, H5O_TYPE_GROUP, "DataSet::childObjType", __LINE__, __FILE__);

	// Everything will be closed as they go out of scope

	PASSED();
    }	// try block

    // catch all other exceptions
    catch (Exception& E)
    {
	issue_fail_msg("test_get_objtype", __LINE__, __FILE__);
    }
}   // test_get_objtype
Beispiel #8
0
//--------------------------------------------------------------------------
// Function:	CompType::insertMember
///\brief	Inserts a new member to this compound datatype.
///\param	name - IN: Name of the new member
///\param	offset - IN: Offset in memory structure of the field to insert
///\param	new_member - IN: New member to be inserted
///\exception	H5::DataTypeIException
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CompType::insertMember( const H5std_string& name, size_t offset, const DataType& new_member ) const
{
   // Convert string to C-string
   const char* name_C;
   name_C = name.c_str();  // name_C refers to the contents of name as a C-str

   hid_t new_member_id = new_member.getId();  // get new_member id for C API

   // Call C routine H5Tinsert to add the new member
   herr_t ret_value = H5Tinsert( id, name_C, offset, new_member_id );
   if( ret_value < 0 )
   {
      throw DataTypeIException("CompType::insertMember", "H5Tinsert failed");
   }
}
Beispiel #9
0
/*-------------------------------------------------------------------------
 * Function:	test_read_vl_string_attribute
 *
 * Purpose:	Test reading VL strings from attributes.
 *
 * Return:	None
 *
 * Programmer:	Binh-Minh Ribler (use C version)
 *		January, 2007
 *
 *-------------------------------------------------------------------------
 */
static void test_read_vl_string_attribute()
{

    // Output message about test being performed
    SUBTEST("reading VL String as attributes");

    try {
	// Open file
	H5File file1(FILENAME, H5F_ACC_RDONLY);

	// Create a datatype to refer to.
	StrType vlst(0, H5T_VARIABLE);

	// Open the root group and its attribute named ATTRSTR_NAME.
	Group root = file1.openGroup("/");
	Attribute att = root.openAttribute(ATTRSTR_NAME);

	// Test reading "normal" sized string attribute
	char *string_att_check;
	att.read(vlst, &string_att_check);
	if(HDstrcmp(string_att_check,ATTRSTR_DATA.c_str())!=0)
	    TestErrPrintf("VL string attributes don't match!, string_att=%s, string_att_check=%s\n",ATTRSTR_DATA.c_str(),string_att_check);
	HDfree(string_att_check);
	att.close();

	// Test reading "large" sized string attribute
	att = root.openAttribute("test_scalar_large");
	att.read(vlst, &string_att_check);
	if(HDstrcmp(string_att_check,string_att_write)!=0)
	    TestErrPrintf("VL string attributes don't match!, string_att_write=%s, string_att_check=%s\n",string_att_write,string_att_check);
	HDfree(string_att_check);
	HDfree(string_att_write);   // Free string allocated in test_write_vl_string_attribute

	// Close objects and file.
	att.close();
	vlst.close();
	root.close();
	file1.close();

	PASSED();
    } // end try

    // Catch all exceptions.
    catch (Exception E) {
	issue_fail_msg("test_read_vl_string_attribute()", __LINE__, __FILE__, E.getCDetailMsg());
    }
} // test_read_vl_string_attribute
Beispiel #10
0
//--------------------------------------------------------------------------
// Function:	DataSet::write
///\brief	This is an overloaded member function, provided for convenience.
///		It takes a reference to a \c H5std_string for the buffer.
// Programmer	Binh-Minh Ribler - 2000
// Modification
//	Jul 2009
//		Modified to pass the buffer into H5Dwrite properly depending
//		whether the dataset has variable- or fixed-length string.
//--------------------------------------------------------------------------
void DataSet::write( const H5std_string& strg, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
{
    // Check if this attribute has variable-len string or fixed-len string and
    // proceed appropriately.
    htri_t is_variable_len = H5Tis_variable_str(mem_type.getId());
    if (is_variable_len < 0)
    {
        throw DataSetIException("DataSet::write", "H5Tis_variable_str failed");
    }

   // Obtain identifiers for C API
   hid_t mem_type_id = mem_type.getId();
   hid_t mem_space_id = mem_space.getId();
   hid_t file_space_id = file_space.getId();
   hid_t xfer_plist_id = xfer_plist.getId();

    // Convert string to C-string
    const char* strg_C;
    strg_C = strg.c_str();  // strg_C refers to the contents of strg as a C-str
    herr_t ret_value = 0;

    // Pass string in differently depends on variable or fixed length
    if (!is_variable_len)
    {
        ret_value = H5Dwrite( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, strg_C );
    }
    else
    {
        // passing string argument by address
        ret_value = H5Dwrite( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, &strg_C );
    }
    if (ret_value < 0)
    {
        throw DataSetIException("DataSet::write", "H5Dwrite failed");
    }
}
Beispiel #11
0
//--------------------------------------------------------------------------
// Function:	CommonFG::openVarLenType
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - Jul, 2005
//--------------------------------------------------------------------------
VarLenType CommonFG::openVarLenType( const H5std_string& name ) const
{
   return( openVarLenType( name.c_str()) );
}
Beispiel #12
0
//--------------------------------------------------------------------------
// Function:	CommonFG::unmount
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CommonFG::unmount( const H5std_string& name ) const
{
   unmount( name.c_str() );
}
Beispiel #13
0
static void test_file_attribute()
{
    int rdata[ATTR1_DIM1];
    int i;

    // Output message about test being performed
    SUBTEST("File Attribute");

    H5std_string file_name;
    try {
        // Create a file using default properties.
        H5File file5(FILE5, H5F_ACC_TRUNC);

        // Create the data space
        hsize_t dims[RANK1] = {ATTR1_DIM1};
        DataSpace space(RANK1, dims);

        // Create two attributes for the file
        Attribute fattr1(file5.createAttribute(FATTR1_NAME, PredType::NATIVE_FLOAT, space));
        Attribute fattr2(file5.createAttribute(FATTR2_NAME, PredType::NATIVE_INT, space));

        fattr2.write(PredType::NATIVE_INT, fattr_data);

        try {
            // Try to create the same attribute again (should fail)
            Attribute fattr_dup(file5.createAttribute(FATTR2_NAME, PredType::NATIVE_INT, space));
            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File createAttribute", "Attempted to create an existing attribute.");
        }
        catch (AttributeIException& E) // catch creating existing attribute
        {} // do nothing, FAIL expected

        // Create a new dataset
        DataSet dataset(file5.createDataSet (DSETNAME, PredType::NATIVE_INT, space));

        // Create an attribute for the dataset
        Attribute dattr(dataset.createAttribute(DATTRNAME, PredType::NATIVE_INT, space));

        // Write data to the second file attribute
        dattr.write(PredType::NATIVE_INT, dattr_data);

        // Test flushing out the data from the attribute object
        dattr.flush(H5F_SCOPE_GLOBAL);

        // Get and verify the number of all objects in the file
        // Current: 1 file, 2 file attr, 1 ds, and 1 ds attr.
        ssize_t num_objs = file5.getObjCount(H5F_OBJ_ALL);
        verify_val(num_objs, 5, "H5File::getObjCount", __LINE__, __FILE__);

        num_objs = file5.getObjCount(H5F_OBJ_GROUP);
        verify_val(num_objs, 0, "H5File::getObjCount(H5F_OBJ_GROUP)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_DATASET);
        verify_val(num_objs, 1, "H5File::getObjCount(H5F_OBJ_DATASET)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_ATTR);
        verify_val(num_objs, 3, "H5File::getObjCount(H5F_OBJ_ATTR)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_DATATYPE);
        verify_val(num_objs, 0, "H5File::getObjCount(H5F_OBJ_DATATYPE)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_FILE);
        verify_val(num_objs, 1, "H5File::getObjCount(H5F_OBJ_FILE)", __LINE__, __FILE__);
        
        // Get the file name using the attributes
        H5std_string fname = fattr1.getFileName();
        verify_val(fname, FILE5, "H5File::getFileName()", __LINE__, __FILE__);

        fname.clear();
        fname = dattr.getFileName();
        verify_val(fname, FILE5, "H5File::getFileName()", __LINE__, __FILE__);

        // Get the class of a file attribute's datatype
        H5T_class_t atclass = fattr1.getTypeClass();
        verify_val(atclass, H5T_FLOAT, "Attribute::getTypeClass()", __LINE__, __FILE__);

        // Get and verify the number of attributes attached to a file
        int n_attrs = file5.getNumAttrs();
        verify_val(n_attrs, 2, "H5File::getNumAttrs()", __LINE__, __FILE__);

        // Get and verify the number of attributes attached to a dataset
        n_attrs = 0;
        n_attrs = dataset.getNumAttrs();
        verify_val(n_attrs, 1, "DataSet::getNumAttrs()", __LINE__, __FILE__);

        // Read back attribute's data
        HDmemset(rdata, 0, sizeof(rdata));
        dattr.read(PredType::NATIVE_INT, rdata);
        /* Check results */
        for (i = 0; i < ATTR1_DIM1; i++) {
            if (rdata[i] != dattr_data[i]) {
                H5_FAILED();
                cerr << endl;
                cerr << "element [" << i << "] is " << rdata[i] <<
                        "but should have been " << dattr_data[i] << endl;
                }
            }
        PASSED();
    }   // end of try block

    catch (Exception& E)
    {
        issue_fail_msg("test_file_attribute()", __LINE__, __FILE__, E.getCDetailMsg());
    }
}   // test_file_attribute()
Beispiel #14
0
//--------------------------------------------------------------------------
// Function:    H5Object::reference
///\brief       This is an overloaded function, provided for your convenience.
///             It differs from the above function in that it takes an
///             \c H5std_string for the object's name.
///\param       ref - IN: Reference pointer
///\param       name - IN: Name of the object to be referenced - \c H5std_string
// Programmer   Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void H5Object::reference(void* ref, const H5std_string& name) const
{
   reference(ref, name.c_str());
}
Beispiel #15
0
//--------------------------------------------------------------------------
// Function:	H5Object::removeAttr
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes
///		a reference to an \c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void H5Object::removeAttr( const H5std_string& name ) const
{
   removeAttr( name.c_str() );
}
Beispiel #16
0
//--------------------------------------------------------------------------
// Function:	H5Object::createAttribute
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes
///		a reference to an \c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Attribute H5Object::createAttribute( const H5std_string& name, const DataType& data_type, const DataSpace& data_space, const PropList& create_plist ) const
{
   return( createAttribute( name.c_str(), data_type, data_space, create_plist ));
}
Beispiel #17
0
/*-------------------------------------------------------------------------
 *
 * Function:	test_h5s_basic
 *
 * Purpose:	Test basic H5S (dataspace) code
 *
 * Return:	none
 *
 * Programmer:	Binh-Minh Ribler (using C version)
 *              Mar 2001
 *
 * Modifications:
 *      January, 2005: C tests' macro VERIFY casts values to 'long' for all
 *		       cases.  Since there are no operator<< for 'long long'
 *		       or int64 in VS C++ ostream, I casted the hssize_t values
 *		       passed to verify_val to 'long' as well.  If problems
 *		       arises later, this will have to be specificly handled
 *		       with a special routine.
 *-------------------------------------------------------------------------
 */
static void test_h5s_basic(void)
{
    hsize_t		dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
    hsize_t		dims2[] = {SPACE2_DIM1, SPACE2_DIM2, SPACE2_DIM3,
				   SPACE2_DIM4};
    hsize_t		dims3[H5S_MAX_RANK+1];
    hsize_t		tmax[4];

    // Output message about test being performed
    SUBTEST("Testing Dataspace Manipulation");

    try {
	// Create simple dataspace sid1
	DataSpace sid1 (SPACE1_RANK, dims1 );

	// Get simple extent npoints of the dataspace sid1 and verify it
	hssize_t	n;	 	// Number of dataspace elements
	n = sid1.getSimpleExtentNpoints();
	verify_val((long)n, (long)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3),
	   "DataSpace::getSimpleExtentNpoints", __LINE__, __FILE__);

	// Get the logical rank of dataspace sid1 and verify it
	int	rank;		// Logical rank of dataspace
	rank = sid1.getSimpleExtentNdims();
	verify_val(rank, SPACE1_RANK, "DataSpace::getSimpleExtentNdims", __LINE__, __FILE__);

	// Retrieves dimension size of dataspace sid1 and verify it
	int ndims;		// Number of dimensions
	hsize_t	tdims[4];	// Dimension array to test with
	ndims = sid1.getSimpleExtentDims( tdims );
	verify_val(ndims, SPACE1_RANK, "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
	verify_val(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(unsigned)), 0,
	   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);

	// Create simple dataspace sid2
	hsize_t	max2[] = {SPACE2_MAX1, SPACE2_MAX2, SPACE2_MAX3, SPACE2_MAX4};
	DataSpace sid2 (SPACE2_RANK, dims2, max2);

	// Get simple extent npoints of dataspace sid2 and verify it
	n = sid2.getSimpleExtentNpoints();
	verify_val((long)n, (long)(SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4),
	   "DataSpace::getSimpleExtentNpoints", __LINE__, __FILE__);

	// Get the logical rank of dataspace sid2 and verify it
	rank = sid2.getSimpleExtentNdims();
	verify_val(rank, SPACE2_RANK, "DataSpace::getSimpleExtentNdims", __LINE__, __FILE__);

	// Retrieves dimension size and max size of dataspace sid2 and
	// verify them
	ndims = sid2.getSimpleExtentDims( tdims, tmax );
	verify_val(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(unsigned)), 0,
	   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
	verify_val(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(unsigned)), 0,
	   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);

	// Check to be sure we can't create a simple data space that has too
	// many dimensions.
	try {
	    DataSpace manydims_ds(H5S_MAX_RANK+1, dims3, NULL);

	    // Should FAIL but didn't, so throw an invalid action exception
	    throw InvalidActionException("DataSpace constructor", "Library allowed overwrite of existing dataset");
	}
	catch( DataSpaceIException E ) // Simple data space with too many dims
	{} // do nothing, exception expected

       /*
	* Try reading a file that has been prepared that has a dataset with a
	* higher dimensionality than what the library can handle.
	*
	* If this test fails and the H5S_MAX_RANK variable has changed, follow
	* the instructions in space_overflow.c for regenating the th5s.h5 file.
	*/
	char testfile[512]="";
	char *srcdir = getenv("srcdir");
	if (srcdir && ((strlen(srcdir) + strlen(TESTFILE.c_str()) + 1) < sizeof(testfile))){
	    strcpy(testfile, srcdir);
	    strcat(testfile, "/");
	}
	strcat(testfile, TESTFILE.c_str());

	// Create file
	H5File fid1(testfile, H5F_ACC_RDONLY);

	// Try to open the dataset that has higher dimensionality than
	// what the library can handle and this operation should fail.
	try {
	    DataSet dset1 = fid1.openDataSet( "dset" );

	    // Should FAIL but didn't, so throw an invalid action exception
	    throw InvalidActionException("H5File::openDataSet", "Opening a dataset with higher dimensionality than what the library can handle");
	}
	catch( FileIException E ) // catching higher dimensionality dataset
	{} // do nothing, exception expected

	// Verify that incorrect dimensions don't work
	dims1[0] = 0;
	try {
	    DataSpace wrongdim_ds (SPACE1_RANK, dims1);

	    // Should FAIL but didn't, so throw an invalid action exception
	    throw InvalidActionException("DataSpace constructor", "Attempted to use incorrect dimensions");
	}
	catch( DataSpaceIException E ) // catching use of incorrect dimensions
	{} // do nothing, exception expected

	// Another incorrect dimension case
	DataSpace sid3 (H5S_SIMPLE);
	try {
	    sid3.setExtentSimple( SPACE1_RANK, dims1 );

	    // Should FAIL but didn't, so throw an invalid action exception
	    throw InvalidActionException("DataSpace::setExtentSimple", "Attempted to use incorrect dimensions");
	}
	catch (DataSpaceIException E) // catching use of incorrect dimensions
	{} // do nothing, exception expected

	PASSED();
    }	// end of try block

    catch (InvalidActionException E)
    {
        cerr << " FAILED" << endl;
        cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
    }
    // catch all other exceptions
    catch (Exception E)
    {
        issue_fail_msg("test_h5s_basic()", __LINE__, __FILE__, E.getCDetailMsg());
    }
}   // test_h5s_basic()
Beispiel #18
0
//--------------------------------------------------------------------------
// Function:	CommonFG::iterateElems
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
int CommonFG::iterateElems( const H5std_string& name, int *idx, H5G_iterate_t op , void* op_data )
{
   return( iterateElems( name.c_str(), idx, op, op_data ));
}
Beispiel #19
0
void cleanup_reference(void)
{
    HDremove(FILE1.c_str());
    HDremove(FILE2.c_str());
}
Beispiel #20
0
//--------------------------------------------------------------------------
// Function:	CommonFG::getObjinfo
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - Nov, 2005
//--------------------------------------------------------------------------
void CommonFG::getObjinfo( const H5std_string& name, H5G_stat_t& statbuf ) const
{
   getObjinfo( name.c_str(), statbuf );
}
Beispiel #21
0
void cleanup_h5s(void)
{
    HDremove(DATAFILE.c_str());
}   // cleanup_h5s
Beispiel #22
0
//--------------------------------------------------------------------------
// Function:	CommonFG::getLinkval
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
H5std_string CommonFG::getLinkval( const H5std_string& name, size_t size ) const
{
   return( getLinkval( name.c_str(), size ));
}
Beispiel #23
0
//--------------------------------------------------------------------------
// Function:	H5Object::openAttribute
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes
///		a reference to an \c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Attribute H5Object::openAttribute( const H5std_string& name ) const
{
   return( openAttribute( name.c_str()) );
}
Beispiel #24
0
//--------------------------------------------------------------------------
// Function:	CommonFG::setComment
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name and \a comment.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CommonFG::setComment( const H5std_string& name, const H5std_string& comment ) const
{
   setComment( name.c_str(), comment.c_str() );
}
Beispiel #25
0
//--------------------------------------------------------------------------
// Function:	H5Object::renameAttr
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes
///		a reference to an \c H5std_string for the names.
// Programmer	Binh-Minh Ribler - Mar, 2005
//--------------------------------------------------------------------------
void H5Object::renameAttr(const H5std_string& oldname, const H5std_string& newname) const
{
   renameAttr (oldname.c_str(), newname.c_str());
}
Beispiel #26
0
//--------------------------------------------------------------------------
// Function:	CommonFG::removeComment
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - May 2005
//--------------------------------------------------------------------------
void CommonFG::removeComment(const H5std_string& name) const
{
   removeComment (name.c_str());
}
Beispiel #27
0
void cleanup_filters()
{
    HDremove(FILE1.c_str());
}
Beispiel #28
0
//--------------------------------------------------------------------------
// Function:	CommonFG::getComment
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
H5std_string CommonFG::getComment( const H5std_string& name, size_t bufsize ) const
{
   return( getComment( name.c_str(), bufsize ));
}
Beispiel #29
0
/*-------------------------------------------------------------------------
 * Function:    test_file_create
 *
 * Purpose      Test file and template creations
 *
 * Return       None
 *
 * Programmer   Binh-Minh Ribler (use C version)
 *              January, 2001
 *
 * Modifications:
 *        January, 2005: C tests' macro VERIFY casts values to 'long' for all
 *                     cases.  Since there are no operator<< for 'long long'
 *                     or int64 in VS C++ ostream, I casted the hsize_t values
 *                     passed to verify_val to 'long' as well.  If problems
 *                     arises later, this will have to be specifically handled
 *                     with a special routine.
 *-------------------------------------------------------------------------
 */
static void test_file_create()
{
    // Output message about test being performed
    SUBTEST("File Creation I/O");

    // Test create with various sequences of H5F_ACC_EXCL and
    // H5F_ACC_TRUNC flags

    // Create with H5F_ACC_EXCL
    // First ensure the file does not exist
    remove(FILE1.c_str());

    // Setting this to NULL for cleaning up in failure situations
    H5File* file1 = NULL;
    try {
        // Create file FILE1
        file1 = new H5File (FILE1, H5F_ACC_EXCL);

        // Try to create the same file with H5F_ACC_TRUNC. This should fail
        // because file1 is the same file and is currently open.
        try {
            H5File file2 (FILE1, H5F_ACC_TRUNC);  // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "Attempted to create an existing file.");
        }
        catch (FileIException& E) // catch truncating existing file
        {} // do nothing, FAIL expected

        // Close file1
        delete file1;
        file1 = NULL;

        // Try again with H5F_ACC_EXCL. This should fail because the file
        // already exists from the previous steps.
        try {
            H5File file2(FILE1, H5F_ACC_EXCL);  // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "File already exists.");
        }
        catch (FileIException& E) // catching creating existing file
        {} // do nothing, FAIL expected

            // Test create with H5F_ACC_TRUNC. This will truncate the existing file.
        file1 = new H5File (FILE1, H5F_ACC_TRUNC);

        // Try to create first file again. This should fail because file1
        // is the same file and is currently open.
            try {
            H5File file2 (FILE1, H5F_ACC_TRUNC);   // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "H5F_ACC_TRUNC attempt on an opened file.");
        }
        catch (FileIException& E) // catching truncating opened file
        {} // do nothing, FAIL expected

             // Try with H5F_ACC_EXCL. This should fail too because the file already
             // exists.
            try {
            H5File file3 (FILE1, H5F_ACC_EXCL);  // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "H5F_ACC_EXCL attempt on an existing file.");
            }
        catch (FileIException& E) // catching H5F_ACC_EXCL on existing file
        {} // do nothing, FAIL expected

            // Get the file-creation template
        FileCreatPropList tmpl1 = file1->getCreatePlist();

        hsize_t ublock = tmpl1.getUserblock();
        verify_val((long)ublock, (long)F1_USERBLOCK_SIZE, "FileCreatPropList::getUserblock", __LINE__, __FILE__);

            size_t  parm1, parm2;                // file-creation parameters
        tmpl1.getSizes( parm1, parm2);
        verify_val(parm1, F1_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F1_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned  iparm1,iparm2;        // file-creation parameters
        tmpl1.getSymk( iparm1, iparm2);
        verify_val(iparm1, F1_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F1_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // tmpl1 is automatically closed; if error occurs, it'll be
        // caught in the catch block

        // Close first file
        delete file1;
    }
    catch (InvalidActionException& E)
    {
        cerr << " *FAILED*" << endl;
        cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
        if (file1 != NULL) // clean up
            delete file1;
    }
    // catch all other exceptions
    catch (Exception& E)
    {
        issue_fail_msg("test_file_create()", __LINE__, __FILE__, E.getCDetailMsg());
        if (file1 != NULL) // clean up
            delete file1;
    }

    // Setting this to NULL for cleaning up in failure situations
    FileCreatPropList* tmpl1 = NULL;
    try
    {
            // Create a new file with a non-standard file-creation template
        tmpl1 = new FileCreatPropList;

            // Set the new file-creation parameters
        tmpl1->setUserblock (F2_USERBLOCK_SIZE);
        tmpl1->setSizes( F2_OFFSET_SIZE, F2_LENGTH_SIZE );
        tmpl1->setSymk( F2_SYM_INTERN_K, F2_SYM_LEAF_K );

             // Try to create second file, with non-standard file-creation template
             // params.
        H5File file2( FILE2, H5F_ACC_TRUNC, *tmpl1 );

            // Release file-creation template
        delete tmpl1;
        tmpl1 = NULL;

        // Get the file-creation template
        tmpl1 = new FileCreatPropList (file2.getCreatePlist());

        // Get the file-creation parameters
        hsize_t ublock = tmpl1->getUserblock();
        verify_val((long)ublock, (long)F2_USERBLOCK_SIZE, "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        size_t parm1, parm2; // file-creation parameters
        tmpl1->getSizes( parm1, parm2);
        verify_val(parm1, F2_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F2_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned  iparm1,iparm2;        // file-creation parameters
        tmpl1->getSymk( iparm1, iparm2);
        verify_val(iparm1, F2_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F2_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // Clone the file-creation template
        FileCreatPropList tmpl2;
        tmpl2.copy (*tmpl1);

        // Release file-creation template
        delete tmpl1;
        tmpl1 = NULL;

        // Set the new file-creation parameter
        tmpl2.setUserblock( F3_USERBLOCK_SIZE );

        // Try to create second file, with non-standard file-creation template
        // params
        H5File file3( FILE3, H5F_ACC_TRUNC, tmpl2 );

        // Get the file-creation template
        tmpl1 = new FileCreatPropList (file3.getCreatePlist());

        // Get the file-creation parameters
        ublock = tmpl1->getUserblock();
        verify_val((long)ublock, (long)F3_USERBLOCK_SIZE, "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        tmpl1->getSizes( parm1, parm2);
        verify_val(parm1, F3_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F3_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

            tmpl1->getSymk( iparm1, iparm2);
        verify_val(iparm1, F3_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F3_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // Release file-creation template
        delete tmpl1;
        PASSED();
    }
    // catch all exceptions
    catch (Exception& E)
    {
        issue_fail_msg("test_file_create()", __LINE__, __FILE__, E.getCDetailMsg());
        if (tmpl1 != NULL)  // clean up
            delete tmpl1;
    }
}   // test_file_create()
Beispiel #30
0
//--------------------------------------------------------------------------
// Function:	CommonFG::mount
///\brief	This is an overloaded member function, provided for convenience.
///		It differs from the above function in that it takes an
///		\c H5std_string for \a name.
// Programmer	Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CommonFG::mount( const H5std_string& name, H5File& child, PropList& plist ) const
{
   mount( name.c_str(), child, plist );
}