Useful extension of the HDF5 API.

Macros
#define	H5Gclose(x)

Functions
F5_API hid_t	F5open (const char *filename, int socket)
F5_API int	F5connect (const char *url)
F5_API int	F5listen (const char *service)
F5_API void	F5closesocket (int socket)
F5_API void	F5socket_init ()
F5_API void	F5socket_cleanup ()
F5_API hid_t	F5Gcreate (hid_t loc_id, const char *name, int est_num_entries, int est_name_len)
F5_API hid_t	F5append (const char *filename)
F5_API hid_t	F5Gappend (hid_t loc_id, const char *name)
F5_API hid_t	F5Gappend_hinted_creation (hid_t loc_id, const char *name, int est_num_entries, int est_name_len)
F5_API hid_t	F5Gappend_external (hid_t loc_id, const char *name, const char *target_file_name, const char *target_obj_name, const char *prefix)
F5_API hid_t	F5Dappend (hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist_id)
F5_API hid_t	F5Dcreate (hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist_id)
F5_API int	F5Gopen (hid_t location, const char *name)
F5_API int	F5Gexist (hid_t location, const char *name)
F5_API hid_t	F5Gtry_to_open (hid_t location, const char *name)
F5_API int	F5Dexist (hid_t location, const char *name)
F5_API hid_t	F5Dtry_to_open (hid_t location, const char *name)
F5_API herr_t	F5Xclose (hid_t obj_id)
F5_API herr_t	_F5Gclose (hid_t id, const char *filename, int lineno)

Detailed Description

These extensions are of general use, not only in conjunction with the fiber bundle concept, but they just happen to sit here in this library.

Macro Definition Documentation

H5Gclose

#define H5Gclose

(

x

)

Value:

_F5Gclose(x, __FILE__, __LINE__)

Examples

ObjtoF5.c.

Definition at line 144 of file F5X.h.

Referenced by _F5Gclose(), F5B_read_chart_domain(), F5B_read_global_chart(), F5B_save_global_chart(), F5BgetGridVertexData(), F5Bopen_coordinate_domain(), F5Cget_content_types(), F5Cget_fields(), F5close(), F5Cset(), F5Fclose(), F5Fget_attribute_nr_elements(), F5Fget_field_enum(), F5Fget_fragment_attribute(), F5Fhas_fragment_attribute(), F5file_type(), F5Fis_fragment_attribute_of_type(), F5Fset_fragment_attribute(), F5Gappend_external(), F5Gappend_tree(), F5get_extension(), F5Gexist(), F5has_standard_vertex_fields(), F5I_add_field(), F5I_add_grid(), F5I_create_contents(), F5iterate_grids_per_bundle(), F5iterate_representations(), F5iterate_topologies(), F5iterate_topology_fields(), F5iterate_vertex_fields(), F5Lget_field_dimension_and_type(), F5Lis_linear(), F5Lread_linear(), F5LTcreate_topology(), F5LTcreateV(), F5LTget_maximal_grid_refinement(), F5LTget_maximal_skeleton_refinement(), F5LTset_maximal_grid_refinement(), F5P_has_vertices(), F5P_is_curvilinear(), F5P_is_rectilinear(), F5P_is_triangular_surface(), F5P_is_uniform(), F5Tmake_precise_tensor(), and F5Xclose().

Function Documentation

_F5Gclose()

F5_API herr_t _F5Gclose	(	hid_t	id,
		const char *	filename,
		int	lineno )

Call H5Cclose with a debug message when F5_VERBOSITY is larger then 110

Definition at line 342 of file F5private.c.

{
        F5printf(110, "   H5Gclose(%lx): %s(%d)", (long)id, filename, lineno );
        return H5Gclose( id );
}

References F5printf, and H5Gclose.

F5append()

F5_API hid_t F5append

(

const char *

filename

)

Open some file for appending data.

Definition at line 225 of file F5X.c.

