From 7c606e5692bd4ff85545175c3c6ec8956dfb2418 Mon Sep 17 00:00:00 2001 From: Frank Baker Date: Thu, 21 Dec 2000 14:34:29 -0500 Subject: [svn-r3175] Purpose: CppUserNotes.pdf CppUserNotes.doc (not for distribution) CppInterfaces.html New C++ API documents -- "HDF5 C++ User's Notes" and "HDF5 C++ Interfaces" Platforms tested: IE 5 --- doc/html/cpplus/CppInterfaces.html | 1413 ++++++++++++++++++++++++++++++++++++ doc/html/cpplus/CppUserNotes.doc | Bin 0 -> 136192 bytes doc/html/cpplus/CppUserNotes.pdf | Bin 0 -> 55301 bytes 3 files changed, 1413 insertions(+) create mode 100644 doc/html/cpplus/CppInterfaces.html create mode 100644 doc/html/cpplus/CppUserNotes.doc create mode 100644 doc/html/cpplus/CppUserNotes.pdf diff --git a/doc/html/cpplus/CppInterfaces.html b/doc/html/cpplus/CppInterfaces.html new file mode 100644 index 0000000..cf98a2a --- /dev/null +++ b/doc/html/cpplus/CppInterfaces.html @@ -0,0 +1,1413 @@ + + +HDF5 C++ API Interfaces + + + +
+
+                           HDF5 C++ Interfaces
+                           ===================
+
+// HDF5 dataset and attribute have some common characteristics, so the
+// term abstract dataset is used to name the element that can represent 
+// both objects, dataset and attribute.
+//
+// Class AbstractDs is an abstract base class, from which Attribute and 
+// DataSet inherit.  It provides the services that are common to both 
+// Attribute and DataSet.  It also inherits from H5Object and passes down 
+// the services that H5Object provides.
+class AbstractDs : public H5Object
+
+	// Gets the dataspace of this abstract dataset - pure virtual
+	virtual DataSpace getSpace() const = 0;
+
+        // Gets the class of the datatype that is used by this abstract 
+	// dataset        
+	H5T_class_t getTypeClass() const;
+
+	// Gets a copy of the datatype that this abstract dataset uses.  
+	// Note that this datatype is a generic one and can only be accessed 
+	// via generic member functions, i.e., member functions belong to 
+	// DataType.  To get specific datatype, i.e. EnumType, FloatType, 
+	// etc..., use the specific functions, that follow, instead.
+	DataType getDataType() const;
+
+        // Gets a copy of the specific datatype of this abstract dataset
+        EnumType getEnumType() const;
+        CompType getCompType() const;
+        IntType getIntType() const;
+        FloatType getFloatType() const;
+        StrType getStrType() const;
+
+	// Copy constructor
+	AbstractDs( const AbstractDs& original );
+
+	virtual ~AbstractDs();
+
+// end of class AbstractDs
+
+// Atomic datatype can be an integer, float, string, or predefined datatype.
+//
+// Class AtomType is a base class, from which IntType, FloatType, StrType, 
+// and PredType inherit.  It provides the services that are common to these
+// subclasses.  It also inherits from DataType and passes down the  
+// services that are common to all the datatypes.
+class AtomType : public DataType
+
+	// Sets the total size for an atomic datatype. 
+	void setSize( size_t size ) const;
+
+	// Returns the byte order of an atomic datatype. 
+	H5T_order_t getOrder( string& order_string ) const;
+
+	// Sets the byte ordering of an atomic datatype. 
+	void setOrder( H5T_order_t order ) const;
+
+	// Returns the precision of an atomic datatype. 
+	size_t getPrecision() const;
+
+	// Sets the precision of an atomic datatype. 
+	void setPrecision( size_t precision ) const;
+
+	// Gets the bit offset of the first significant bit. 
+	int getOffset() const;
+
+	// Sets the bit offset of the first significant bit. 
+	void setOffset( size_t offset ) const;
+
+	// Copy constructor 
+	AtomType( const AtomType& original );
+
+	virtual ~AtomType();
+
+// end of class AtomType
+
+
+// An attribute is an abstract dataset because it has some characteristics
+// that a dataset also has, but not all.
+//
+// Class Attribute inherits from AbstractDs and provides accesses to an 
+// attribute.
+class Attribute : public AbstractDs
+
+	// Writes data to this attribute.
+	void write(const DataType& mem_type, void *buf ) const;
+
+	// Reads data from this attribute.
+	void read( const DataType& mem_type, void *buf ) const;
+
+	// Gets a copy of the dataspace for this attribute.
+	virtual DataSpace getSpace() const;
+
+	// Gets the name of this attribute.
+	string getName( size_t buf_size ) const;
+
+	// An attribute doesn't have the ability to iterate, simply because
+	// it doesn't have any attributes associated with it.  Thus, the
+	// implementation of this member which is inherited from H5Object
+	// is overwritten to do nothing here.
+	int iterateAttrs() const;
+
+        // Creates a copy of an existing attribute using the attribute id
+        Attribute( const hid_t attr_id );
+
+	// Copy constructor
+	Attribute( const Attribute& original );
+
+	virtual ~Attribute();
+
+
+// CommonFG is a protocol class.  Its existence is simply to provide the
+// common services that are provided by H5File and Group.  The file or 
+// group in the context of this class is referred to as 'location'.
+class CommonFG
+	// Creates a new group at this location.
+	Group createGroup( const string& name, size_t size_hint = 0 ) const;
+	Group createGroup( const char* name, size_t size_hint = 0 ) const;
+
+	// Opens an existing group in a location.
+	Group openGroup( const string& name ) const;
+	Group openGroup( const char* name ) const;
+
+	// Creates a new dataset at this location.
+	DataSet createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
+	DataSet createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
+
+	// Opens an existing dataset at this location.
+	DataSet openDataSet( const string& name ) const;
+	DataSet openDataSet( const char* name ) const;
+
+	// Creates a link of the specified type from new_name to current_name;
+	// both names are interpreted relative to this location.
+	void link( H5G_link_t link_type, const string& curr_name, const string& new_name ) const;
+	void link( H5G_link_t link_type, const char* curr_name, const char* new_name ) const;
+
+	// Removes the specified name at this location.
+	void unlink( const string& name ) const;
+	void unlink( const char* name ) const;
+
+	// Renames an HDF5 object at this location.
+	void move( const string& src, const string& dst ) const;
+	void move( const char* src, const char* dst ) const;
+
+	// Returns information about an HDF5 object, given by its name, at this location.
+	void getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
+	void getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
+
+	// Returns the name of the HDF5 object that the symbolic link points to.
+	string getLinkval( const string& name, size_t size ) const;
+	string getLinkval( const char* name, size_t size ) const;
+
+	// Sets the comment for the HDF5 object specified by its name.
+	void setComment( const string& name, const string& comment ) const;
+	void setComment( const char* name, const char* comment ) const;
+
+	// Retrieves comment for the HDF5 object specified by its name.
+	string getComment( const string& name, size_t bufsize ) const;
+	string getComment( const char* name, size_t bufsize ) const;
+
+	// Mounts the file 'child' onto this location.
+	void mount( const string& name, H5File& child, PropList& plist ) const;
+	void mount( const char* name, H5File& child, PropList& plist) const;
+
+	// Unmounts the file named 'name' from this location.
+	void unmount( const string& name ) const;
+	void unmount( const char* name ) const;
+
+	// Iterates over the elements of this location - not implemented in
+	// C++ style yet
+	int iterateElems( const string& name, int *idx, H5G_iterate_t op, void *op_data );
+	int iterateElems( const char* name, int *idx, H5G_iterate_t op, void *op_data );
+
+	// Opens a generic named datatype at this location
+	DataType openDataType( const string& name ) const;
+	DataType openDataType( const char* name ) const;
+
+	// Opens a named enumeration datatype at this location
+	EnumType openEnumType( const string& name ) const;
+	EnumType openEnumType( const char* name ) const;
+
+	// Opens a named compound datatype at this location
+	CompType openCompType( const string& name ) const;
+	CompType openCompType( const char* name ) const;
+
+	// Opens a named integer datatype at this location
+	IntType openIntType( const string& name ) const;
+	IntType openIntType( const char* name ) const;
+
+	// Opens a named floating-point datatype at this location
+	FloatType openFloatType( const string& name ) const;
+	FloatType openFloatType( const char* name ) const;
+
+	// Opens a named string datatype at this location
+	StrType openStrType( const string& name ) const;
+	StrType openStrType( const char* name ) const;
+
+	// For H5File and Group to throw appropriate exception - pure virtual
+	virtual void throwException() const = 0;
+
+	// Get id of the location, either group or file - pure virtual 
+	virtual hid_t getLocId() const = 0; 
+
+	CommonFG();
+	virtual ~CommonFG();
+
+// end of CommonFG declaration
+
+
+// Class CompType inherits from DataType and provides accesses to a compound 
+// datatype.
+class CompType : public DataType
+
+	// Creates a new compound datatype, given the type's size.
+	CompType( size_t size );
+
+	// Creates a compound datatype using an existing id.
+	CompType( const hid_t existing_id );
+
+	// Gets the compound datatype of the specified dataset.
+	CompType( const DataSet& dataset );
+
+	// Returns the number of members in this compound datatype. 
+	int getNmembers() const;
+
+	// Returns the name of a member of this compound datatype. 
+	string getMemberName( int member_num ) const;
+
+	// Returns the offset of a member of this compound datatype. 
+	size_t getMemberOffset( int memb_no ) const;
+
+	// Returns the dimensionality of the specified member of this compound datatype. 
+	int getMemberDims( int member_num, size_t* dims, int* perm ) const;
+
+	// Returns the type class of the specified member of this compound 
+	// datatype.  It provides to the user a way of knowing what type 
+	// to create another datatype of the same class.
+	H5T_class_t getMemberClass( int member_num ) const;
+
+	// Returns the generic datatype of the specified member in 
+	// this compound datatype.
+	DataType getMemberDataType( int member_num ) const;
+
+	// Returns the enumeration datatype of the specified member in 
+	// this compound datatype.
+	EnumType getMemberEnumType( int member_num ) const;
+
+	// Returns the compound datatype of the specified member in 
+	// this compound datatype.
+	CompType getMemberCompType( int member_num ) const;
+
+	// Returns the integer datatype of the specified member in 
+	// this compound datatype.
+	IntType getMemberIntType( int member_num ) const;
+
+	// Returns the floating-point datatype of the specified member in 
+	// this compound datatype.
+	FloatType getMemberFloatType( int member_num ) const;
+
+	// Returns the string datatype of the specified member in 
+	// this compound datatype.
+	StrType getMemberStrType( int member_num ) const;
+
+	// Adds a new member to this compound datatype.
+	void insertMember( const string name, size_t offset, const DataType& new_member ) const;
+
+	// Recursively removes padding from within this compound datatype. 
+	void pack() const;
+
+	// Default constructor
+	CompType();
+
+	// Copy constructor
+	CompType( const CompType& original );
+
+	virtual ~CompType();
+
+// end of class CompType
+
+
+// Class DataSet inherits from AbstractDs and provides accesses to a dataset.
+class DataSet : public AbstractDs
+
+	// Gets the dataspace of this dataset.
+	virtual DataSpace getSpace() const;
+
+	// Gets the creation property list of this dataset.
+	DSetCreatPropList getCreatePlist() const;
+
+	// Gets the storage size of this dataset.
+	hsize_t getStorageSize() const;
+
+	// Reads the data of this dataset and stores it in the provided buffer.
+	// The memory and file dataspaces and the transferring property list
+	// can be defaults.
+	void read( void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+
+	// Writes the buffered data to this dataset.
+	// The memory and file dataspaces and the transferring property list
+	// can be defaults.
+	void write( const void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+
+	// Extends the dataset with unlimited dimension.
+	void extend( const hsize_t* size ) const;
+
+	// Default constructor
+	DataSet();
+
+	// Copy constructor
+	DataSet( const DataSet& original );
+
+	virtual ~DataSet();
+
+// end of class DataSet
+
+
+// Class DataSpace provides accesses to the dataspace.
+class DataSpace : public IdComponent
+
+	// Default DataSpace objects
+	static const DataSpace ALL;
+
+	// Creates a dataspace object given the space type.
+	DataSpace( H5S_class_t type );
+
+	// Creates a simple dataspace.
+	DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims = NULL);
+
+	// Makes copy of an existing dataspace.
+	void copy( const DataSpace& like_space );
+
+	// Determines if this dataspace is a simple one.
+	bool isSimple () const;
+
+	// Sets the offset of this simple dataspace.
+	void offsetSimple ( const hssize_t* offset ) const;
+
+	// Retrieves dataspace dimension size and maximum size.
+	int getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims = NULL ) const;
+
+	// Gets the dimensionality of this dataspace.
+	int getSimpleExtentNdims () const;
+
+	// Gets the number of elements in this dataspace.
+	hssize_t getSimpleExtentNpoints () const;
+
+	// Gets the current class of this dataspace.
+	H5S_class_t getSimpleExtentType () const;
+
+	// Copies the extent of this dataspace.
+	void extentCopy ( DataSpace& dest_space ) const;
+
+	// Sets or resets the size of this dataspace.
+	void setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size = NULL ) const;
+
+	// Removes the extent from this dataspace.
+	void setExtentNone () const;
+
+	// Gets the number of elements in this dataspace selection.
+	hssize_t getSelectNpoints () const;
+
+	// Get number of hyperslab blocks.
+	hssize_t getSelectHyperNblocks () const;
+
+	// Gets the list of hyperslab blocks currently selected.
+	void getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const;
+
+	// Gets the number of element points in the current selection.
+	hssize_t getSelectElemNpoints () const;
+
+	// Retrieves the list of element points currently selected.
+	void getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const;
+
+	// Gets the bounding box containing the current selection.
+	void getSelectBounds ( hsize_t* start, hsize_t* end ) const;
+
+	// Selects array elements to be included in the selection for 
+	// this dataspace.
+	void selectElements ( H5S_seloper_t op, const size_t num_elements, const hssize_t* coord[ ] ) const;
+
+	// Selects the entire dataspace.
+	void selectAll () const;
+
+	// Resets the selection region to include no elements.
+	void selectNone () const;
+
+	// Verifies that the selection is within the extent of the dataspace.
+	bool selectValid () const;
+
+	// Selects a hyperslab region to add to the current selected region.
+	void selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hssize_t *start, const hsize_t *stride = NULL, const hsize_t *block = NULL ) const;
+
+	// Default constructor
+	DataSpace();
+
+	// Create a dataspace object from a dataspace identifier
+	DataSpace( const hid_t space_id );
+
+	// Copy constructor
+	DataSpace( const DataSpace& original );
+
+	virtual ~DataSpace();
+// end of class DataSpace
+
+
+// HDF5 datatype can be an atom datatype, a compound datatype, or an 
+// enumeration datatype.  A datatype is itself a kind of HDF5 object.
+//
+// Class DataType provides accesses to a generic HDF5 datatype.  It has 
+// characteristics which AtomType, CompType, and EnumType inherit.  It also 
+// inherits from H5Object and passes down the services to its subclasses.
+class DataType : public H5Object
+
+	// Creates a datatype given its class and size.
+	DataType( const H5T_class_t type_class, size_t size );
+
+	// Copies an existing datatype to this datatype instance.
+	void copy( const DataType& like_type );
+
+	// Returns the datatype class identifier of this datatype. 
+	H5T_class_t getClass() const;
+
+	// Commits a transient datatype to a file; this datatype becomes 
+	// a named datatype which can be accessed from the location.
+	void commit( H5Object& loc, const string& name ) const;
+	void commit( H5Object& loc, const char* name ) const;
+
+	// Determines whether this datatype is a named datatype or 
+	// a transient datatype. 
+	bool committed() const;
+
+        // Finds a conversion function that can handle the conversion 
+        // of this datatype to the given datatype, dest.
+	H5T_conv_t find( const DataType& dest, H5T_cdata_t **pcdata ) const;
+
+	// Converts data from this datatype into the specified datatype, dest. 
+	void convert( const DataType& dest, size_t nelmts, void *buf, void *background, PropList& plist ) const;
+
+	// Sets the overflow handler to a specified function. 
+	void setOverflow(H5T_overflow_t func) const;
+
+	// Returns a pointer to the current global overflow function. 
+	H5T_overflow_t getOverflow(void) const;
+
+	// Locks a datatype. 
+	void lock() const;
+
+	// Returns the size of this datatype. 
+	size_t getSize() const;
+
+	// Returns the base datatype from which a datatype is derived. 
+	// Not implemented yet
+	DataType getSuper() const;
+
+	// Registers a conversion function. 
+	void registerFunc(H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
+	void registerFunc(H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
+
+	// Removes a conversion function from all conversion paths. 
+	void unregister( H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
+	void unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
+
+	// Tags an opaque datatype. 
+	void setTag( const string& tag ) const;
+	void setTag( const char* tag ) const;
+
+	// Gets the tag associated with an opaque datatype. 
+	string getTag() const;
+
+	// Creates a DataType using an existing id - this datatype is
+	// not a predefined type
+	DataType( const hid_t type_id, bool predtype = false );
+
+	// Default constructor
+	DataType();
+
+	// Copy constructor
+	DataType( const DataType& original );
+
+	virtual ~DataType();
+
+// end of class DataType
+
+
+// Class DSetCreatPropList provides accesses to a dataset creation 
+// property list.
+class DSetCreatPropList : public PropList
+
+	// Default DSetCreatPropList object
+	static const DSetCreatPropList DEFAULT;
+
+	// Copies a dataset creation property list using assignment statement.
+	DSetCreatPropList& operator=( const DSetCreatPropList& rhs );
+
+	// Sets the type of storage used to store the raw data for the 
+	// dataset that uses this property list.
+	void setLayout( hid_t plist, H5D_layout_t layout ) const;
+
+	// Gets the layout of the raw data storage of the data that uses this
+	// property list.
+	H5D_layout_t getLayout() const;
+
+	// Sets the size of the chunks used to store a chunked layout dataset.
+	void setChunk( int ndims, const hsize_t* dim ) const;
+
+	// Retrieves the size of the chunks used to store a chunked layout dataset.
+	int getChunk( int max_ndims, hsize_t* dim ) const;
+
+	// Sets compression method and compression level
+	void setDeflate( int level ) const;
+
+	// Sets a dataset fill value.
+	void setFillValue( DataType& fvalue_type, const void* value ) const;
+
+	// Retrieves a dataset fill value.
+	void getFillValue( DataType& fvalue_type, void* value ) const;
+
+	// Adds a filter to the filter pipeline
+	void setFilter( H5Z_filter_t filter, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const;
+
+	// Returns the number of filters in the pipeline. 
+	int getNfilters() const;
+
+	// Returns information about a filter in a pipeline.
+	H5Z_filter_t getFilter( int filter_number, unsigned int& flags, size_t& cd_nelmts, unsigned int* cd_values, size_t namelen, char name[] ) const;
+
+	// Adds an external file to the list of external files.
+	void setExternal( const char* name, off_t offset, hsize_t size ) const;
+
+	// Returns the number of external files for a dataset. 
+	int getExternalCount() const;
+
+	// Returns information about an external file
+	void getExternal( int idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const;
+
+	// Creates a copy of an existing dataset creation property list 
+	// using the property list id
+	DSetCreatPropList( const hid_t plist_id );
+
+	// Default constructor
+	DSetCreatPropList();
+
+	// Copy constructor
+	DSetCreatPropList( const DSetCreatPropList& original );
+
+	virtual ~DSetCreatPropList();
+
+// end of class DSetCreatPropList
+
+
+// Class DSetMemXferPropList provides accesses to a dataset memory and 
+// transfer property list.
+class DSetMemXferPropList : public PropList
+
+	// Default object for dataset memory and transfer property list
+	static const DSetMemXferPropList DEFAULT;
+
+	// Copies a dataset memory and transfer property list using 
+	// assignment statement
+	DSetMemXferPropList& operator=( const DSetMemXferPropList& rhs );
+
+	// Sets type conversion and background buffers
+	void setBuffer( size_t size, void* tconv, void* bkg ) const;
+
+	// Reads buffer settings
+	size_t getBuffer( void** tconv, void** bkg ) const;
+
+	// Sets the dataset transfer property list status to TRUE or FALSE
+	void setPreserve( bool status ) const;
+
+	// Checks status of the dataset transfer property list
+	bool getPreserve() const;
+
+	// Indicates whether to cache hyperslab blocks during I/O
+	void setHyperCache( bool cache, unsigned limit = 0 ) const;
+
+	// Returns information regarding the caching of hyperslab blocks during I/O
+	void getHyperCache( bool& cache, unsigned& limit ) const;
+
+	// Sets B-tree split ratios for a dataset transfer property list 
+	void setBtreeRatios( double left, double middle, double right ) const;
+
+	// Gets B-tree split ratios for a dataset transfer property list
+	void getBtreeRatios( double& left, double& middle, double& right ) const;
+
+	// Sets the memory manager for variable-length datatype 
+	// allocation in H5Dread and H5Dvlen_reclaim
+	void setVlenMemManager( H5MM_allocate_t alloc, void* alloc_info, 
+				H5MM_free_t free, void* free_info ) const;
+
+	// alloc and free are set to NULL, indicating that system 
+	// malloc and free are to be used
+	void setVlenMemManager() const;
+
+	// Gets the memory manager for variable-length datatype 
+	// allocation in H5Dread and H5Tvlen_reclaim
+	void getVlenMemManager( H5MM_allocate_t& alloc, void** alloc_info, 
+				H5MM_free_t& free, void** free_info ) const;
+
+	// Sets the transfer mode - parallel mode, not currently supported
+	//void setXfer( H5D_transfer_t data_xfer_mode = H5D_XFER_INDEPENDENT ) const;
+
+	// Gets the transfer mode - parallel mode, not currently supported
+	//H5D_transfer_t getXfer() const;
+
+	// Creates a copy of an existing dataset memory and transfer 
+	// property list using the property list id
+	DSetMemXferPropList (const hid_t plist_id)
+
+	// Default constructor
+	DSetMemXferPropList();
+
+	// Copy constructor
+	DSetMemXferPropList( const DSetMemXferPropList& original );
+
+	// Default destructor
+	virtual ~DSetMemXferPropList();
+
+// end of class DSetMemXferPropList
+
+
+class EnumType : public DataType
+
+	// Creates an empty enumeration datatype based on a native signed 
+	// integer type, whose size is given by size.
+	EnumType( size_t size );
+
+	// Gets the enum datatype of the specified dataset
+	EnumType( const DataSet& dataset );  // H5Dget_type
+
+	// Creates a new enum datatype based on an integer datatype
+	EnumType( const IntType& data_type );  // H5Tenum_create
+
+	// Inserts a new member to this enumeration type. 
+	void insert( const string& name, void *value ) const;
+	void insert( const char* name, void *value ) const;
+
+	// Returns the symbol name corresponding to a specified member 
+	// of this enumeration datatype. 
+	string nameOf( void *value, size_t size ) const;
+
+	// Returns the value corresponding to a specified member of this 
+	// enumeration datatype. 
+	void valueOf( const string& name, void *value ) const;
+	void valueOf( const char* name, void *value ) const;
+
+	// Returns the value of an enumeration datatype member
+	void getMemberValue( int memb_no, void *value ) const;
+
+	// Default constructor
+	EnumType();
+
+	// Creates an enumeration datatype using an existing id
+	EnumType( const hid_t existing_id );
+
+	// Copy constructor
+	EnumType( const EnumType& original );
+
+	virtual ~EnumType();
+// end of class EnumType
+
+
+class Exception
+
+	// Creates an exception with a detailed message
+	Exception( const string& message );
+
+	Exception( const char* message);
+
+	// Returns the character string that describes an error specified by
+	// a major error number.
+	string getMajorString( H5E_major_t major_num ) const;
+
+	// Returns the character string that describes an error specified by
+	// a minor error number.
+	string getMinorString( H5E_minor_t minor_num ) const;
+
+	// Returns the detailed message set at the time the exception is thrown
+	string getDetailMesg() const;
+
+	// Turns on the automatic error printing.
+	void setAutoPrint( H5E_auto_t func, 
+				void* client_data ) const;
+
+	// Turns off the automatic error printing.
+	static void dontPrint();
+
+	// Retrieves the current settings for the automatic error stack 
+	// traversal function and its data.
+	void getAutoPrint( H5E_auto_t& func, 
+				void** client_data ) const;
+
+	// Clears the error stack for the current thread.
+	void clearErrorStack() const;
+
+	// Walks the error stack for the current thread, calling the 
+	// specified function.
+	void walkErrorStack( H5E_direction_t direction, 
+				H5E_walk_t func, void* client_data ) const;
+
+	// Default error stack traversal callback function that prints 
+	// error messages to the specified output stream.
+	void walkDefErrorStack( int n, H5E_error_t& err_desc,
+				void* client_data ) const;
+
+	// Prints the error stack in a default manner.
+	//void printError() const;
+	void printError( FILE* stream = NULL ) const;
+
+	// Creates an exception with no message
+	Exception();
+
+	// copy constructor
+	Exception( const Exception& original );
+
+// end of class Exception
+
+
+// Class FileIException inherits from Exception to provide exception 
+// handling for H5File.
+class FileIException : public Exception
+	FileIException();
+	FileIException( string message );
+// end of class FileIException
+
+
+// Class GroupIException inherits from Exception to provide exception 
+// handling for Group.
+class GroupIException : public Exception
+	GroupIException();
+	GroupIException( string message );
+// end of class GroupIException
+
+
+// Class DataSpaceIException inherits from Exception to provide exception 
+// handling for DataSpace.
+class DataSpaceIException : public Exception
+	DataSpaceIException();
+	DataSpaceIException( string message );
+// end of class DataSpaceIException
+
+
+// Class DataTypeIException inherits from Exception to provide exception 
+// handling for DataType.
+class DataTypeIException : public Exception
+	DataTypeIException();
+	DataTypeIException( string message );
+// end of class DataTypeIException
+
+
+// Class PropListIException inherits from Exception to provide exception 
+// handling for PropList.
+class PropListIException : public Exception
+	PropListIException();
+	PropListIException( string message );
+// end of class PropListIException
+
+
+// Class DataSetIException inherits from Exception to provide exception 
+// handling for DataSet.
+class DataSetIException : public Exception
+	DataSetIException();
+	DataSetIException( string message );
+// end of class DataSetIException
+
+
+// Class AttributeIException inherits from Exception to provide exception 
+// handling for Attribute.
+class AttributeIException : public Exception
+	AttributeIException();
+	AttributeIException( string message );
+// end of class AttributeIException
+
+
+// Class LibraryIException inherits from Exception to provide exception 
+// handling for H5Library.
+class LibraryIException : public Exception
+	LibraryIException();
+	LibraryIException( string message );
+// end of class LibraryIException
+
+
+// Class IdComponentException inherits from Exception to provide exception 
+// handling for IdComponent.
+class IdComponentException : public Exception
+	IdComponentException();
+	IdComponentException( string message );
+// end of class IdComponentException
+
+
+// Class FileAccPropList provides accesses to a file access property list.
+class FileAccPropList : public PropList
+
+	// Default file access property list object 
+	static const FileAccPropList DEFAULT;
+
+	// Copies a file access property list using assignment statement.
+	FileAccPropList& operator=( const FileAccPropList& rhs );
+
+	// Sets alignment properties of this file access property list.
+	void setAlignment( hsize_t threshold = 1, hsize_t alignment = 1 ) const;
+
+	// Retrieves the current settings for alignment properties from
+	// this file access property list.
+	void getAlignment( hsize_t& threshold, hsize_t& alignment ) const;
+
+	// Sets the meta data cache and raw data chunk cache parameters.
+	void setCache( int mdc_nelmts, int rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const;
+
+	// Retrieves maximum sizes of data caches and the preemption 
+	// policy value.
+	void getCache( int& mdc_nelmts, int& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const;
+
+	// Sets garbage collecting references flag.
+	void setGcReferences( unsigned gc_ref = 0 ) const;
+
+	// Returns garbage collecting references setting.
+	unsigned getGcReferences() const;
+
+	// Creates a copy of an existing file access property list
+	// using the property list id.
+	FileAccPropList (const hid_t plist_id);
+
+	// Default constructor
+	FileAccPropList();
+
+	// Copy constructor
+	FileAccPropList( const FileAccPropList& original );
+
+	// Default destructor
+	virtual ~FileAccPropList();
+
+// end of class FileAccPropList
+
+
+// Class FileCreatPropList provides accesses to a file creation property list.
+class FileCreatPropList : public PropList
+
+	// Default file creation property list object
+	static const FileCreatPropList DEFAULT;
+	
+	// Copies a file creation property list using assignment statement.
+	FileCreatPropList& operator=( const FileCreatPropList& rhs );
+
+	// Retrieves version information for various parts of a file.
+	void getVersion( int& boot, int& freelist, int& stab, int& shhdr ) const;
+
+	// Sets the userblock size field of a file creation property list.
+	void setUserblock( hsize_t size ) const;
+
+	// Gets the size of a user block in this file creation property list.
+	hsize_t getUserblock() const;
+
+	// Sets file size-of addresses and sizes.
+	void setSizes( size_t sizeof_addr = 4, size_t sizeof_size = 4 ) const;
+
+	// Retrieves the size-of address and size quantities stored in a 
+	// file according to this file creation property list.
+	void getSizes( size_t& sizeof_addr, size_t& sizeof_size ) const;
+
+	// Sets the size of parameters used to control the symbol table nodes.
+	void setSymk( int int_nodes_k, int leaf_nodes_k ) const;
+
+	// Retrieves the size of the symbol table B-tree 1/2 rank and the
+	// symbol table leaf node 1/2 size.
+	void getSymk( int& int_nodes_k, int& leaf_nodes_k ) const;
+
+	// Sets the size of parameter used to control the B-trees for
+	// indexing chunked datasets.
+	void setIstorek( int ik ) const;
+
+	// Returns the 1/2 rank of an indexed storage B-tree.
+	int getIstorek() const;
+
+	// Creates a copy of an existing file create property list
+	// using the property list id.
+	FileCreatPropList (const hid_t plist_id);
+
+	// Default constructor
+	FileCreatPropList();
+
+	// Copy constructor
+	FileCreatPropList( const FileCreatPropList& original );
+
+	// Default destructor
+	virtual ~FileCreatPropList();
+
+// end of class FileCreatPropList
+
+// Class H5File provides accesses to an HDF5 file.  It uses the services
+// provided by CommonFG beside inheriting the HDF5 id management from the
+// IdComponent class.
+class H5File : public IdComponent, public CommonFG
+
+	// Creates or opens an HDF5 file.  The file creation and access 
+	// property lists can be default.
+	H5File( const string& name, unsigned int flags, const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT, const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
+	H5File( const char* name, unsigned int flags, const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT, const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
+
+	// Throw file exception - used by CommonFG to specifically throw
+	// FileIException.
+	virtual void throwException() const;
+
+	// Determines if a file, specified by its name, is in HDF5 format.
+	static bool isHdf5(const string& name );
+	static bool isHdf5(const char* name );
+
+	// Reopens this file.
+	void reopen();
+
+	// Gets the creation property list of this file.
+	FileCreatPropList getCreatePlist() const;
+
+	// Gets the access property list of this file.
+	FileAccPropList getAccessPlist() const;
+
+	// Copy constructor
+	H5File(const H5File& original );
+
+	virtual ~H5File();
+
+// end of class H5File
+
+
+// Class FloatType inherits from AtomType and provides accesses to a 
+// floating-point datatype.
+class FloatType : public AtomType
+
+        // Creates a floating-point type using a predefined type.
+        FloatType( const PredType& pred_type );
+
+	// Gets the floating-point datatype of the specified dataset.
+	FloatType( const DataSet& dataset );
+
+	// Retrieves floating point datatype bit field information. 
+	void getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mpos, size_t& msize ) const;
+
+	// Sets locations and sizes of floating point bit fields. 
+	void setFields( size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize ) const;
+
+	// Retrieves the exponent bias of a floating-point type. 
+	size_t getEbias() const;
+
+	// Sets the exponent bias of a floating-point type. 
+	void setEbias( size_t ebias ) const;
+
+	// Retrieves mantissa normalization of a floating-point datatype. 
+	H5T_norm_t getNorm( string& norm_string ) const;
+
+	// Sets the mantissa normalization of a floating-point datatype. 
+	void setNorm( H5T_norm_t norm ) const;
+
+	// Retrieves the internal padding type for unused bits in 
+	// floating-point datatypes. 
+	H5T_pad_t getInpad( string& pad_string ) const;
+	
+	// Fills unused internal floating point bits. 
+	void setInpad( H5T_pad_t inpad ) const;
+
+	// Default constructor
+	FloatType();
+
+	// Creates a floating-point datatype using an existing id.
+	FloatType( const hid_t existing_id );
+
+	// Copy constructor
+	FloatType( const FloatType& original );
+
+	virtual ~FloatType();
+
+// end of class FloatType
+
+
+// Class Group provides accesses to an HDF5 group.  As H5File, it uses the 
+// services provided by CommonFG.  This class also inherits from H5Object.
+class Group : public H5Object, public CommonFG
+   public:
+
+        // Throw group exception - used by CommonFG to specifically throw
+	// GroupIException.
+        virtual void throwException() const;
+
+	// Default constructor
+	Group();
+
+	// Copy constructor
+	Group( const Group& original );
+
+	virtual ~Group();
+
+// end of class Group
+
+// Class IdComponent provides a mechanism to handle reference counting 
+// for an identifier of any HDF5 object.
+class IdComponent
+	// Sets the identifier of this object to a new value.
+	void setId( hid_t new_id );
+
+	// Creates an object to hold an HDF5 identifier.
+	IdComponent( const hid_t h5_id );
+
+	// Gets the value of the current HDF5 object id which is held
+	// by this IdComponent object.
+	hid_t getId () const;
+
+	// Increment reference counter.
+	void incRefCount();
+
+	// Decrement reference counter.
+	void decRefCount();
+
+	// Get the reference counter to this identifier.
+	int getCounter();
+
+	// Decrements the reference counter then determines if there are 
+	// no more reference to this object.
+	bool noReference();
+
+	// Reset this object by deleting its reference counter of the old id.
+	void reset();
+
+	// Copy constructor
+	IdComponent( const IdComponent& original );
+
+	// Destructor
+	virtual ~IdComponent();
+
+}; // end class IdComponent
+
+
+// Class IntType inherits from AtomType and provides accesses to 
+// integer datatypes.
+class IntType : public AtomType
+
+	// Creates a integer type using a predefined type.
+	IntType( const PredType& pred_type );
+
+	// Gets the integer datatype of the specified dataset.
+	IntType( const DataSet& dataset );
+
+	// Retrieves the sign type for an integer type.
+	H5T_sign_t getSign() const;
+
+	// Sets the sign proprety for an integer type. 
+	void setSign( H5T_sign_t sign ) const;
+
+	// Default constructor
+	IntType();
+
+	// Creates a integer datatype using an existing id.
+	IntType( const hid_t existing_id );
+
+	// Copy constructor
+	IntType( const IntType& original );
+
+	virtual ~IntType();
+
+// end of class IntType
+
+
+// Class H5Library provides accesses to the HDF5 library.  All of its
+// member functions are static.
+class H5Library
+
+	// Initializes the HDF5 library. 
+	static void open(); 
+
+	// Flushes all data to disk, closes files, and cleans up memory. 
+	static void close(); 
+
+	// Instructs library not to install atexit cleanup routine
+	static void dontAtExit(); 
+
+	// Returns the HDF library release number. 
+	static void getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum ); 
+
+	// Verifies that the arguments match the version numbers compiled
+	// into the library
+	static void checkVersion( unsigned majnum, unsigned minnum, unsigned relnum ); 
+
+// end of class H5Library
+
+
+// An HDF5 object can be a group, dataset, attribute, or named datatype.
+//
+// Class H5Object provides the services that are typical to an HDF5 object
+// so Group, DataSet, Attribute, and DataType can use them.  It also 
+// inherits the HDF5 id management from the class IdComponent.
+class H5Object : public IdComponent
+
+	// Flushes all buffers associated with this HDF5 object to disk.
+	void flush( H5F_scope_t scope ) const;
+
+	// Creates an attribute for a group, dataset, or named datatype.
+	// PropList is currently not used, it should always be default.
+	Attribute createAttribute( const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
+	Attribute createAttribute( const string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
+
+	// Opens an attribute that belongs to this object, given the 
+	// attribute name.
+	Attribute openAttribute( const string& name ) const;
+	Attribute openAttribute( const char* name ) const;
+
+	// Opens an attribute that belongs to this object, given the
+	// attribute index.
+	Attribute openAttribute( const unsigned int idx ) const;
+
+	// Iterate user's function over the attributes of this HDF5 object
+	int iterateAttrs( attr_operator_t user_op, unsigned* idx = NULL, void* op_data = NULL );
+
+	// Determines the number of attributes attached to this HDF5 object.
+	int getNumAttrs() const;
+
+	// Removes an attribute from this HDF5 object, given the attribute 
+	// name.
+	void removeAttr( const string& name ) const;
+	void removeAttr( const char* name ) const;
+
+	// Copy constructor
+	H5Object( const H5Object& original );
+
+	virtual ~H5Object();
+
+// end of class H5Object
+
+
+// Class PredType contains all the predefined datatype objects that are
+// currently available.
+class PredType : public AtomType
+
+	static const PredType STD_I8BE;
+	static const PredType STD_I8LE;
+	static const PredType STD_I16BE;
+	static const PredType STD_I16LE;
+	static const PredType STD_I32BE;
+	static const PredType STD_I32LE;
+	static const PredType STD_I64BE;
+	static const PredType STD_I64LE;
+	static const PredType STD_U8BE;
+	static const PredType STD_U8LE;
+	static const PredType STD_U16BE;
+	static const PredType STD_U16LE;
+	static const PredType STD_U32BE;
+	static const PredType STD_U32LE;
+	static const PredType STD_U64BE;
+	static const PredType STD_U64LE;
+	static const PredType STD_B8BE;
+	static const PredType STD_B8LE;
+	static const PredType STD_B16BE;
+	static const PredType STD_B16LE;
+	static const PredType STD_B32BE;
+	static const PredType STD_B32LE;
+	static const PredType STD_B64BE;
+	static const PredType STD_B64LE;
+	static const PredType STD_REF_OBJ;
+	static const PredType STD_REF_DSETREG;
+
+	static const PredType C_S1;
+	static const PredType FORTRAN_S1;
+
+	static const PredType IEEE_F32BE;
+	static const PredType IEEE_F32LE;
+	static const PredType IEEE_F64BE;
+	static const PredType IEEE_F64LE;
+
+	static const PredType UNIX_D32BE;
+	static const PredType UNIX_D32LE;
+	static const PredType UNIX_D64BE;
+	static const PredType UNIX_D64LE;
+
+	static const PredType INTEL_I8;
+	static const PredType INTEL_I16;
+	static const PredType INTEL_I32;
+	static const PredType INTEL_I64;
+	static const PredType INTEL_U8;
+	static const PredType INTEL_U16;
+	static const PredType INTEL_U32;
+	static const PredType INTEL_U64;
+	static const PredType INTEL_B8;
+	static const PredType INTEL_B16;
+	static const PredType INTEL_B32;
+	static const PredType INTEL_B64;
+	static const PredType INTEL_F32;
+	static const PredType INTEL_F64;
+
+	static const PredType ALPHA_I8;
+	static const PredType ALPHA_I16;
+	static const PredType ALPHA_I32;
+	static const PredType ALPHA_I64;
+	static const PredType ALPHA_U8;
+	static const PredType ALPHA_U16;
+	static const PredType ALPHA_U32;
+	static const PredType ALPHA_U64;
+	static const PredType ALPHA_B8;
+	static const PredType ALPHA_B16;
+	static const PredType ALPHA_B32;
+	static const PredType ALPHA_B64;
+	static const PredType ALPHA_F32;
+	static const PredType ALPHA_F64;
+
+	static const PredType MIPS_I8;
+	static const PredType MIPS_I16;
+	static const PredType MIPS_I32;
+	static const PredType MIPS_I64;
+	static const PredType MIPS_U8;
+	static const PredType MIPS_U16;
+	static const PredType MIPS_U32;
+	static const PredType MIPS_U64;
+	static const PredType MIPS_B8;
+	static const PredType MIPS_B16;
+	static const PredType MIPS_B32;
+	static const PredType MIPS_B64;
+	static const PredType MIPS_F32;
+	static const PredType MIPS_F64;
+
+	static const PredType NATIVE_CHAR;
+	static const PredType NATIVE_SCHAR;
+	static const PredType NATIVE_UCHAR;
+	static const PredType NATIVE_SHORT;
+	static const PredType NATIVE_USHORT;
+	static const PredType NATIVE_INT;
+	static const PredType NATIVE_UINT;
+	static const PredType NATIVE_LONG;
+	static const PredType NATIVE_ULONG;
+	static const PredType NATIVE_LLONG;
+	static const PredType NATIVE_ULLONG;
+	static const PredType NATIVE_FLOAT;
+	static const PredType NATIVE_DOUBLE;
+	static const PredType NATIVE_LDOUBLE;
+	static const PredType NATIVE_B8;
+	static const PredType NATIVE_B16;
+	static const PredType NATIVE_B32;
+	static const PredType NATIVE_B64;
+	static const PredType NATIVE_OPAQUE;
+	static const PredType NATIVE_HSIZE;
+	static const PredType NATIVE_HSSIZE;
+	static const PredType NATIVE_HERR;
+	static const PredType NATIVE_HBOOL;
+
+	static const PredType NATIVE_INT8;
+	static const PredType NATIVE_UINT8;
+	static const PredType NATIVE_INT_LEAST8;
+	static const PredType NATIVE_UINT_LEAST8;
+	static const PredType NATIVE_INT_FAST8;
+	static const PredType NATIVE_UINT_FAST8;
+
+	static const PredType NATIVE_INT16;
+	static const PredType NATIVE_UINT16;
+	static const PredType NATIVE_INT_LEAST16;
+	static const PredType NATIVE_UINT_LEAST16;
+	static const PredType NATIVE_INT_FAST16;
+	static const PredType NATIVE_UINT_FAST16;
+
+	static const PredType NATIVE_INT32;
+	static const PredType NATIVE_UINT32;
+	static const PredType NATIVE_INT_LEAST32;
+	static const PredType NATIVE_UINT_LEAST32;
+	static const PredType NATIVE_INT_FAST32;
+	static const PredType NATIVE_UINT_FAST32;
+
+	static const PredType NATIVE_INT64;
+	static const PredType NATIVE_UINT64;
+	static const PredType NATIVE_INT_LEAST64;
+	static const PredType NATIVE_UINT_LEAST64;
+	static const PredType NATIVE_INT_FAST64;
+	static const PredType NATIVE_UINT_FAST64;
+
+	// Copy constructor
+	PredType( const PredType& original );
+
+	// Default destructor
+	virtual ~PredType();
+
+   protected:
+	// Default constructor
+	PredType();
+
+	// Creates a pre-defined type using an HDF5 pre-defined constant
+	PredType( const hid_t predtype_id );  // used by the library only
+
+// end of class PredType
+
+
+// An HDF5 property list can be a file creation property list, a file
+// access property list, a dataset creation property list, or a dataset
+// memory and transfer property list.  
+//
+// Class PropList provides accesses to an HDF5 property list.  Its
+// services are inherited by classes FileCreatPropList, FileAccPropList,
+// DSetCreatPropList, and DSetMemXferPropList.  It also inherits the HDF5
+// id management from the class IdComponent.
+class PropList : public IdComponent
+
+	// Default property list object
+        static const PropList DEFAULT;
+
+	// Creates a property list given the property list type.
+	PropList( H5P_class_t type );
+
+	// Makes a copy of the given property list.
+	void copy( const PropList& like_plist );
+
+	// Gets the class of this property list, i.e. H5P_FILE_CREATE,
+	// H5P_FILE_ACCESS, ...
+	H5P_class_t getClass() const;
+
+	// Default constructor
+	PropList();
+
+	// Copy constructor
+	PropList( const PropList& original );
+
+	// Creates a default property list or creates a copy of an 
+	// existing property list giving the property list id
+	PropList( const hid_t plist_id );
+
+	virtual ~PropList();
+
+// end of class PropList
+
+// Class RefCounter provides a reference counting mechanism.  It is used
+// mainly by IdComponent to keep track of the references to an HDF5 object 
+// identifier.
+class RefCounter
+
+	// Returns the value of the counter.
+        int getCounter () const;
+
+	// Increments and decrements the counter.
+        void increment();
+        void decrement();
+
+	// This bool function is used to determine whether to close an
+	// HDF5 object when there are no more reference to that object.
+	// It decrements the counter, then returns true if there are no
+	// other object references the associated identifier.  When the
+	// function returns true, the associated identifier can be closed
+	// safely.
+	bool noReference();
+
+	// Default constructor
+	RefCounter();
+
+	~RefCounter();
+
+// end of class RefCounter
+
+
+// Class StrType inherits from AtomType and provides accesses to a 
+// string datatype.
+class StrType : public AtomType
+   public:
+	// Creates a string type using a predefined type.
+	StrType( const PredType& pred_type );
+
+        // Gets the string datatype of the specified dataset.
+	StrType( const DataSet& dataset );
+
+	// Returns the character set type of this string datatype. 
+	H5T_cset_t getCset() const;
+
+	// Sets character set to be used. 
+	void setCset( H5T_cset_t cset ) const;
+
+	// Returns the string padding method for this string datatype. 
+	H5T_str_t getStrpad() const;
+
+	// Defines the storage mechanism for character strings. 
+	void setStrpad( H5T_str_t strpad ) const;
+
+	// Default constructor 
+	StrType();
+
+	// Copy constructor
+	StrType( const StrType& original );
+
+	// Creates a string datatype using an existing id.
+	StrType( const hid_t existing_id );
+
+	virtual ~StrType();
+// end of class StrType
+
+
+// This template function, resetIdComponent, is used to reset an 
+// IdComponent object, which includes closing the associated HDF5 
+// identifier if it has no other references.
+// 'Type' can be of the following classes: Attribute, DataSet, DataSpace,
+// DataType, H5File, Group, and PropList.
+template 
+void resetIdComponent( 
+	Type* obj )	// pointer to object to be reset
+
+
+ +
+ +
+Last modified: 17 December 2000
+Describes HDF5 Release 1.4 Beta, December 2000 
+
+ + + + diff --git a/doc/html/cpplus/CppUserNotes.doc b/doc/html/cpplus/CppUserNotes.doc new file mode 100644 index 0000000..c14d3d6 Binary files /dev/null and b/doc/html/cpplus/CppUserNotes.doc differ diff --git a/doc/html/cpplus/CppUserNotes.pdf b/doc/html/cpplus/CppUserNotes.pdf new file mode 100644 index 0000000..7d0064f Binary files /dev/null and b/doc/html/cpplus/CppUserNotes.pdf differ -- cgit v0.12