[svn-r639] Two new examples h5_select.c and h5_attribute.c were added to the directory.

Makefile.in was modified to reflect those changes.

Tested on Sun Sparc ( baldric) and DEC Alpha (gondolin)

3 files changed, 482 insertions, 5 deletions

diff --git a/examples/Makefile.in b/examples/Makefile.in
index 0a3d851..2d476db 100644
--- a/examples/Makefile.in
+++ b/examples/Makefile.in
@@ -12,20 +12,21 @@ CPPFLAGS=-I. -I../src @CPPFLAGS@
 # These are the programs that `make all' will build, `make install'
 # will copy to the binaries directory, and `make uninstall' will
 # remove from that directory.
-PROGS=h5_chunk_read h5_compound h5_extend_write h5_group h5_read h5_write
+PROGS=h5_chunk_read h5_compound h5_extend_write h5_group h5_read h5_write \
+	h5_select h5_attribute
 
 # These are the programs that `make test' will run
 TESTS=
 
 # These are the files that `make clean' (and derivatives) will remove from
 # this directory.
-CLEAN=
+CLEAN=*.h5
 
 # List all source files here.  The list of object files will be
 # created by replacing the `.c' with a `.o'.  This list is necessary
 # for building automatic dependencies.
 PROG_SRC=h5_chunk_read.c h5_compound.c h5_extend_write.c h5_group.c \
-	 h5_read.c h5_write.c
+	 h5_read.c h5_write.c h5_select.c h5_attribute.c
 PROG_OBJ=$(PROG_SRC:.c=.o)
 
 # List the source files for each individual program.  Most programs
@@ -51,6 +52,13 @@ READ_OBJ=$(READ_SRC:.c=.o)
 WRITE_SRC=h5_write.c
 WRITE_OBJ=$(WRITE_SRC:.c=.o)
 
+SELECT_SRC=h5_select.c
+SELECT_OBJ=$(SELECT_SRC:.c=.o)
+
+
+ATTRIBUTE_SRC=h5_attribute.c
+ATTRIBUTE_OBJ=$(ATTRIBUTE_SRC:.c=.o)
+
 # How to build the programs...
 h5_chunk_read: $(CHUNK_READ_OBJ) ../src/libhdf5.a
 	$(CC) $(CFLAGS) -o $@ $(CHUNK_READ_OBJ) ../src/libhdf5.a $(LIBS)
@@ -64,10 +72,16 @@ h5_extend_write: $(EXTEND_WRITE_OBJ) ../src/libhdf5.a
 h5_group: $(GROUP_OBJ) ../src/libhdf5.a
 	$(CC) $(CFLAGS) -o $@ $(GROUP_OBJ) ../src/libhdf5.a $(LIBS)
 
+h5_write: $(WRITE_OBJ) ../src/libhdf5.a
+	$(CC) $(CFLAGS) -o $@ $(WRITE_OBJ) ../src/libhdf5.a $(LIBS)
+
 h5_read: $(READ_OBJ) ../src/libhdf5.a
 	$(CC) $(CFLAGS) -o $@ $(READ_OBJ) ../src/libhdf5.a $(LIBS)
 
-h5_write: $(WRITE_OBJ) ../src/libhdf5.a
-	$(CC) $(CFLAGS) -o $@ $(WRITE_OBJ) ../src/libhdf5.a $(LIBS)
+h5_select: $(SELECT_OBJ) ../src/libhdf5.a
+	$(CC) $(CFLAGS) -o $@ $(SELECT_OBJ) ../src/libhdf5.a $(LIBS)
+
+h5_attribute: $(ATTRIBUTE_OBJ) ../src/libhdf5.a
+	$(CC) $(CFLAGS) -o $@ $(ATTRIBUTE_OBJ) ../src/libhdf5.a $(LIBS)
 
 @CONCLUDE@