{
hid_t   id;
 
        H5E_BEGIN_TRY
        id = H5Fcreate (filename, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
 
        if (id<0)
                return H5Fopen(filename, H5F_ACC_RDWR, H5P_DEFAULT);
 
        return id;
}

Referenced by F5Gappend_external(), and saveF5image().

F5closesocket()

F5_API void F5closesocket

(

int

socket

)

A forwarding call to the platformspecific system call to close a socket.

Definition at line 582 of file F5X.c.

{
        if (socket>0)
                closesocket(socket);
}

References closesocket.

F5connect()

F5_API int F5connect

(

const char *

url

)

Open a socket connection to the specified host and port. The URL must be of the form:

HDF5://myhost.com:6666/T=0.000000/

Definition at line 415 of file F5X.c.

{
#ifndef NI_MAXHOST
#define NI_MAXHOST 10000
#endif
 
char hostname[NI_MAXHOST];
char    *p, *command;
 
const char*service = "6666";
int     sockfd = 0;
struct  addrinfo *res;
struct  addrinfo *r;
int     error;
int     commandlen = 0;
 
        /*
          URL chopping: get hostname and service name
        */
        if ( strncmp( url, "hdf5://", 7 ) != 0
             &&
             strncmp( url, "HDF5://", 7 ) != 0 )
        {
                return 0;
        }
        url += 7;
 
        strcpy(hostname, url);
        p = strchr(hostname,':');
        if (p)
        {
                *p = '\0';
                p++;
                service = p;
        }
 
        command = strchr(p?p:hostname,'/');
        if (command)
        {
                *command++ = '\0';
                commandlen = strlen(command);
        }
 
 
/***************************************/
        error = getaddrinfo(hostname, service, NULL, &res);
        switch(error)
        {
        case EAI_AGAIN: /* case WSATRY_AGAIN:    */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "A temporary failure in name resolution occurred.\n", hostname, service);
                return -1;
 
        case EAI_BADFLAGS:/*    WSAEINVAL */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "An invalid value was provided for the ai_flags member of the hints parameter.\n",
                       hostname, service);
                return -1;
 
        case EAI_FAIL:/*        WSANO_RECOVERY  */
                printf("CANNOT open HDF5 stream from `%s' %s:"
                       " A nonrecoverable failure in name resolution occurred.\n",
                       hostname, service);
                return -1;
 
/*
EAI_FAMILY      WSAEAFNOSUPPORT         The ai_family member of the hints parameter is not supported.
EAI_MEMORY      WSA_NOT_ENOUGH_MEMORY   A memory allocation failure occurred.
*/
        case EAI_NONAME:  /*   WSAHOST_NOT_FOUND  */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "The name does not resolve for the supplied parameters "
                       "or the nodename and servname parameters were not provided.\n", hostname, service);
                return -1;
 
        case EAI_SERVICE: /*    WSATYPE_NOT_FOUND */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "The servname parameter is not supported for the specified "
                       "ai_socktype member of the hints parameter.\n", hostname, service);
                return -1;
 
