F5F.h

Go to the documentation of this file.

/*
//
// $Id: F5F.h,v 1.42 2008/03/19 21:21:43 werner Exp $
//
*/
 
#ifndef __F5F_H
#define __F5F_H
 
#include "F5L.h"
#include "F5Bchart.h"
#include "F5Path.h"
 
#ifdef  __cplusplus
extern "C"
{
#endif
 
/** flag to tell wether the field id is a group */
F5_API int F5Fis_group(const F5Path*);
 
/** flag to tell wether the fragment in the current field is a group
 
Note: The requirement to call this function is likely a design error in the
      calling code.
 */
F5_API int F5Ffragment_is_group(const F5Path*fpath, const char*fragment_name );
 
F5_API int F5LTset_dataspace(F5Path*f, int rank, hsize_t*dims);
 
F5_API int F5LTexpand_dataspace(F5Path*f, int rank, hsize_t*dims);
 
F5_API int F5Fexpand_dataspace(F5Path*fpath, int rank, hsize_t*Dims);
 
/**
   In F5, types are saved to the file to store certain information about datasets.
   The insufficiency in HDF5 is that a certain type can be saved to one file only,
   but not to many files, like a dataset. When a type is saved to a file, it becomes
   a "named type" - in contrast to "transient" types, which are not bound to a file.
   Only named types may carry attributes, transient types may not contain attributes.
 
   Type attributes are used to describe properties of a type, in particular its
   tensorial properties, which is beyond the raw native type definition of e.g. float
   and dimension. We cannot store this information with a transient type, but must
   do it by our own ;-( .
 
   Generic support would be desireable, but is not implemented right now.
   For now, only a limited set of pre-defined low-tensorial data types is
   hard-coded. By knowing this hard-coded type, also the tensorial type information
   is written into the file *when saving* the data type. Admittedly, this is
   not pretty, and a future revision will provide a more dynamically mechanism here.
 
 
   The functionality is as follows:
 
   Given a transient HDF5 type, return a named type that is suitable for the
   current file. The file ID's will be filled with the named data types.
 
   @Note The file which is contained in fpath will be changed by this operation,
           because a new type might be created and saved into the file, so the fpath parameter
           cannot be const.
 
   @Note This function currently only knows aboout point, vector
           and predefined tensor types in the ChartId. It is NOT fully generic.
           If it cannot convert some field type into a file type, it returns
           the transient type, i.e. we don't get a named type in this case.
 */
F5_API hid_t F5file_type(F5Path*fpath, hid_t fieldtype);
 
 
/**\ingroup F5L
   Remove a F5Path object.
  */
F5_API void F5close(F5Path*f);
F5_API void F5closep(F5Path**f);
 
/**\ingroup F5F
   Open a field entry within an F5Path object and leave all other entries intact.
   An previously opened field entry is closed before the new one is opened.
 
   @return zero if the entry could not be opened, non-zero otherwise.
 
   @note F5 does no HDF5 error management by itself. If any error messages
         from HDF5 when trying to open a non-existing field shall be
         emitted, the application code has to set the HDF5 error handler.
         F5 guarantees to leave these error handlers intact, even if they
         are locally disabled during some operations.
  */
F5_API int F5Fopen(F5Path*f, const char*fieldname);
 
/**\ingroup F5F
 */
F5_API F5Path*F5FopenMostRecentSlice(hid_t File_id, double*t,
                                     const char*gridname,
                                     const char*fieldname,
                                     const char*coordinate_system);
 
/**\ingroup F5F
   Close a field entry within an F5Path object and leave all other entries intact.
  */
F5_API void F5Fclose(F5Path*f);
 
/**\ingroup F5F
   Take an HDF5 field identifier out of control of the F5Path.
   The path identifier is no longer pointing to a field after this operations,
   it is just a truncated path up to the representation group.
   It is the responsibility of the caller to close the returned
   HDF5 identifier, which can either be a group or dataset.
   This can be determined either by inspecting f->FieldIDisGroup
   or by H5Gget_objinfo() .
   Note that using this function allows to keep a field ID open for
   later use, but undermines the transparency of fields as beeing
   stored as either datasets or a group with multiple datasets.
  */
F5_API hid_t F5Fgrab(F5Path*f);
 
 
/**\ingroup F5F
   Get the data type of an field, given an F5 path.
   @return An HDF5 datatype, caller must call H5Tclose().
  */
F5_API hid_t F5Fget_type2(F5Path*f, hid_t elink_fapl_id);
 
F5_API hid_t F5Fget_type(F5Path*f);
        
/**\ingroup F5F
   Get the data space of an field, given an F5 path.
   @return An HDF5 dataspace, caller must call H5Sclose().
  */
F5_API hid_t F5Tget_space(F5Path*f);
 
/**
   Permute a given dimensions array according to the memory ordering of the
   current coordinate system.
 
   @param source_dims The source dimensions.
   @param target_dims The target dimensions array, may be identical to the source
                      dimensions array.
   @return A pointer to the target dimensions array, if successfull, otherwise NULL.
 
   @param fpath       An F5Path object that must contain a valid coordinate system
                      description, e.g. via some F5Rcreate() operation.
*/
F5_API hsize_t*F5Tpermute_dimensions(F5Path*fpath,
                                     int rank,
                                     hsize_t*target_dims,
                                     const hsize_t*source_dims);
 
/**
   Get the extent (number of elements in each dimension)
   for a given F5 field. This function is like getting the
   data space via F5Tget_space() and then performing
   a F5Tpermute_dimensions() on the result.
 
   @param  dims    Storage place for the extension in each
                   dimension.
   @param  maxDims The maximal number of storage available for
                   the dims array
   @return The dimension of the current topology.
 
   It is recommended to allocate the storage as
   @code
   hsize_t dims[FIBER_MAX_RANK];
   @endcode
   where FIBER_MAX_RANK is a predefined integer constant
   from the F5 library which corresponds to the
   respective HDF5 value.
 
   @todo Add weblink here to HDF5 docu.
 */
F5_API int F5Tget_extent(F5Path*f, hsize_t*dims, int maxDims);
 
/**
   @param result pointer to integer which will contain the result
                 value on return.
   @return non-zero when attribute cold be read, zero if not.
 */
F5_API int F5Tget_index_depth(F5Path*f, int*result);
 
/** */
F5_API int F5LTget_skeleton_dimensionality(hid_t Top_hid);
 
/** */
F5_API int F5Tget_refinement_level(F5Path*f, hsize_t*dims, int maxDims);
 
 
/**\ingroup F5F
 
Create an HDF5 dataset for further treatment with raw HDF5 functions, e.g.
to write an hyperslab instead of the full dataset at once.
 
  @param property_id An HDF5 dataset property ID. If it is negative,
                      then a default property will be created locally
                      via <PRE>H5Pcreate(H5P_DATASET_CREATE)</PRE>.
 
  @param dataspace_id Pointer to an HDF5 identifier, that will be used to store
                        a shared dataspace. It may be NULL, in which case a local
                        dataspace is created. Until shared dataspaces are implemented
                        in HDF5, this will make no difference in the actual HDF5 file.
 
  @param fpath  An F5 Path object that has been created by a F5Rcreate() or related calls
                from the F5R group.
                Any previous field ID contained there will be closed and overwritten.
 
  @param fieldname The name of the field. It may be chosen arbitrarily, but must not contain slashes "/".
                   It is furthermore recommended to avoid special characters - even if
                   they work - and to keep the name short and concise).
 
  @param dimension The dimensionality of the data set.
  @param dims      The extension of the data set.
  @param fieldtype An HDF5 type identifier.
 
  \see F5Lcreate()
 
   \todo Add consistency check of sustained dataspace properties
         across multiple fields per representation.
 
   @return zero if the entry could not be opened, non-zero otherwise.
*/
F5_API int F5Fcreate(F5Path*fpath, const char*fieldname, int dimension, hsize_t*dims,
                     hid_t fieldtype, hid_t property_id);
 
enum F5ErrorCode_type
{
        /** no troubles */
        F5_SUCCESS       = 0,
 
        /** fpath pointer is invalid */
        F5ERROR_INVALID_FPATH = -1,
 
        /**  inconsistent dataspace (does not match with representation group)  */
 
        F5ERROR_INCONSISTENT_DATASPACE = -2,
 
        /**   F5Fwrite_fraction(): fragment starts beyond dataspace */
        F5ERROR_INVALID_FRAGMENT_START = -3,
 
        /**   F5Fwrite_fraction(): fragment ends beyond dataspace */
        F5ERROR_INVALID_FRAGMENT_END   = -4,
 
        /**   Invalid field name */
        F5ERROR_INVALID_FIELDNAME   = -5,
 
        /**   Invalid fragment name */
        F5ERROR_INVALID_FRAGMENTNAME   = -6,
 
        /**   Invalid data pointer, nullptr */
        F5ERROR_INVALID_DATA_ADDRESS   = -7,
 
        /**   Some invalid function parameter */
        F5ERROR_INVALID_PARAMETERS    = -9,
 
        F5ERROR_ALREADY_EXISTS = -10,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPOUND_EXPECTED     = -30,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPONENTMAP_EXPECTED = -31,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPONENTMAP_INVALID  = -32,
 
        F5ERROR_NONSPECIFIED = -100
};
 
typedef enum F5ErrorCode_type F5ErrorCode;
 
 
/**\ingroup F5F
   Return a string explaining the meaning of a certain
   error code.
 */
F5_API const char*F5Fwhatsup(F5ErrorCode);
 
 
/**\ingroup F5F
 
   Write some data as a contiguous field under the given F5Path
   location with the given name.
 
   The dimensions of the data must match exactly the dataspace
   of the containing Skeleton.
   Use F5FwriteHyperDimensional() to store a dataset that is
   higher-dimensional than the containing Skeleton.
   
   @param fpath The F5Path pointing to the location of the Field.
                The field ID filled in. Any previous field ID contained there
                will be closed and overwritten.
 
   @param property_id An HDF5 dataset property ID. If it is negative,
                      then a default property will be created locally
                      via <PRE>H5Pcreate(H5P_DATASET_CREATE)</PRE>.
 
   @param dimension The dimensionality of the data set. You may use F5Lwrite1D() as a convenience
                    shortcut for one-dimensional data sets.
 
   @param dims      The extension of the data set.
 
   @note Fields are always associated to certain coordinates system.
         The field type must be consistent with its coordinate system,
         e.g. one may not store a vector field in polar coordinates
         in a cartesian chart. Formally, this can be done because not
         all API functions have the ability to check for this consistency.
         However, a field type which is not part of a certain coordinate
         system will be treated as non-existent when reading the file
         later.
 
  @note  If a field is a structure made by separate data arrays, e.g. a
         vector field with components x,y,z stored as three arrays of floats,
         then use function F5Lwrites().
 
   \todo Implement, and add consistency check of sustained dataspace properties
         across multiple fields per representation.
 
   @return error code telling the success of the write:
*/
F5_API F5ErrorCode F5Fwrite(F5Path*fpath, const char*fieldname,
                            int dimension, hsize_t*dims,
                            hid_t fieldtype, hid_t memtype, const void * dataPtr,
                            hid_t property_id);
 
 
/**\ingroup F5F
 
   Write some data as a contiguous field under the given F5Path
   location with the given name where the data dimensions are higher
   than the underlying skeleton. This functionality is useful to
   store data where the higher dimensions express constant, but
   unknown, number of data elements per point in the base space.
 
 */
F5_API F5ErrorCode F5FwriteHyperDimensional(F5Path*fpath, const char*fieldname,
                                     int rank, hsize_t*dims,
                                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                     hid_t property_id);
 
        
F5_API F5ErrorCode F5_DEPRECATED("This is an internal function. Use F5FwriteHyperDimensional() instead.",
                              F5Fwrite_flexible( F5Path*fpath, const char*fieldname,
                                                 int dimension, hsize_t*dims,
                                                 hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                                 hid_t property_id, int do_check ));
 
/**\ingroup F5F
 Save a dataset according to the specifications in
        https://support.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html
 Only rank 2 dimensions are allowed here. All other arguments will lead to an error.
 Note that this specification is quite inconsistent, as an rgb data set is modeled as
 a three-dimensional array, not a two-dimensional array of type rgb. Still, we allow
 this format explicitely here since it is a standard.
 */
F5_API F5ErrorCode F5FwriteIMAGE(F5Path*fpath, const char*fieldname,
                                 int dimension, hsize_t*dims,
                                 hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                 hid_t property_id);
 
F5_API F5ErrorCode F5Fwrite_1D(F5Path*fpath, const char*fieldname,
                               hsize_t nElements, hid_t fieldtype, hid_t memtype,
                               const void *dataPtr, hid_t property_id);
 
/**
  Write an array of compound data type as separated components.
  @param dataPtr An array of pointers to the respective arrays for each component
  @param memtype An HDF5 compound data type that specifies how the data reside
                 in memory.
  @return 0 if the entry could not be opened, non-zero otherwise.
*/
F5_API int F5Fwrites(F5Path*fpath, const char*fieldname,
                     int dimension, hsize_t*dims,
                     hid_t fieldtype, hid_t memtype, const void ** dataPtr,
                     hid_t property_id);
 
/**\ingroup F5F
   Write a field which is defined procedurally as a polynomial function of each manifold
   coordinate index.
 
   @param rank                      Dimensionality of the base manifold
   @param dims[rank]                Extension of the base manifold
   @param fieldtype                 The type of the field as it should appear in the file
   @param memtype                   The type of the field as it resides in memory
   @param dataPtr[COMPONENTS]       An array of polynom coefficients for each component of fieldtype
   @param polynom_order[COMPONENTS] The order of each component's polynom
   @param component_map[rank]       Mapping from manifold index to component
 */
F5_API F5ErrorCode F5FwriteX(F5Path*fpath, const char*fieldname,
                             int rank, const hsize_t dims[],
                             hid_t fieldtype, hid_t memtype,
                             const void *const dataPtr[], const int polynom_order[],
                             const int component_map[],
                             hid_t property_id);
 
 
F5_API void F5FevalX(double*result, int Mrank, const int index[],
                     int components, const double*const polynomials[], const int polynom_order[],
                     const int component_map[]);
 
 
/**\ingroup F5F
  Write a field which is a linear mapping of a base and delta value.
  @param fpath An F5Path object referring to the location where the field
               shall be created. It must contain a valid Representation_hid.
               Its Field_hid will contain a reference to the newly created Field
               on return. If the F5Path object already contained a valid Field_hid,
               then this one will be closed by this call.
  @param rank  The rank (dimensionality) of the data set.
  @param dims  The extension of the data set.
  @param fieldtype The type of the field, being compatible to base and delta.
  @return zero, if the entry could not be opened, non-zero if successful.
  @todo Make this function compatible with F5FwriteX instead.
        Need to revise this function such that base and delta may be different
        types, for instance a point and a tangential vector.
        Possibly provide an alternative function where the min/max is specified
        instead.
  */
F5_API int F5Fwrite_linear(F5Path*fpath, const char*fieldname,
                           int rank, hsize_t*dims,
                           hid_t fieldtype, const void * base, const void*delta);
 
 
/**\ingroup F5F
   Write a dataset which only covers a fraction of the entire representation's domain.
   Such datasets are called "fragmented".
 
   @param fpath  An F5 Path object that has been created by a F5Rcreate() or related calls
                 from the F5R group.
                 Any previous field ID contained there will be closed and overwritten.
 
   @param rank          The rank (dimensionality) of the data set. Maximum value 8 is set by HDF5.
   @param full_dims     The extension of the full (virtual) data set in each dimension, i.e. the
                        size of the entire field when reconstructed from all fragments covering
                        this field.
   @param datastart     The (multidimensional) start index of the saved data set.
                        Also known as the minimum integer coordinates of this fragment in
                        the coarse grid.
   @param fragment_dims The number of elements of this fraction.
   @param fraction_name A string to name this fraction. It may be an arbitrary
                        name, but should be consistently used among all fragmented
                        fields.
                        It may be NULL to use an internal default (this feauture is
                        not implemented yet, so please DO specify a valid name here).
 
   @param property_id An HDF5 dataset property ID. If it is negative,
                      then a default property will be created locally
                      via <TT>H5Pcreate(H5P_DATASET_CREATE)</TT>.
 
   @param start_border The number of overlapping elements at the lower border (also
                        known as ghost zones). It may be NULL if the fragments do no
                        overlap.
   @param end_border   The number of overlapping elements at the upper border (also
                        known as ghost zones). It may be NULL if the fragments do no
                        overlap.
 
 
   @param fieldtype     The data type of the field as it should appear in the file.
   @param memtype       The data type of the field as it exists in memory. It may be
                        negative if it is identical to the field type.
                        For instance, if an array of doubles should be written into a
                        file in single precision, specify fieldtype=H5T_NATIVE_DOUBLE
                        and memtype=H5T_NATIVE_FLOAT .
 
   @note Subsampling can not be specified here. Subsampled data need to go into another
         Topology group.
 
   @return An error code telling why the function failed.
  */
F5_API F5ErrorCode F5Fwrite_fraction(F5Path*fpath, const char*fieldname,
                                     int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                     const hsize_t*datastart,
                                     const hsize_t*start_border, const hsize_t*end_border,
                                     const char*fraction_name, hid_t property_id);
 
F5_API F5ErrorCode F5Fwrite_fraction_external(F5Path*fpath, const char*fieldname,
 
                                              const char *target_file_name,
                                              const char *target_obj_name,
                                              const char *prefix,
 
                                     int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                     const hsize_t*datastart,
                                     const hsize_t*start_border, const hsize_t*end_border,
                                     const char*fraction_name, hid_t property_id);
 
 
/**\ingroup F5F
   Write a dataset given as a compound as separate components,
   changing the in-memory data layout.
*/
F5_API F5ErrorCode F5Fwrite_fractionS(F5Path*fpath, const char*fieldname,
                                      int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                      hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                      const hsize_t*datastart,
                                      const hsize_t*start_border, const hsize_t*end_border,
                                      const char*fraction_name, hid_t property_id);
 
        
/**\ingroup F5F
   Write a dataset given as separate components
   which only covers a fraction of the entire representation's domain.
   @param dimension     The dimension of the data set.
 
   @param full_dims     The extension of the full (virtual) data set in each dimension, i.e. the
                        size of the entire field when reconstructed from all fragments covering
                        this field.
   @param datastart     The (multidimensional) start index of the saved data set.
   @param fragment_dims The number of elements of this fraction.
   @param fraction_name An optional string to name this fraction.
                        It may be NULL to use an internal default.
 
   @param AllowFullCoverage If non-zero, then the data set is not written as a fragment
                            in case its dimensions cover the entire data space.
                            Use this reduction option with care. This automatism
                            might lead to bad effects, especcially it eliminates the
                            capability to add fragments later. By default, leave this
                            parameter at 0.
 
   @note Subsampling can not be specified here. Subsampled data need to go into another
         Topology group.
   @return true
 
  */
F5_API int F5FSwrite_fraction(F5Path*fpath, const char*fieldname,
                              int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                              hid_t fieldtype, hid_t memtype, const void *const* dataPtr,
                              const hsize_t*datastart,
                              const hsize_t*start_border, const hsize_t*end_border,
                              const char*fraction_name, hid_t property_id,
                              int AllowFullCoverage);
 
/**\ingroup F5F
   Write a dataset given as small "linear mappings"
   which only covers a fraction of the entire representation's domain.
   Useful to specify local bounding boxes.
 
   @param dimension     The dimension of the data set.
 
   @param full_dims     The extension of the full (virtual) data set in each dimension, i.e. the
                        size of the entire field when reconstructed from all fragments covering
                        this field.
   @param datastart     The (multidimensional) start index of the saved data set.
   @param fragment_dims The number of elements of this fraction.
   @param fraction_name An optional string to name this fraction.
                        It may be NULL to use an internal default.
   @note Subsampling can not be specified here. Subsampled data need to go into another
         Topology group.
   @return true
 
   @see F5Fwrite_linear_fraction_overlap()
  */
F5_API int F5Fwrite_linear_fraction(F5Path*fpath, const char*fieldname,
                                    int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                    hid_t fieldtype, const void * base, const void*delta,
                                    const hsize_t*datastart,
                                    const char*fraction_name);
 
/**
   Write overlap attributes associated with linear fractions.
 */
F5_API  int     F5Fwrite_linear_fraction_overlap(F5Path*myPath,
                                                 int rank,
                                                 const hsize_t*start_border,
                                                 const hsize_t*end_border,
                                                 const char*fraction_name);
 
        
/**
   Get the field enumeration type for a given field.
   If the fieldname is zero, then the fpath object must contain a
   valid Field_id. The F5Path object is unchanged.
 */
F5_API ArrayType F5Fget_field_enum(const F5Path*fpath, const char*fieldname,
                                   int*major_version, int*minor_version, int*release_version);
 
/**\ingroup F5F
   Check if a field within an F5 path is a linear mapping of points to values.
   @todo Implement. Similar to F5Lread_linear().
 */
F5_API int F5Fis_linear(F5Path*fpath, const char*fieldname);
 
F5_API int F5Fis_fragmented(F5Path*fpath, const char*fieldname);
F5_API int F5Fis_separatedcompound(F5Path*fpath, const char*fieldname);
 
/**\ingroup F5L
   Try to read a field which is a linear mapping of a base (origin) and delta value.
   The fpath object gets the  the field identifier set to the opened
   field (which is available to retrieve additional user-defined
           attributes and such).
 
  @params dims The dimensions of integer coordinates.
  @return zero, if the entry could not be opened, non-zero if successfull.
*/
F5_API int F5Fread_linear(F5Path*fpath,
                          hsize_t*dims,
                          hid_t fieldtype, void * base, void*delta);
 
F5_API int F5Fread_linearo(F5Path*fpath, const char*fieldname,
                          hsize_t*dims,
                          hid_t fieldtype, void * base, void*delta);
 
/** same as F5Fread_linear, but reads a fragment of a field
@TODO revise this function as it requires a fragment_hid, which is out of
      synch with the remaining F5 API: Fragments must never passed as id's
      but only as name, which may also be a null pointer to indicate
      unfragmented fields.
 */
F5_API int F5Fread_linear_fragment(F5Path*fpath,
                                hid_t fragment_hid,
                                hsize_t *dims,
                                hid_t fieldtype, void*base, void *delta);
 
 
/**
   Get a field's attribute, possibly specifying data conversion.
   @param mem_type_id The type of the attribute as it resides in memory,
                      may be zero to use the type of the attribute in-file.
   @param fragment_name Optional name of a fragment, null string indicates unfragmented read.
 */
F5_API int F5Fget_attribute_byname( F5Path*f, const char*attribute_name,
                                    void*data, hsize_t N, hid_t mem_type_id,
                                    const char*fragment_name);
 
/**
   Set a field's attribute.
   @param fragment_name Optional name of a fragment, null string indicates unfragmented read.
*/
F5_API int F5Fset_attribute_byname( F5Path*f, const char*attribute_name,
                                    const void*data, hsize_t N, hid_t mem_type_id,
                                    const char*fragment_name);
        
/**
   Field attribute (recommended): The min/max of components of a dataset.
   This two-element attribute is of the same type as a dataset,
   but contains the respective minimal/maximal value of the
   data's components.
   Example: for a set of point locations distributed in space,
   this gives the bounding box.
   @param memtype_id HDF5 Type ID describing the min/max variables. May be zero
                     to use exactly the type of the field. Otherwise, type conversion
                     must be available to HDF5.
 
   @note WARNING: You should never use the file type for reading, because then you
         might get values in the wrong bitorder! Usually you want to provide a
         type that is identically to the file type, but constructed from NATIVE
         types!
   @todo Write a function that converts types from file type to native type...
 */
F5_API int F5Fget_range( F5Path*f, const char*fragment_name, void*minmax );
 
/**
   Set the range of values within a dataset.
   The given min/max values must be of the same type as in the field.
 */
F5_API int F5Fset_range(F5Path*f, const char*fragment_name, const void*minmax);
 
        
#ifdef  __cplusplus
}    /* extern "C" */
#endif
 
#endif  /* __F5F_H */