diff --git a/examples/h5_attribute.c b/examples/h5_attribute.c
new file mode 100644
index 0000000..661f72d
--- /dev/null
+++ b/examples/h5_attribute.c
@@ -0,0 +1,259 @@
+/* 
+ *  This program illustrates the usage of the H5A Interface functions.
+ *  It creates and writes a dataset, and then creates and writes array,
+ *  scalar, and string attributes of the dataset. 
+ *  Program reopens the file, attaches to the scalar attribute using
+ *  attribute name and reads and displays its value. Then index of the
+ *  third attribute is used to read and display attribute values.
+ *  The H5Aiterate function is used to iterate through the dataset attributes,
+ *  and display their names. The function is also reads and displays the values 
+ *  of the array attribute. 
+ */ 
+ 
+#include <hdf5.h>
+
+#define FILE "Attributes.h5"
+
+#define RANK  1   /* Rank and size of the dataset  */ 
+#define SIZE  7
+
+#define ARANK  2   /* Rank and dimension sizes of the first dataset attribute */
+#define ADIM1  2
+#define ADIM2  3 
+#define ANAME  "Float attribute"      /* Name of the array attribute */
+#define ANAMES "Character attribute" /* Name of the string attribute */
+
+herr_t attr_info(hid_t loc_id, const char *name, void *opdata); 
+                                     /* Operator function */
+
+int main (void)
+{
+
+   hid_t   file, dataset;       /* File and dataset identifiers */
+   
+   hid_t   fid;                 /* Dataspace identifier */
+   hid_t   attr1, attr2, attr3; /* Attribute identifiers */
+   hid_t   attr;
+   hid_t   aid1, aid2, aid3;    /* Attribute dataspace identifiers */ 
+   hid_t   atype;               /* Attribute type */
+
+   hsize_t fdim[] = {SIZE};
+   hsize_t adim[] = {ADIM1, ADIM2};  /* Dimensions of the first attribute  */
+   
+   float matrix[ADIM1][ADIM2]; /* Attribute data */ 
+
+   herr_t  ret;                /* Return value */
+   uint    i,j;                /* Counters */
+   int     idx;                /* Attribute index */
+   char    string_out[80];     /* Buffer to read string attribute back */
+   int     point_out;          /* Buffer to read scalar attribute back */
+
+/*
+ * Data initialization.
+ */
+int vector[] = {1, 2, 3, 4, 5, 6, 7};  /* Dataset data */
+int point = 1;                         /* Value of the scalar attribute */ 
+char string[] = "ABCD";                /* Value of the string attribute */
+
+   
+for (i=0; i < ADIM1; i++) {            /* Values of the array attribute */
+    for (j=0; j < ADIM2; j++)
+        matrix[i][j] = -1.;
+}
+
+/*
+ * Create a file.
+ */
+file = H5Fcreate(FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+/* 
+ * Create the dataspace for the dataset in the file.
+ */
+fid = H5Screate(H5S_SIMPLE);
+ret = H5Sset_extent_simple(fid, RANK, fdim, NULL);
+
+/*
+ * Create the dataset in the file.
+ */
+dataset = H5Dcreate(file, "Dataset", H5T_NATIVE_INT, fid, H5P_DEFAULT);
+
+/*
+ * Write data to the dataset.
+ */
+ret = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL , H5S_ALL, H5P_DEFAULT, vector);
+
+/*
+ * Create dataspace for the first attribute. 
+ */
+aid1 = H5Screate(H5S_SIMPLE);
+ret  = H5Sset_extent_simple(aid1, ARANK, adim, NULL);
+
+/*
+ * Create array attribute.
+ */
+attr1 = H5Acreate(dataset, ANAME, H5T_NATIVE_FLOAT, aid1, H5P_DEFAULT);
+
+/*
+ * Write array attribute.
+ */
+ret = H5Awrite(attr1, H5T_NATIVE_FLOAT, matrix);
+
+/*
+ * Create scalar attribute.
+ */
+aid2  = H5Screate(H5S_SCALAR);
+attr2 = H5Acreate(dataset, "Integer attribute", H5T_NATIVE_INT, aid2,
+                  H5P_DEFAULT);
+
+/*
+ * Write scalar attribute.
+ */
+ret = H5Awrite(attr2, H5T_NATIVE_INT, &point); 
+
+/*
+ * Create string attribute.
+ */
+aid3  = H5Screate(H5S_SCALAR);
+atype = H5Tcopy(H5T_C_S1);
+        H5Tset_size(atype, 4);
+attr3 = H5Acreate(dataset, ANAMES, atype, aid3, H5P_DEFAULT);
+
+/*
+ * Write string attribute.
+ */
+ret = H5Awrite(attr3, atype, string); 
+
+/*
+ * Close attribute and file datapsaces.
+ */
+ret = H5Sclose(aid1); 
+ret = H5Sclose(aid2); 
+ret = H5Sclose(aid3); 
+ret = H5Sclose(fid); 
+
+/*
+ * Close the attributes.
+ */ 
+ret = H5Aclose(attr1);
+ret = H5Aclose(attr2);
+ret = H5Aclose(attr3);
+ 
+/*
+ * Close the dataset.
+ */
+ret = H5Dclose(dataset);
+
+/*
+ * Close the file.
+ */
+ret = H5Fclose(file);
+
+/*
+ * Reopen the file.
+ */
+file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
+
+/*
+ * Open the dataset.
+ */
+dataset = H5Dopen(file,"Dataset");
+
+/*
+ * Attach to the scalar attribute using attribute name, then read and 
+ * display its value.
+ */
+attr = H5Aopen_name(dataset,"Integer attribute");
+ret  = H5Aread(attr, H5T_NATIVE_INT, &point_out);
+printf("The value of the attribute \"Integer attribute\" is %d \n", point_out); 
+ret =  H5Aclose(attr);
+
+/*
+ * Attach to the string attribute using its index, then read and display the value.
+ */
+attr = H5Aopen_idx(dataset, 2);
+atype = H5Tcopy(H5T_C_S1);
+        H5Tset_size(atype, 4);
+ret   = H5Aread(attr, atype, string_out);
+printf("The value of the attribute with the index 2 is %s \n", string_out);
+ret   = H5Aclose(attr);
+ret   = H5Tclose(atype);
+
+/*
+ * Get attribute info using iteration function. 
+ */
+idx = H5Aiterate(dataset, NULL, attr_info, NULL);
+
+/*
+ * Close the dataset and the file.
+ */
+H5Dclose(dataset);
+H5Fclose(file);
+return 0;  
+}
+
+/*
+ * Operator function.
+ */
+herr_t attr_info(hid_t loc_id, const char *name, void *opdata)
+{
+    hid_t attr, atype, aspace;  /* Attribute, datatype and dataspace identifiers */
+    int   rank;
+    hsize_t sdim[64]; 
+    herr_t ret;
+    int i;
+    size_t npoints;             /* Number of elements in the array attribute. */ 
+    float *float_array;         /* Pointer to the array attribute. */
+/*
+ * Open the attribute using its name.
+ */    
+    attr = H5Aopen_name(loc_id, name);
+
+/*
+ * Display attribute name.
+ */
+    printf("\n");
+    printf("Name : ");
+    puts(name);
+
+/* 
+ * Get attribute datatype, dataspace, rank, and dimensions.
+ */
+    atype = H5Aget_type(attr);
+    aspace = H5Aget_space(attr);
+    rank = H5Sextent_ndims(aspace);
+    ret = H5Sextent_dims(aspace, sdim, NULL);
+/*
+ *  Display rank and dimension sizes for the array attribute.
+ */
+
+    if(rank > 0) {
+    printf("Rank : %d \n", rank); 
+    printf("Dimension sizes : ");
+    for (i=0; i< rank; i++) printf("%d ", (int)sdim[i]);
+    printf("\n");
+    }
+
+/*
+ * Read array attribute and display its type and values.
+ */
+
+    if (H5T_FLOAT == H5Tget_class(atype)) {
+    printf("Type : FLOAT \n"); 
+    npoints = H5Sextent_npoints(aspace);
+    float_array = (float *)malloc(sizeof(float)*(int)npoints); 
+    ret = H5Aread(attr, atype, float_array);
+    printf("Values : ");
+    for( i = 0; i < npoints; i++) printf("%f ", float_array[i]); 
+    printf("\n");
+    free(float_array);
+    }
+
+
+/*
+ * Release all identifiers.
+ */
+    H5Tclose(atype);
+    H5Sclose(aspace);
+    H5Aclose(attr);
+    return 0;
+}
diff --git a/examples/h5_select.c b/examples/h5_select.c
new file mode 100644
index 0000000..4de93e0
--- /dev/null
+++ b/examples/h5_select.c
@@ -0,0 +1,204 @@
+/* 
+ *  This program shows how the H5Sselect_hyperslab and H5Sselect_elements
+ *  functions are used to write selected data from memory to the file.
+ *  Program takes 48 elements from the linear buffer and writes them into
+ *  the matrix using 3x2 blocks, (4,3) stride and (2,4) count. 
+ *  Then four elements  of the matrix are overwritten with the new values and 
+ *  file is closed. Program reopens the file and reads and displays the result.
+ */ 
+ 
+#include <hdf5.h>
+
+#define FILE "Select.h5"
+
+#define MSPACE1_RANK     1          /* Rank of the first dataset in memory */
+#define MSPACE1_DIM      50         /* Dataset size in memory */ 
+
+#define MSPACE2_RANK     1          /* Rank of the second dataset in memory */ 
+#define MSPACE2_DIM      4          /* Dataset size in memory */ 
+
+#define FSPACE_RANK      2          /* Dataset rank as it is stored in the file */
+#define FSPACE_DIM1      8          /* Dimension sizes of the dataset as it is
+                                       stored in the file */
+#define FSPACE_DIM2      12 
+
+                                    /* We will read dataset back from the file
+                                       to the dataset in memory with these
+                                       dataspace parameters. */  
+#define MSPACE_RANK      2
+#define MSPACE_DIM1      8 
+#define MSPACE_DIM2      12 
+
+#define NPOINTS          4          /* Number of points that will be selected 
+                                       and overwritten */ 
+int main (void)
+{
+
+   hid_t   file, dataset;           /* File and dataset identifiers */
+   hid_t   mid1, mid2, fid;         /* Dataspace identifiers */
+   hsize_t dim1[] = {MSPACE1_DIM};  /* Dimension size of the first dataset 
+                                       (in memory) */ 
+   hsize_t dim2[] = {MSPACE2_DIM};  /* Dimension size of the second dataset
+                                       (in memory */ 
+   hsize_t fdim[] = {FSPACE_DIM1, FSPACE_DIM2}; 
+                                    /* Dimension sizes of the dataset (on disk) */
+
+   hssize_t start[2]; /* Start of hyperslab */
+   hsize_t stride[2]; /* Stride of hyperslab */
+   hsize_t count[2];  /* Block count */
+   hsize_t block[2];  /* Block sizes */
+
+   hssize_t coord[NPOINTS][FSPACE_RANK]; /* Array to store selected points 
+                                            from the file dataspace */ 
+   herr_t  ret;
+   uint    i,j;
+   int     matrix[MSPACE_DIM1][MSPACE_DIM2];
+   int     vector[MSPACE1_DIM];
+   int     values[] = {53, 59, 61, 67};  /* New values to be written */
+/*
+ * Buffers' initialization.
+ */
+vector[0] = vector[MSPACE1_DIM - 1] = -1;
+for (i = 1; i < MSPACE1_DIM - 1; i++) vector[i] = i;
+
+for (i = 0; i < MSPACE_DIM1; i++) {
+    for (j = 0; j < MSPACE_DIM2; j++)
+        matrix[i][j] = 0;
+}
+/*
+ * Create a file.
+ */
+file = H5Fcreate(FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+/* 
+ * Create dataspace for the dataset in the file.
+ */
+fid = H5Screate_simple(FSPACE_RANK, fdim, NULL);
+
+/*
+ * Create dataset and write it into the file.
+ */
+dataset = H5Dcreate(file, "Matrix in file", H5T_NATIVE_INT, fid, H5P_DEFAULT);
+ret = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, matrix);
+
+/*
+ * Select hyperslab for the dataset in the file, using 3x2 blocks, (4,3) stride
+ * (2,4) count starting at the position (0,1).
+ */
+start[0]  = 0; start[1]  = 1;
+stride[0] = 4; stride[1] = 3;
+count[0]  = 2; count[1]  = 4;    
+block[0]  = 3; block[1]  = 2;
+ret = H5Sselect_hyperslab(fid, H5S_SELECT_SET, start, stride, count, block);
+
+/*
+ * Create dataspace for the first dataset.
+ */
+mid1 = H5Screate_simple(MSPACE1_RANK, dim1, NULL);
+
+/*
+ * Select hyperslab. 
+ * We will use 48 elements of the vector buffer starting at the second element.
+ * Selected elements are 1 2 3 . . . 48
+ */
+start[0]  = 1;
+stride[0] = 1;
+count[0]  = 48;
+block[0]  = 1;
+ret = H5Sselect_hyperslab(mid1, H5S_SELECT_SET, start, stride, count, block);
+ 
+/*
+ * Write selection from the vector buffer to the dataset in the file.
+ *
+ * File dataset should look like this:       
+ *                    0  1  2  0  3  4  0  5  6  0  7  8 
+ *                    0  9 10  0 11 12  0 13 14  0 15 16
+ *                    0 17 18  0 19 20  0 21 22  0 23 24
+ *                    0  0  0  0  0  0  0  0  0  0  0  0
+ *                    0 25 26  0 27 28  0 29 30  0 31 32
+ *                    0 33 34  0 35 36  0 37 38  0 39 40
+ *                    0 41 42  0 43 44  0 45 46  0 47 48
+ *                    0  0  0  0  0  0  0  0  0  0  0  0
+ */
+ret = H5Dwrite(dataset, H5T_NATIVE_INT, mid1, fid, H5P_DEFAULT, vector);
+
+/*
+ * Reset the selection for the file dataspace fid.
+ */
+ret = H5Sselect_none(fid);
+
+/*
+ * Create dataspace for the second dataset.
+ */
+mid2 = H5Screate_simple(MSPACE2_RANK, dim2, NULL);
+
+/*
+ * Select sequence of NPOINTS points in the file dataspace.
+ */
+coord[0][0] = 0; coord[0][1] = 0;
+coord[1][0] = 3; coord[1][1] = 3;
+coord[2][0] = 3; coord[2][1] = 5;
+coord[3][0] = 5; coord[3][1] = 6;
+
+ret = H5Sselect_elements(fid, H5S_SELECT_SET, NPOINTS, 
+                         (const hssize_t **)coord);
+
+/*
+ * Write new selection of points to the dataset.
+ */
+ret = H5Dwrite(dataset, H5T_NATIVE_INT, mid2, fid, H5P_DEFAULT, values);   
+
+/*
+ * File dataset should look like this:     
+ *                   53  1  2  0  3  4  0  5  6  0  7  8 
+ *                    0  9 10  0 11 12  0 13 14  0 15 16
+ *                    0 17 18  0 19 20  0 21 22  0 23 24
+ *                    0  0  0 59  0 61  0  0  0  0  0  0
+ *                    0 25 26  0 27 28  0 29 30  0 31 32
+ *                    0 33 34  0 35 36 67 37 38  0 39 40
+ *                    0 41 42  0 43 44  0 45 46  0 47 48
+ *                    0  0  0  0  0  0  0  0  0  0  0  0
+ *                                        
+ */
+   
+/*
+ * Close memory file and memory dataspaces.
+ */
+ret = H5Sclose(mid1); 
+ret = H5Sclose(mid2); 
+ret = H5Sclose(fid); 
+ 
+/*
+ * Close dataset.
+ */
+ret = H5Dclose(dataset);
+
+/*
+ * Close the file.
+ */
+ret = H5Fclose(file);
+/*
+ * Open the file.
+ */
+file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
+
+/*
+ * Open the dataset.
+ */
+dataset = dataset = H5Dopen(file,"Matrix in file");
+
+/*
+ * Read data back to the buffer matrix.
+ */
+ret = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
+                  H5P_DEFAULT, matrix);
+
+/*
+ * Display the result.
+ */
+for (i=0; i < MSPACE_DIM1; i++) {
+    for(j=0; j < MSPACE_DIM2; j++) printf("%3d  ", matrix[i][j]);
+    printf("\n");
+}
+return 0;
+}