/*EAI_SOCKTYPE  WSAESOCKTNOSUPPORT      The ai_socktype member of the hints parameter is not supported. */
 
        default:
                printf("CANNOT open HDF5 stream from `%s' %s: error code %d\n", hostname, service, error);
                return -1;
 
        case 0: /* no error */
                F5printf(10, "HDF5 stream to `%s' %s: addrinfo ok, proceeding\n", hostname, service);
                break;
        }
 
 
        for(r = res; r; r = r->ai_next)
        {
        int     cerror;
                sockfd = socket(r->ai_family,
                                r->ai_socktype,
                                r->ai_protocol);
 
                if (sockfd <= 0 || sockfd==(int)INVALID_SOCKET)
                {
                        printf("HDF5 stream: FAILED to open connection\n");
                        continue;
                }
 
                F5printf(5, "F5connect: Created socket for HDF5 stream from `%s':%s...\n", hostname, service );
 
                cerror = connect(sockfd, r->ai_addr, r->ai_addrlen);
                F5printf(5, "F5connect: Connected to `%s':%s...\n", hostname, service );
                if (cerror)
                {
                        cerror = WSAGetLastError();
                        switch( cerror )
                        {
#if defined(_WINDOWS)
                        case WSAECONNREFUSED:
#else
                        case ECONNREFUSED:
#endif
                                printf("HDF5 stream to `%s' %s: connection refused.\n", hostname, service);
                                break;
/*
//                              case WSAEADDRNOTAVAIL:
//                                      printf("HDF5 stream to `%s' %s: The remote address is not a valid address.\n", hostname, service);
//                                      break;
 
//                              case WSAEFAULT:
//                              case WSAENETUNREACH:
//                              case WSAEHOSTUNREACH:
//                              printf("HDF5 stream to `%s' %s: A socket operation was attempted to an unreachable host.\n", hostname, service);
//                                      break;
*/
                        default:
                                perror("CANNOT connect to HDF5 stream");
                                printf("HDF5 stream to `%s' %s: error code %d.\n", hostname, service, cerror);
                                continue;
                        }
                        closesocket( sockfd );
                        sockfd = 0;
                        continue;
                }
                break;
        }
        freeaddrinfo(res);
 
        if (sockfd<=0)
        {
                puts("HDF5 URL: could not open valid connection.");
                return -1;
        }
 
        if (commandlen>0)
        {
        int     werr;
                F5printf(1, "Sending HDF5 Request `%s'\n", command );
 
                werr = send(sockfd, command, commandlen, 0);
                if (werr<0)
                        perror("Sending HDF5 Request");
                else if (werr != commandlen)
                        F5printf(1,"Warning: Only sent %d of %d bytes during HDF5 Request transfer\n", werr, commandlen);
        }
        return sockfd;
}

References closesocket, F5printf, INVALID_SOCKET, NI_MAXHOST, and WSAGetLastError.

F5Dappend()

F5_API hid_t F5Dappend	(	hid_t	loc_id,
		const char *	name,
		hid_t	type_id,
		hid_t	space_id,
		hid_t	create_plist_id )

Open some dataset if it exists, otherwise create one.

Definition at line 239 of file F5X.c.

{
hid_t   id;
 
        H5E_BEGIN_TRY
        id = H5Dopen2(loc_id, name, H5P_DEFAULT );
        H5E_END_TRY
 
        if (id>0)
        {
        hid_t   FileSpace_id = H5Dget_space( id ); 
        hssize_t NewPoints = H5Sget_simple_extent_npoints( space_id );
        hssize_t OldPoints = H5Sget_simple_extent_npoints( FileSpace_id );
                F5printf(41, "F5Dappend(%lli,%s,...) opening existing dataset...", loc_id, name); 
                H5Sclose( FileSpace_id ); 
 
                if (NewPoints != OldPoints)
                {
                hid_t lapl_id = H5P_DEFAULT;
                        
                        F5printf(0, "PERFORMANCE WARNING: F5Dappend(,%s,,NewSize=%lld,...) modifying dataset to different size, it is %lld currently (%s to %u%%).",
                                 name, (long long)NewPoints,  (long long)OldPoints,
                                 (NewPoints<OldPoints)?"shrink":"grow", (int)(100*NewPoints)/OldPoints ); 
                        H5Dclose(id); 
                        id = -1; 
                        H5Ldelete( loc_id, name, lapl_id );
                }
        }
 
        if (id<0)
        {
                F5printf(41, "F5Dappend(%lli,%s,...) could not open existing dataset...", loc_id, name); 
                id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT) ;
                if (id<0)
                        F5printf(41, "F5Dappend(%lli,%s,...) could not create dataset...", loc_id, name);
        }
        return id;
}

References F5printf, and name.

