diff --git a/examples/hdfgroup/H5D/CMakeLists.txt b/examples/hdfgroup/H5D/CMakeLists.txt
index c764c493ea..a99a1a557c 100644
--- a/examples/hdfgroup/H5D/CMakeLists.txt
+++ b/examples/hdfgroup/H5D/CMakeLists.txt
@@ -12,4 +12,19 @@ add_executable(h5ex_d_compact h5ex_d_compact.cpp)
 target_link_libraries(h5ex_d_compact h5cpp)
 
 add_executable(h5ex_d_fillval h5ex_d_fillval.cpp)
-target_link_libraries(h5ex_d_fillval h5cpp)
\ No newline at end of file
+target_link_libraries(h5ex_d_fillval h5cpp)
+
+add_executable(h5ex_d_hyper h5ex_d_hyper.cpp)
+target_link_libraries(h5ex_d_hyper h5cpp)
+
+add_executable(h5ex_d_rdwr h5ex_d_rdwr.cpp)
+target_link_libraries(h5ex_d_rdwr h5cpp)
+
+add_executable(h5ex_d_shuffle h5ex_d_shuffle.cpp)
+target_link_libraries(h5ex_d_shuffle h5cpp)
+
+add_executable(h5ex_d_transform h5ex_d_transform.cpp)
+target_link_libraries(h5ex_d_transform h5cpp)
+
+add_executable(h5ex_d_unlimadd h5ex_d_unlimadd.cpp)
+target_link_libraries(h5ex_d_unlimadd h5cpp)
\ No newline at end of file
diff --git a/examples/hdfgroup/H5D/h5ex_d_gzip.cpp b/examples/hdfgroup/H5D/h5ex_d_gzip.cpp
new file mode 100644
index 0000000000..c9f579fafb
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_gzip.cpp
@@ -0,0 +1,181 @@
+/************************************************************
+
+  This example shows how to read and write data to a dataset
+  using gzip compression (also called zlib or deflate).  The
+  program first checks if gzip compression is available,
+  then if it is it writes integers to a dataset using gzip,
+  then closes the file.  Next, it reopens the file, reads
+  back the data, and outputs the type of compression and the
+  maximum value in the dataset to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include "hdf5.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#define FILE            "h5ex_d_gzip.h5"
+#define DATASET         "DS1"
+#define DIM0            32
+#define DIM1            64
+#define CHUNK0          4
+#define CHUNK1          8
+
+int
+main (void)
+{
+    hid_t           file, space, dset, dcpl;    /* Handles */
+    herr_t          status;
+    htri_t          avail;
+    H5Z_filter_t    filter_type;
+    hsize_t         dims[2] = {DIM0, DIM1},
+                    chunk[2] = {CHUNK0, CHUNK1};
+    size_t          nelmts;
+    unsigned int    flags,
+                    filter_info;
+    int             wdata[DIM0][DIM1],          /* Write buffer */
+                    rdata[DIM0][DIM1],          /* Read buffer */
+                    max,
+                    i, j;
+
+    /*
+     * Check if gzip compression is available and can be used for both
+     * compression and decompression.  Normally we do not perform error
+     * checking in these examples for the sake of clarity, but in this
+     * case we will make an exception because this filter is an
+     * optional part of the hdf5 library.
+     */
+    avail = H5Zfilter_avail(H5Z_FILTER_DEFLATE);
+    if (!avail) {
+        printf ("gzip filter not available.\n");
+        return 1;
+    }
+    status = H5Zget_filter_info (H5Z_FILTER_DEFLATE, &filter_info);
+    if ( !(filter_info & H5Z_FILTER_CONFIG_ENCODE_ENABLED) ||
+                !(filter_info & H5Z_FILTER_CONFIG_DECODE_ENABLED) ) {
+        printf ("gzip filter not available for encoding and decoding.\n");
+        return 1;
+    }
+
+    /*
+     * Initialize data.
+     */
+    for (i=0; i<DIM0; i++)
+        for (j=0; j<DIM1; j++)
+            wdata[i][j] = i * j - j;
+
+    /*
+     * Create a new file using the default properties.
+     */
+    file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+    /*
+     * Create dataspace.  Setting maximum size to NULL sets the maximum
+     * size to be the current size.
+     */
+    space = H5Screate_simple (2, dims, NULL);
+
+    /*
+     * Create the dataset creation property list, add the gzip
+     * compression filter and set the chunk size.
+     */
+    dcpl = H5Pcreate (H5P_DATASET_CREATE);
+    status = H5Pset_deflate (dcpl, 9);
+    status = H5Pset_chunk (dcpl, 2, chunk);
+
+    /*
+     * Create the dataset.
+     */
+    dset = H5Dcreate (file, DATASET, H5T_STD_I32LE, space, H5P_DEFAULT, dcpl,
+                H5P_DEFAULT);
+
+    /*
+     * Write the data to the dataset.
+     */
+    status = H5Dwrite (dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
+                wdata[0]);
+
+    /*
+     * Close and release resources.
+     */
+    status = H5Pclose (dcpl);
+    status = H5Dclose (dset);
+    status = H5Sclose (space);
+    status = H5Fclose (file);
+
+
+    /*
+     * Now we begin the read section of this example.
+     */
+
+    /*
+     * Open file and dataset using the default properties.
+     */
+    file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
+    dset = H5Dopen (file, DATASET, H5P_DEFAULT);
+
+    /*
+     * Retrieve dataset creation property list.
+     */
+    dcpl = H5Dget_create_plist (dset);
+
+    /*
+     * Retrieve and print the filter type.  Here we only retrieve the
+     * first filter because we know that we only added one filter.
+     */
+    nelmts = 0;
+    filter_type = H5Pget_filter (dcpl, 0, &flags, &nelmts, NULL, 0, NULL,
+                &filter_info);
+    printf ("Filter type is: ");
+    switch (filter_type) {
+        case H5Z_FILTER_DEFLATE:
+            printf ("H5Z_FILTER_DEFLATE\n");
+            break;
+        case H5Z_FILTER_SHUFFLE:
+            printf ("H5Z_FILTER_SHUFFLE\n");
+            break;
+        case H5Z_FILTER_FLETCHER32:
+            printf ("H5Z_FILTER_FLETCHER32\n");
+            break;
+        case H5Z_FILTER_SZIP:
+            printf ("H5Z_FILTER_SZIP\n");
+            break;
+        case H5Z_FILTER_NBIT:
+            printf ("H5Z_FILTER_NBIT\n");
+            break;
+        case H5Z_FILTER_SCALEOFFSET:
+            printf ("H5Z_FILTER_SCALEOFFSET\n");
+    }
+
+    /*
+     * Read the data using the default properties.
+     */
+    status = H5Dread (dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
+                rdata[0]);
+
+    /*
+     * Find the maximum value in the dataset, to verify that it was
+     * read correctly.
+     */
+    max = rdata[0][0];
+    for (i=0; i<DIM0; i++)
+        for (j=0; j<DIM1; j++)
+            if (max < rdata[i][j])
+                max = rdata[i][j];
+
+    /*
+     * Print the maximum value.
+     */
+    printf ("Maximum value in %s is: %d\n", DATASET, max);
+
+    /*
+     * Close and release resources.
+     */
+    status = H5Pclose (dcpl);
+    status = H5Dclose (dset);
+    status = H5Fclose (file);
+
+    return 0;
+}
diff --git a/examples/hdfgroup/H5D/h5ex_d_hyper.cpp b/examples/hdfgroup/H5D/h5ex_d_hyper.cpp
new file mode 100644
index 0000000000..3e65464818
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_hyper.cpp
@@ -0,0 +1,113 @@
+/************************************************************
+
+  This example shows how to read and write data to a
+  dataset by hyberslabs.  The program first writes integers
+  in a hyperslab selection to a dataset with dataspace
+  dimensions of DIM0xDIM1, then closes the file.  Next, it
+  reopens the file, reads back the data, and outputs it to
+  the screen.  Finally it reads the data again using a
+  different hyperslab selection, and outputs the result to
+  the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+#include <algorithm>
+
+#define FILE            "h5ex_d_hyper.h5"
+#define DATASET         "DS1"
+#define DIM0            6
+#define DIM1            8
+
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+using namespace hdf5;
+
+void write ()
+{
+  Int32Matrix wdata;
+  std::fill (wdata.begin (), wdata.end (), 1);
+
+  // Print the data to the screen.
+  std::cout << "Original Data:" << std::endl;
+  std::cout << wdata << std::endl;
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple space ({ DIM0, DIM1 });
+
+  // Create the dataset.  We will use all default properties for this
+  // example.
+  node::Dataset dset (file.root (), DATASET, datatype::create<int32_t> (),
+                      space);
+
+  // Define and select the first part of the hyperslab selection.
+  dataspace::Hyperslab hyperslab1 (  { 0, 0 },  //offset
+                                     { 2, 2 },  //block
+                                     { 2, 3 },  //count
+                                     { 3, 3 }); //stride
+
+  // Define and select the second part of the hyperslab selection.
+  dataspace::Hyperslab hyperslab2 (  { 0, 0 },  //offset
+                                     { 1, 1 },  //block
+                                     { 2, 3 },  //count
+                                     { 3, 3 }); //stride
+
+  //apply the hyperslabs to the dataspace
+  space.selection (dataspace::SelectionOperation::SET, hyperslab1);
+  space.selection (dataspace::SelectionOperation::NOTB, hyperslab2);
+
+
+  //Write the data to the dataset.
+  dset.write (wdata, datatype::create (wdata), space,
+              space);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open(FILE,file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+
+  std::cout<<"Data as written to disk by hyberslabs:"<<std::endl;
+  std::cout<<rdata<<std::endl;
+
+  // Initialize the read array.
+  std::fill(rdata.begin(),rdata.end(),0);
+
+  // Define and select the hyperslab to use for reading.
+  dataspace::Dataspace space = dset.dataspace();
+  dataspace::Hyperslab hyperslab( {0,1},   // offset
+                                  {2,3},   // block
+                                  {2,2},   // count
+                                  {4,4});  // stride
+  space.selection(dataspace::SelectionOperation::SET,hyperslab);
+
+  // Read the data using the previously defined hyperslab.
+  dset.read(rdata,datatype::create(rdata),space,space);
+
+  // Output the data to the screen.
+  std::cout<<"Data as read from disk by hyperslab:"<<std::endl;
+  std::cout<<rdata<<std::endl;
+}
+
+int
+main (void)
+{
+  write();
+  read();
+
+  return 0;
+}
diff --git a/examples/hdfgroup/H5D/h5ex_d_rdwr.cpp b/examples/hdfgroup/H5D/h5ex_d_rdwr.cpp
new file mode 100644
index 0000000000..9ce9a88595
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_rdwr.cpp
@@ -0,0 +1,75 @@
+/************************************************************
+
+  This example shows how to read and write data to a
+  dataset.  The program first writes integers to a dataset
+  with dataspace dimensions of DIM0xDIM1, then closes the
+  file.  Next, it reopens the file, reads back the data, and
+  outputs it to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+
+#define FILE            "h5ex_d_rdwr.h5"
+#define DATASET         "DS1"
+#define DIM0            4
+#define DIM1            7
+
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+using namespace hdf5;
+
+void write()
+{
+  Int32Matrix wdata;
+
+  // Initialize data.
+  for (int32_t i = 0; i < DIM0; i++)
+    for (int32_t j = 0; j < DIM1; j++)
+      wdata (i, j) = i * j - j;
+
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple space ({ DIM0, DIM1 });
+
+
+  // Create the dataset.  We will use all default properties for this
+  // example.
+  std::cout<<"Data to write:"<<std::endl;
+  std::cout<<wdata<<std::endl;
+  node::Dataset dset (file.root(), DATASET, datatype::create (wdata), space);
+
+
+  // Write the data to the dataset.
+  dset.write(wdata);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE, file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+  std::cout<<DATASET<<std::endl;
+  std::cout<<rdata<<std::endl;
+}
+
+int
+main (void)
+{
+  write();
+  read();
+
+  return 0;
+}
diff --git a/examples/hdfgroup/H5D/h5ex_d_shuffle.cpp b/examples/hdfgroup/H5D/h5ex_d_shuffle.cpp
new file mode 100644
index 0000000000..bafac8b2a5
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_shuffle.cpp
@@ -0,0 +1,132 @@
+/************************************************************
+
+  This example shows how to read and write data to a dataset
+  using the shuffle filter with gzip compression.  The
+  program first checks if the shuffle and gzip filters are
+  available, then if they are it writes integers to a
+  dataset using shuffle+gzip, then closes the file.  Next,
+  it reopens the file, reads back the data, and outputs the
+  types of filters and the maximum value in the dataset to
+  the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+#include <algorithm>
+
+#define FILE            "h5ex_d_shuffle.h5"
+#define DATASET         "DS1"
+#define DIM0            32
+#define DIM1            64
+#define CHUNK0          4
+#define CHUNK1          8
+
+using namespace hdf5;
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+
+void write()
+{
+  filter::Shuffle shuffle_filter;
+  filter::Deflate deflate_filter;
+  deflate_filter.level(9);
+
+  Int32Matrix wdata;
+  // Initialize data.
+  for (size_t i=0; i<DIM0; i++)
+    for (size_t j=0; j<DIM1; j++)
+        wdata(i,j) = i * j - j;
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple space ({ DIM0, DIM1 });
+
+  // Create the dataset creation property list, add the shuffle
+  // filter and the gzip compression filter and set the chunk size.
+  // The order in which the filters are added here is significant -
+  // we will see much greater results when the shuffle is applied
+  // first.  The order in which the filters are added to the property
+  // list is the order in which they will be invoked when writing
+  // data.
+  property::LinkCreationList lcpl;
+  property::DatasetCreationList dcpl;
+  shuffle_filter (dcpl);
+  deflate_filter (dcpl);
+  dcpl.layout (property::DatasetLayout::CHUNKED);
+  dcpl.chunk ({ CHUNK0, CHUNK1 });
+
+  // Create the dataset.
+  node::Dataset dset (file.root (), DATASET, datatype::create<int32_t> (),
+                      space, lcpl, dcpl);
+
+  // Write the data to the dataset.
+  dset.write (wdata);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE,file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Retrieve dataset creation property list
+  property::DatasetCreationList dcpl = dset.creation_list();
+
+  // Retrieve the number of filters, and retrieve and print the
+  // type of each.
+  unsigned int flags,filter_info;
+  int nfilters = H5Pget_nfilters (static_cast<hid_t>(dcpl));
+  for (int i=0; i<nfilters; i++) {
+    size_t nelmts = 0;
+    int filter_type = H5Pget_filter (static_cast<hid_t>(dcpl), i, &flags, &nelmts, NULL, 0, NULL,
+                                 &filter_info);
+    std::cout<< "Filter "<<i<<": Type is: ";
+    switch (filter_type)
+      {
+      case H5Z_FILTER_DEFLATE: std::cout<<"H5Z_FILTER_DEFLATE"<<std::endl;
+        break;
+      case H5Z_FILTER_SHUFFLE: std::cout<<"H5Z_FILTER_SHUFFLE"<<std::endl;
+        break;
+      case H5Z_FILTER_FLETCHER32: std::cout<<"H5Z_FILTER_FLETCHER32"<<std::endl;
+        break;
+      case H5Z_FILTER_SZIP: std::cout<<"H5Z_FILTER_SZIP"<<std::endl;
+        break;
+      case H5Z_FILTER_NBIT: std::cout<<"H5Z_FILTER_NBIT"<<std::endl;
+        break;
+      case H5Z_FILTER_SCALEOFFSET: std::cout<<"H5Z_FILTER_SCALEOFFSET"<<std::endl;
+      }
+  }
+
+  /*
+   * Read the data using the default properties.
+   */
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  /*
+   * Find the maximum value in the dataset, to verify that it was
+   * read correctly.
+   */
+  int32_t max_value = *std::max_element(rdata.begin(),rdata.end());
+
+  /*
+   * Print the maximum value.
+   */
+  std::cout<<"Maximum value in "<<DATASET<<" is: "<<max_value<<std::endl;
+  std::cout<<rdata<<std::endl;
+
+
+}
+
+int main (void)
+{
+  write();
+  read();
+  return 0;
+}
diff --git a/examples/hdfgroup/H5D/h5ex_d_transform.cpp b/examples/hdfgroup/H5D/h5ex_d_transform.cpp
new file mode 100644
index 0000000000..6dcaccef30
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_transform.cpp
@@ -0,0 +1,101 @@
+/************************************************************
+
+  This example shows how to read and write data to a dataset
+  using a data transform expression.  The program first
+  writes integers to a dataset using the transform
+  expression TRANSFORM, then closes the file.  Next, it
+  reopens the file, reads back the data without a transform,
+  and outputs the data to the screen.  Finally it reads the
+  data using the transform expression RTRANSFORM and outputs
+  the results to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+
+#define FILE            "h5ex_d_transform.h5"
+#define DATASET         "DS1"
+#define DIM0            4
+#define DIM1            7
+#define TRANSFORM       "x+1"
+#define RTRANSFORM      "x-1"
+
+using namespace hdf5;
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+
+void write()
+{
+  // Initialize data.
+  Int32Matrix wdata;
+  for (int32_t i=0; i<DIM0; i++)
+      for (int32_t j=0; j<DIM1; j++)
+          wdata(i,j) = i * j - j;
+
+  // Output the data to the screen.
+  std::cout<<"Original Data:"<<std::endl<<wdata<<std::endl;
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE,file::AccessFlags::TRUNCATE);
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple memory_space({DIM0,DIM1});
+  datatype::Datatype memory_type = datatype::create<int32_t>();
+
+  // Create the dataset transfer property list and define the
+  // transform expression.
+  property::DatasetTransferList dxpl;
+  dxpl.data_transform(TRANSFORM);
+
+  // Create the dataset using the default properties.  Unfortunately
+  // we must save as a native type or the transform operation will
+  // fail.
+  node::Dataset dset(file.root(), DATASET, memory_type,memory_space);
+
+
+  // Write the data to the dataset using the dataset transfer
+  // property list.
+  dset.write(wdata,memory_type,memory_space,memory_space,dxpl);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE, file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+  std::cout<<std::endl<<"Data as written with transform \""<<TRANSFORM<<"\":"<<std::endl;
+  std::cout<<rdata<<std::endl;
+
+  // Create the dataset transfer property list and define the
+  // transform expression.
+  property::DatasetTransferList dxpl;
+  dxpl.data_transform(RTRANSFORM);
+
+  // Read the data using the dataset transfer property list.
+  dset.read(rdata,dset.datatype(),dset.dataspace(),dset.dataspace(),dxpl);
+
+  // Output the data to the screen.
+  std::cout<<std::endl<<"Data as written with transform \""<<TRANSFORM
+           <<"\" and read with transform \""<<RTRANSFORM<<"\":"<<std::endl;
+  std::cout<<rdata<<std::endl;
+}
+
+int
+main (void)
+{
+  write();
+  read();
+
+
+
+    return 0;
+}
diff --git a/examples/hdfgroup/H5D/h5ex_d_unlimadd.cpp b/examples/hdfgroup/H5D/h5ex_d_unlimadd.cpp
new file mode 100644
index 0000000000..9b26070aa9
--- /dev/null
+++ b/examples/hdfgroup/H5D/h5ex_d_unlimadd.cpp
@@ -0,0 +1,133 @@
+/************************************************************
+
+  This example shows how to create and extend an unlimited
+  dataset.  The program first writes integers to a dataset
+  with dataspace dimensions of DIM0xDIM1, then closes the
+  file.  Next, it reopens the file, reads back the data,
+  outputs it to the screen, extends the dataset, and writes
+  new data to the extended portions of the dataset.  Finally
+  it reopens the file again, reads back the data, and
+  outputs it to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+#include <vector>
+
+
+#define FILE            "h5ex_d_unlimadd.h5"
+#define DATASET         "DS1"
+#define DIM0            4
+#define DIM1            7
+#define EDIM0           6
+#define EDIM1           10
+#define CHUNK0          4
+#define CHUNK1          4
+
+using namespace hdf5;
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+using Int32MatrixExtended = Matrix<int32_t,EDIM0,EDIM1>;
+
+void write_initial_data()
+{
+  // Initialize data.
+  Int32Matrix wdata;
+  for (int32_t i=0; i<DIM0; i++)
+      for (int32_t j=0; j<DIM1; j++)
+          wdata(i,j) = i * j - j;
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+  // Create dataspace with unlimited dimensions.
+  dataspace::Simple space({DIM0,DIM1},
+                          {dataspace::Simple::UNLIMITED,
+                           dataspace::Simple::UNLIMITED});
+
+  // Create the dataset creation property list, and set the chunk size.
+  property::LinkCreationList lcpl;
+  property::DatasetCreationList dcpl;
+  dcpl.layout(property::DatasetLayout::CHUNKED);
+  dcpl.chunk({CHUNK0,CHUNK1});
+
+  // Create the unlimited dataset.
+  node::Dataset dset (file.root(), DATASET, datatype::create<int32_t>(), space,lcpl, dcpl);
+
+  // Write the data to the dataset.
+  dset.write(wdata);
+}
+
+void append_data()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE, file::AccessFlags::READWRITE);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Get dataspace and allocate memory for read buffer.  This is a
+  // two dimensional dataset so the dynamic allocation must be done
+  // in steps.
+  dataspace::Simple space = dset.dataspace();
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+  std::cout<<"Dataset before extension:"<<std::endl;
+  std::cout<<rdata<<std::endl;
+
+  // Extend the dataset.
+  dset.extent({EDIM0,EDIM1});
+
+  // Retrieve the dataspace for the newly extended dataset.
+  space = dset.dataspace();
+
+  /*
+   * Initialize data for writing to the extended dataset.
+   */
+  Int32MatrixExtended wextdata;
+  for (int32_t i=0; i<EDIM0; i++)
+      for (int32_t j=0; j<EDIM1; j++)
+          wextdata(i,j) = j;
+
+  // Subtract a hyperslab reflecting the original dimensions from the
+  // selection.  The selection now contains only the newly extended
+  // portions of the dataset.
+  dataspace::Hyperslab selection({0,0},{DIM0,DIM1});
+  space.selection(dataspace::SelectionOperation::NOTB,selection);
+
+  // Write the data to the selected portion of the dataset.
+  dset.write(wextdata,datatype::create(wextdata),space,space);
+
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE, file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Get dataspace and allocate memory for the read buffer as before.
+  Int32MatrixExtended rextdata;
+
+  // Read the data using the default properties.
+  dset.read(rextdata);
+
+  // Output the data to the screen.
+  std::cout<< "Dataset after extension:"<<std::endl;
+  std::cout<<rextdata<<std::endl;
+
+}
+
+int
+main (void)
+{
+  write_initial_data();
+  append_data();
+  read();
+
+  return 0;
+}