Referenced by F5Cwrite_regular_surface(), and F5write_particle_cartesian3DvU().

F5Dcreate()

F5_API hid_t F5Dcreate	(	hid_t	loc_id,
		const char *	name,
		hid_t	type_id,
		hid_t	space_id,
		hid_t	create_plist_id )

Create a new dataset, possibly deleting an old one if such exists.

Definition at line 278 of file F5X.c.

{
hid_t   id;
        H5E_BEGIN_TRY 
        id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT) ;
        H5E_END_TRY
        if (id<0)
        {
                F5printf(10, "F5Dcreate(%d,%s,...) could not create dataset, dataset already exists, deleting it...", (int)(loc_id), name);
                H5Ldelete( loc_id, name, H5P_DEFAULT );
                id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT);
        }
 
        if (id<0)
                F5printf(0, "F5Dcreate(%d,%s,...) could not create dataset, not even after deletion...", (int)(loc_id), name); 
 
        return id; 
}

References F5printf, and name.

Referenced by F5Lcreate().

F5Dexist()

F5_API int F5Dexist	(	hid_t	location,
		const char *	name )

Check if a dataset exists.

Definition at line 321 of file F5X.c.

{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Dopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        if (retval>=0)
                H5Dclose(retval);
 
        return retval>=0;
}

References name.

Referenced by F5P_has_vertices(), F5P_is_curvilinear(), and F5P_is_rectilinear().

F5Dtry_to_open()

F5_API hid_t F5Dtry_to_open	(	hid_t	location,
		const char *	name )

Definition at line 335 of file F5X.c.

{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Dopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        return retval;
}

References name.

Referenced by F5Fget_attribute_byname(), F5Fset_attribute_byname(), and F5P_is_triangular_surface().

F5Gappend()

F5_API hid_t F5Gappend	(	hid_t	loc_id,
		const char *	name )

Open some group if it exists, otherwise create one.

Definition at line 59 of file F5X.c.

{
        return F5Gappend_hinted_creation(loc_id, name, -1, -1);
}

References F5Gappend_hinted_creation(), and name.

Referenced by F5Bappend_slice(), F5Cget_content_types(), F5Cget_fields(), F5Cset(), F5file_type(), F5Fwrite_linear_fraction(), F5Gappend_tree(), F5I_add_field(), F5I_add_grid(), F5I_create_contents(), F5LSwrite_fraction(), F5LTcreate_topology(), F5LTcreateV(), F5LTget_maximal_grid_refinement(), F5LTget_maximal_skeleton_refinement(), F5LTset_maximal_grid_refinement(), F5Lwrite_fraction(), F5Lwrite_fractionS(), and F5LwriteS().

F5Gappend_external()

F5_API hid_t F5Gappend_external	(	hid_t	loc_id,
		const char *	name,
		const char *	target_file_name,
		const char *	target_obj_name,
		const char *	prefix )

Definition at line 136 of file F5X.c.

{
herr_t  external_err;
hid_t   id; 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT); 
        H5E_END_TRY
        if (id>=0)
                return id; 
 
                
/* link creation property list used in creating the new link. */
/*
If crt_intermed_group is non-positive, the H5G_CRT_INTMD_GROUP, if present, will be removed from lcpl_id. Missing intermediate groups will not be created upon calls to functions such as those listed above that use lcpl_id. 
                  herr_t H5Pset_create_intermediate_group( hid_t lcpl_id, unsigned crt_intermed_group ) 
*/ 
hid_t   lcpl_id = H5Pcreate(H5P_LINK_CREATE); 
        H5Pset_char_encoding( lcpl_id, H5T_CSET_UTF8 );
 
/*
  herr_t H5Pset_elink_cb( hid_t lapl_id, H5L_elink_traverse_t func, void *op_data )
  Purpose:
  Sets the external link traversal callback function in a link access property list.
 
  herr_t H5Pset_elink_fapl( hid_t lapl_id, hid_t fapl_id )
  Purpose:
Sets a file access property list for use in accessing a file pointed to by an external link.          
*/ 
hid_t   lapl_id = H5Pcreate( H5P_LINK_ACCESS ); 
 
        if (prefix && *prefix)
                H5Pset_elink_prefix( lapl_id, prefix ); 
 
/*
  The library opens target file target_file_name with the file access property list that is set via H5Pset_elink_fapl when the external link link_name is accessed. If no such property list is set, the library uses the file access property list associated with the file of link_loc_id to open the target file.
*/ 
        external_err = H5Lcreate_external( target_file_name, target_obj_name,
                                           loc_id, name, lcpl_id, lapl_id ); 
        H5Pclose(lcpl_id);
        H5Pclose(lapl_id);
 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT); 
        H5E_END_TRY     
        if (id<0)
        {
        hid_t   ExternalFileID, ExternalFileGroup;
                F5printf(0, "F5Gappend_external(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) INFO - No external file yet, thus- CREATING external file structure", loc_id, name,
                         target_file_name,
                         target_obj_name,
                         prefix ); 
                ExternalFileID = F5append( target_file_name ); 
                if (ExternalFileID<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
 
                ExternalFileGroup = F5Gappend_tree(ExternalFileID, target_obj_name); 
 
                if (ExternalFileGroup<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file group", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
                
                H5Gclose( ExternalFileGroup );
                H5Fclose( ExternalFileID );
 
                id = H5Gopen2(loc_id, name, H5P_DEFAULT);
                if (id<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file structure", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
        }
 
        return id;
}

References F5append(), F5Gappend_tree(), F5printf, H5Gclose, and name.

Referenced by F5Lwrite_fraction_external().

F5Gappend_hinted_creation()

F5_API hid_t F5Gappend_hinted_creation	(	hid_t	loc_id,
		const char *	name,
		int	est_num_entries,
		int	est_name_len )

Open or create a group, if created then with estimated hints about its number of entries and estimated length of its member names.

Definition at line 87 of file F5X.c.

{
hid_t   id;
 
        F5printf(30, "F5Gappend(%lli,%s)", loc_id, name);
 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT );
        H5E_END_TRY
 
        if (id<0)
        {
                id = F5Gcreate(loc_id, name, est_num_entries, est_name_len );
                if (id<0)
                {
                        F5printf(0, "F5Gcreate(`%s') failed on ID %d!\n", name, (int)loc_id);
                }
        }
 
        if (id<0)
                F5printf(0, "F5Gappend(%lli,%s) FAILED", loc_id, name);
 
        return id;
}

References F5Gcreate(), F5printf, and name.

Referenced by F5Gappend().

F5Gcreate()

F5_API hid_t F5Gcreate	(	hid_t	loc_id,
		const char *	name,
		int	est_num_entries,
		int	est_name_len )

Create a group using utf8 encoding for the link name and making use of the estimated group entry and name length properties for optimization. If these values are negative, no such hints will be set.

Definition at line 65 of file F5X.c.

{
hid_t   id;
hid_t   lcpl_id =    H5Pcreate(H5P_LINK_CREATE); 
        H5Pset_char_encoding(lcpl_id, H5T_CSET_UTF8); 
 
hid_t   gcpl_id = H5Pcreate( H5P_GROUP_CREATE ); 
 
        if (est_num_entries>=0 && est_name_len >=0)
        {
                H5Pset_est_link_info( gcpl_id, (unsigned) est_num_entries, (unsigned) est_name_len ); 
        } 
        H5Pset_link_creation_order( gcpl_id, H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED ); 
 
        id = H5Gcreate2(loc_id, name, lcpl_id, gcpl_id, H5P_DEFAULT); 
 
        H5Pclose( gcpl_id );
        H5Pclose( lcpl_id );
        return id;
}

References name.

Referenced by F5Gappend_hinted_creation(), F5Lwrite_linear(), F5Lwrites(), and F5LwriteX().

F5Gexist()

F5_API int F5Gexist	(	hid_t	location,
		const char *	name )

Check if a group exists.

Definition at line 307 of file F5X.c.

{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Gopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        if (retval>=0)
                H5Gclose(retval);
 
        return retval>=0;
}

References H5Gclose, and name.

Referenced by F5Bopen_coordinate_domain(), F5LTcreateV(), F5P_has_vertices(), F5P_is_curvilinear(), F5P_is_particle_system(), and F5P_is_triangular_surface().

F5Gopen()

F5_API int F5Gopen	(	hid_t	location,
		const char *	name )

Open a group

References F5_API, and name.

F5Gtry_to_open()

F5_API hid_t F5Gtry_to_open	(	hid_t	location,
		const char *	name )

Try to open an HDF5 group, silently return -1 if it does not exist.

Definition at line 297 of file F5X.c.

{
hid_t   retval;
        H5E_BEGIN_TRY
        retval = H5Gopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        return retval;
}

References name.

Referenced by F5B_read_chart_domain(), F5Bopen_coordinate_domain(), F5Fget_attribute_byname(), F5iterate_grids_per_bundle(), F5iterate_representations(), F5iterate_topology_fields(), F5LTcreateV(), and F5P_is_triangular_surface().

F5listen()

F5_API int F5listen

(

const char *

service

)

Definition at line 621 of file F5X.c.

{
struct addrinfo hints, *res, *ressave;
int     n, sockfd = -1;
 
        memset(&hints, 0, sizeof(struct addrinfo));
 
        /*
          AI_PASSIVE flag: the resulting address is used to bind
          to a socket for accepting incoming connections.
          So, when the hostname==NULL, getaddrinfo function will
          return one entry per allowed protocol family containing
          the unspecified address for that family.
        */
        hints.ai_flags    = AI_PASSIVE; 
        hints.ai_family   = AF_INET;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
 
        n = getaddrinfo( NULL, service, &hints, &res);
 
        if (n<0)
        {
                return n;
        }
 
        ressave = res;
 
        /*
          Try open socket with each address getaddrinfo returned,
          until getting a valid listening socket.
        */
        while (res)
        {
                sockfd = socket(res->ai_family,
                                res->ai_socktype,
                                res->ai_protocol);
 
                if (!(sockfd < 0))
                {
                        if (bind(sockfd, res->ai_addr, res->ai_addrlen) == 0)
                                break;
 
                        closesocket(sockfd);
                        sockfd=-1;
                }
                res = res->ai_next;
        }
 
        if (sockfd < 0)
        {
                freeaddrinfo(ressave);
                F5printf(1, "F5listen(): could not open socket\n");
                return -1;
        }
 
 
        {
        struct linger wait_on_close;
                wait_on_close.l_onoff = 1; /* yes, wait on close */
                wait_on_close.l_linger = 1; /* and wait for 1 second */
                setsockopt (sockfd, SOL_SOCKET, SO_LINGER,
                            (const char*)&wait_on_close, sizeof (wait_on_close));
/*
// Erik says: the variables "on" and "port" are undeclared
//#ifdef        SO_REUSEPORT
//              if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int)) < 0)
//              {
//                      printf("Couldn't set SO_REUSEPORT to port %u: %s",
//                             port, strerror (errno));
//                      closesocket (sockfd);
//                      return -1;
//              }
//#endif
*/
        }
 
        listen(sockfd, SOMAXCONN);
 
        freeaddrinfo(ressave);
 
        return sockfd;
}

References closesocket, and F5printf.

F5open()

F5_API hid_t F5open	(	const char *	filename,
		int	socket )

Open some URL for reading data (read-only). Note that this function may well invoke the streaming HDF5 driver when a valid socket descriptor is given. Such might well be created by a call to F5connect(). Note that the socket needs to be closed explicitely.

Definition at line 589 of file F5X.c.

{
#ifdef  H5_HAVE_STREAM
hid_t   proplist = H5Pcreate (H5P_FILE_ACCESS);
hid_t   file_id;
 
H5FD_stream_fapl_t fapl;
        fapl.increment = 1024*1024;
        fapl.do_socket_io = 1;
        fapl.socket = socket;
        fapl.backlog = 0;
        fapl.broadcast_fn = 0;
        if (socket>0)
        {
                if (H5Pset_fapl_stream ( proplist, &fapl)<0)
                {
                        puts("HDF5: Problem in H5Pset_fapl_stream ()!");
                }
                file_id = H5Fopen("/dev/null", H5F_ACC_RDONLY, proplist);
                H5Pclose (proplist);
                if (file_id<0)
                {
                        puts("Problem Receiving HDF5 Stream Data...");
                        return -1;
                }
                return file_id;
        }
#endif
        return H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
}

F5socket_cleanup()

F5_API void F5socket_cleanup

(

)

Calling windows socket cleanup on windows

Definition at line 408 of file F5X.c.

{
#if defined(_WINDOWS)
        WSACleanup( );
#endif
}

F5socket_init()

F5_API void F5socket_init

(

)

Calling windows socket init on windows

Definition at line 390 of file F5X.c.

{
#if defined(_WINDOWS)
WSADATA wsaData;
WORD    wVersionRequested = MAKEWORD( 2, 2 );
int     err = WSAStartup( wVersionRequested, &wsaData );
        switch(err)
        {
        case 0:
                break;
 
        default:
                puts("windows sockets error");
                break;
        }
#endif
}

F5Xclose()

F5_API herr_t F5Xclose

(

hid_t

obj_id

)

Close an object regardless of its type.

Use this function to close any HDF5-Object,
if you do not know the type of the object.
This is especially usefull after a call to H5Rdereference().

@remark Normally you shouldn't use this function,
    because you should know the objects you are creating.

Remarks

The function doesn't work for properties, supported are only the following types:

• H5I_FILE
• H5I_GROUP
• H5I_DATATYPE
• H5I_DATASPACE
• H5I_DATASET
• H5I_ATTR

Parameters

ret_type_id	A pointer to a storage to take the type of the given object. See H5Iget_type() for a list of types.
obj_id	The ID of the object to be closed.

Returns

Error Code of the closing function. (A non-negative value if successful; otherwise a negative value.)

Todo

Better Error Value than "-1".

Note

Could/should rename this to F5Dclose(), to denote it as a function to close F5 dataset ID's, which can be HDF5 groups or datasets.

Definition at line 347 of file F5X.c.

{
        /* Get the type */
        H5I_type_t ObjectType = H5Iget_type(obj_id);
 
        /* Return it to the caller, if wanted
        if (pret_type_id)
                (*pret_type_id) = ObjectType;           */
 
        /* Call the appropriate closing func */
        switch (ObjectType)
        {
                case H5I_FILE:
                        return H5Fclose(obj_id);
 
                case H5I_GROUP:
                        return H5Gclose(obj_id);
 
                case H5I_DATATYPE:
                        return H5Tclose(obj_id);
 
                case H5I_DATASPACE:
                        return H5Sclose(obj_id);
 
                case H5I_DATASET:
                        return H5Dclose(obj_id);
 
                case H5I_ATTR:
                        return H5Aclose(obj_id);
 
                case H5I_BADID:
                        return -1;
 
                default:
            printf ("INTERNAL ERROR F5Xclose(): unknown type %d\n", ObjectType);
            return -1;
        }
}

References H5Gclose, and H5Tclose().

Referenced by F5Fget_attribute_byname(), F5Fset_attribute_byname(), F5Fwrite_linear_fraction(), F5Fwrite_linear_fraction_overlap(), F5LSwrite_fraction(), F5Lwrite_fraction(), F5Lwrite_fraction_external(), and F5Lwrite_fractionS().