Remove boost::tokenizer

Replace with std::stringstream implementation put for convenience
in XdmfStringUtils.hpp. Added a test as well.

XdmfAggregate.cpp

@@ -23,7 +23,6 @@
 
 #include <numeric>
 #include <functional>
-#include <boost/tokenizer.hpp>
 #include "XdmfArray.hpp"
 #include "XdmfError.hpp"
 #include "XdmfAggregate.hpp"

XdmfGeometry.cpp

@@ -21,11 +21,11 @@
 /*                                                                           */
 /*****************************************************************************/
 
-#include "XdmfGeometry.hpp"
-#include "XdmfGeometryType.hpp"
 #include "XdmfError.hpp"
 #include "XdmfFunction.hpp"
-#include <boost/tokenizer.hpp>
+#include "XdmfGeometry.hpp"
+#include "XdmfGeometryType.hpp"
+#include "XdmfStringUtils.hpp"
 
 shared_ptr<XdmfGeometry> XdmfGeometry::New()
 {
@@ -188,12 +188,7 @@ XdmfGeometry::populateItem(const std::map<std::string, std::string> & itemProper
   std::map<std::string, std::string>::const_iterator origin =
     itemProperties.find("Origin");
   if (origin != itemProperties.end()) {
-    boost::tokenizer<> tokens(origin->second);
-    for(boost::tokenizer<>::const_iterator iter = tokens.begin();
-        iter != tokens.end();
-        ++iter) {
-      mOrigin.push_back(atof((*iter).c_str()));
-    }
+    XdmfStringUtils::split(origin->second, mOrigin);
   }
 }
 

XdmfGridTemplate.cpp

@@ -42,8 +42,6 @@
 
 #include "XdmfSystemUtils.hpp"
 
-#include <boost/tokenizer.hpp>
-
 #include <stdio.h>
 
 shared_ptr<XdmfGridTemplate>

XdmfItemFactory.cpp

@@ -22,7 +22,6 @@
 /*****************************************************************************/
 
 #include <cctype>
-#include <boost/tokenizer.hpp>
 #include "XdmfAttribute.hpp"
 #include "XdmfCurvilinearGrid.hpp"
 #include "XdmfDomain.hpp"
@@ -41,6 +40,7 @@
 #include "XdmfRegularGrid.hpp"
 #include "XdmfSet.hpp"
 #include "XdmfSparseMatrix.hpp"
+#include "XdmfStringUtils.hpp"
 #include "XdmfTemplate.hpp"
 #include "XdmfTime.hpp"
 #include "XdmfTopology.hpp"
@@ -277,12 +277,11 @@ XdmfItemFactory::createItem(const std::string & itemTag,
         if(dimensions != itemProperties.end()) {
           dimensionsString = dimensions->second;
         }
-        boost::tokenizer<> tokens(dimensionsString);
-        for(boost::tokenizer<>::const_iterator iter = tokens.begin();
-            iter != tokens.end();
-            ++iter) {
-          dimensionsArray->pushBack<unsigned int>(atoi((*iter).c_str()));
-        }
+	std::vector<unsigned int> dimensionsVector;
+	XdmfStringUtils::split(dimensionsString, dimensionsVector);
+	dimensionsArray->insert(0,
+				&(dimensionsVector[0]),
+				dimensionsVector.size());
         if(typeVal.compare("2DCORECTMESH") == 0 ||
            typeVal.compare("3DCORECTMESH") == 0 ||
            typeVal.compare("CORECTMESH") == 0) {

XdmfTemplate.cpp

@@ -26,20 +26,18 @@
 #include <climits>
 #include <set>
 #include "XdmfArray.hpp"
-#include "XdmfHDF5Controller.hpp"
 #include "XdmfBinaryController.hpp"
+#include "XdmfError.hpp"
+#include "XdmfHDF5Controller.hpp"
 #include "XdmfItem.hpp"
 #include "XdmfItemFactory.hpp"
 #include "XdmfReader.hpp"
 #include "XdmfTemplate.hpp"
-#include "XdmfError.hpp"
+#include "XdmfStringUtils.hpp"
+#include "XdmfSystemUtils.hpp"
 #include "XdmfVisitor.hpp"
 #include "XdmfWriter.hpp"
 
-#include "XdmfSystemUtils.hpp"
-
-#include <boost/tokenizer.hpp>
-
 #include <stdio.h>
 
 std::vector<shared_ptr<XdmfHeavyDataController> >
@@ -1102,33 +1100,26 @@ XdmfTemplate::setStep(unsigned int stepId)
             // Data is contained in the content
             std::string content = mDataDescriptions[i+(stepId*mTrackedArrays.size())];
 
-            mTrackedArrays[i]->initialize(mTrackedArrayTypes[i], mTrackedArrayDims[i]);
+            mTrackedArrays[i]->initialize(mTrackedArrayTypes[i], 
+					  mTrackedArrayDims[i]);
 
-            unsigned int index = 0;
-            boost::char_separator<char> sep(" \t\n");
-            boost::tokenizer<boost::char_separator<char> > valtokens(content, sep);
             if(mTrackedArrayTypes[i] == XdmfArrayType::String()) {
-              for(boost::tokenizer<boost::char_separator<char> >::const_iterator
-                    iter = valtokens.begin();
-                  iter != valtokens.end();
-                  ++iter, ++index) {
-                mTrackedArrays[i]->insert(index, *iter);
-              }
-            }
+	      std::vector<std::string> tokens;
+	      XdmfStringUtils::split(content, tokens);
+	      mTrackedArrays[i]->insert(0, &(tokens[0]), tokens.size());
+	    }
             else {
-              for(boost::tokenizer<boost::char_separator<char> >::const_iterator
-                    iter = valtokens.begin();
-                  iter != valtokens.end();
-                  ++iter, ++index) {
-                mTrackedArrays[i]->insert(index, atof((*iter).c_str()));
-              }
+	      std::vector<double> tokens;
+	      XdmfStringUtils::split(content, tokens);
+	      mTrackedArrays[i]->insert(0, &(tokens[0]), tokens.size());
             }
           }
         }
       }
     }
     else {
-      XdmfError::message(XdmfError::FATAL, "Error: Template attempting to load invalid step");
+      XdmfError::message(XdmfError::FATAL, 
+			 "Error: Template attempting to load invalid step");
     }
     mCurrentStep = stepId;
   }

core/XdmfArray.cpp

@@ -21,7 +21,6 @@
 /*                                                                           */
 /*****************************************************************************/
 
-#include <boost/tokenizer.hpp>
 #include <limits>
 #include <sstream>
 #include <utility>
@@ -33,11 +32,12 @@
 #include "XdmfArrayReference.hpp"
 #include "XdmfBinaryController.hpp"
 #include "XdmfCoreReader.hpp"
+#include "XdmfError.hpp"
 #include "XdmfFunction.hpp"
-#include "XdmfSubset.hpp"
 #include "XdmfHeavyDataController.hpp"
+#include "XdmfSubset.hpp"
+#include "XdmfStringUtils.hpp"
 #include "XdmfVisitor.hpp"
-#include "XdmfError.hpp"
 
 XDMF_CHILDREN_IMPLEMENTATION(XdmfArray,
                              XdmfHeavyDataController,
@@ -1092,20 +1092,17 @@ XdmfArray::populateItem(const std::map<std::string, std::string> & itemPropertie
 
       unsigned int i = 0;
 
-      while (i < dimArray->getSize() / 3)
-      {
+      while (i < dimArray->getSize() / 3) {
         start.push_back(dimArray->getValue<unsigned int>(i));
         ++i;
       }
 
-      while (i < 2 * (dimArray->getSize() / 3))
-      {
+      while (i < 2 * (dimArray->getSize() / 3)) {
         stride.push_back(dimArray->getValue<unsigned int>(i));
         ++i;
       }
 
-      while (i < dimArray->getSize())
-      {
+      while (i < dimArray->getSize()) {
         dimensions.push_back(dimArray->getValue<unsigned int>(i));
         ++i;
       }
@@ -1173,12 +1170,7 @@ XdmfArray::populateItem(const std::map<std::string, std::string> & itemPropertie
                          "XdmfArray::populateItem");
     }
    
-    boost::tokenizer<> tokens(dimensions->second);
-    for(boost::tokenizer<>::const_iterator iter = tokens.begin();
-        iter != tokens.end();
-        ++iter) {
-      mDimensions.push_back(atoi((*iter).c_str()));
-    }
+    XdmfStringUtils::split(dimensions->second, mDimensions);
 
     std::map<std::string, std::string>::const_iterator format =
       itemProperties.find("Format");
@@ -1193,26 +1185,17 @@ XdmfArray::populateItem(const std::map<std::string, std::string> & itemPropertie
       if(formatVal.compare("XML") == 0) {
         this->initialize(arrayType,
                          mDimensions);
-        unsigned int index = 0;
-        boost::char_separator<char> sep(" \t\n");
-        for (contentIndex = 0; contentIndex < contentVals.size(); ++contentIndex)
-        {
-          boost::tokenizer<boost::char_separator<char> > tokens(contentVals[contentIndex], sep);
+        for (contentIndex = 0; contentIndex < contentVals.size(); 
+	     ++contentIndex) {  
           if(arrayType == XdmfArrayType::String()) {
-            for(boost::tokenizer<boost::char_separator<char> >::const_iterator
-                  iter = tokens.begin();
-                iter != tokens.end();
-                ++iter, ++index) {
-              this->insert(index, *iter);
-            }
+	    std::vector<std::string> tokens;
+	    XdmfStringUtils::split(contentVals[contentIndex], tokens);
+	    this->insert(0, &(tokens[0]), tokens.size());
           }
           else {
-            for(boost::tokenizer<boost::char_separator<char> >::const_iterator
-                  iter = tokens.begin();
-                iter != tokens.end();
-                ++iter, ++index) {
-              this->insert(index, atof((*iter).c_str()));
-            }
+	    std::vector<double> tokens;
+	    XdmfStringUtils::split(contentVals[contentIndex], tokens);
+	    this->insert(0, &(tokens[0]), tokens.size());
           }
         }
       }

core/XdmfCoreItemFactory.cpp

@@ -21,6 +21,8 @@
 /*                                                                           */
 /*****************************************************************************/
 
+#include <cstdlib>
+#include <string.h>
 #include "XdmfArray.hpp"
 #include "XdmfBinaryController.hpp"
 #include "XdmfCoreItemFactory.hpp"
@@ -29,11 +31,8 @@
 #include "XdmfHDF5Controller.hpp"
 #include "XdmfHDF5Writer.hpp"
 #include "XdmfSubset.hpp"
+#include "XdmfStringUtils.hpp"
 #include "XdmfTIFFController.hpp"
-#include "XdmfInformation.hpp"
-#include "XdmfSparseMatrix.hpp"
-#include <boost/tokenizer.hpp>
-#include <string.h>
 
 std::string
 XdmfCoreItemFactory::getFullHeavyDataPath(const std::string & filePath,
@@ -174,6 +173,7 @@ XdmfCoreItemFactory::createItem(const std::string & itemTag,
     }
   }
   else if(itemTag.compare(XdmfSubset::ItemTag) == 0) {
+
     std::map<std::string, std::string>::const_iterator type =
       itemProperties.find("ConstructedType");
     std::string arraySubType;
@@ -188,48 +188,32 @@ XdmfCoreItemFactory::createItem(const std::string & itemTag,
     std::vector<shared_ptr<XdmfItem> > newArrayChildren;
     shared_ptr<XdmfArray> returnArray = shared_ptr<XdmfArray>();
 
-    returnArray = shared_dynamic_cast<XdmfArray>(createItem(
-                                                   arraySubType,
-                                                   itemProperties,
-                                                   newArrayChildren));
+    returnArray = 
+      shared_dynamic_cast<XdmfArray>(createItem(arraySubType,
+						itemProperties,
+						newArrayChildren));
 
     std::vector<unsigned int> startVector;
     std::vector<unsigned int> strideVector;
     std::vector<unsigned int> dimensionVector;
-    shared_ptr<XdmfArray> referenceArray;
 
+    std::string token;
+    
     std::map<std::string, std::string>::const_iterator starts =
       itemProperties.find("SubsetStarts");
-
-    boost::tokenizer<> tokens(starts->second);
-    for(boost::tokenizer<>::const_iterator iter = tokens.begin();
-        iter != tokens.end();
-        ++iter) {
-      startVector.push_back(atoi((*iter).c_str()));
-    }
+    XdmfStringUtils::split(starts->second, startVector);
 
     std::map<std::string, std::string>::const_iterator strides =
       itemProperties.find("SubsetStrides");
-
-    boost::tokenizer<> stridetokens(strides->second);
-    for(boost::tokenizer<>::const_iterator iter = stridetokens.begin();
-        iter != stridetokens.end();
-        ++iter) {
-      strideVector.push_back(atoi((*iter).c_str()));
-    }
+    XdmfStringUtils::split(strides->second, strideVector);
 
     std::map<std::string, std::string>::const_iterator dimensions =
       itemProperties.find("SubsetDimensions");
-
-    boost::tokenizer<> dimtokens(dimensions->second);
-    for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-        iter != dimtokens.end();
-        ++iter) {
-      dimensionVector.push_back(atoi((*iter).c_str()));
-    }
+    XdmfStringUtils::split(dimensions->second, dimensionVector);
 
     bool foundspacer = false;
 
+    shared_ptr<XdmfArray> referenceArray;
     for(std::vector<shared_ptr<XdmfItem> >::const_iterator iter =
           childItems.begin();
         iter != childItems.end();
@@ -245,14 +229,14 @@ XdmfCoreItemFactory::createItem(const std::string & itemTag,
       }
     }
 
-    shared_ptr<XdmfSubset> newSubset = XdmfSubset::New(referenceArray,
-                                                       startVector,
-                                                       strideVector,
-                                                       dimensionVector);
+    shared_ptr<XdmfSubset> newSubset = 
+      XdmfSubset::New(referenceArray,
+		      startVector,
+		      strideVector,
+		      dimensionVector);
 
     returnArray->setReference(newSubset);
     returnArray->setReadMode(XdmfArray::Reference);
-
     return returnArray;
 
   }
@@ -335,12 +319,8 @@ XdmfCoreItemFactory::generateHeavyDataControllers(const std::map<std::string, st
                          "XdmfCoreItemFactory");
     }
 
-    boost::tokenizer<> tokens(dimensions->second);
-    for(boost::tokenizer<>::const_iterator iter = tokens.begin();
-        iter != tokens.end();
-        ++iter) {
-      dimVector.push_back(atoi((*iter).c_str()));
-    }
+    XdmfStringUtils::split(dimensions->second, dimVector);
+  
   }
 
   shared_ptr<const XdmfArrayType> arrayType;
@@ -415,39 +395,18 @@ XdmfCoreItemFactory::generateHeavyDataControllers(const std::map<std::string, st
         }
 
         // split the description based on tokens
-        boost::tokenizer<> dimtokens(std::string(""));
         if (dataspaceVector.size() == 1) {
-          dimtokens = boost::tokenizer<>(dataspaceDescription);
+	  XdmfStringUtils::split(dataspaceDescription, contentDims);
         }
         else if (dataspaceVector.size() == 5) {
-          dimtokens = boost::tokenizer<>(dataspaceVector[3]);
-        }
-        for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-            iter != dimtokens.end();
-            ++iter) {
-          contentDims.push_back(atoi((*iter).c_str()));
+	  XdmfStringUtils::split(dataspaceVector[3], contentDims);
         }
 
         if (dataspaceVector.size() == 5) {
           seek = atoi(dataspaceVector[0].c_str());
-          dimtokens = boost::tokenizer<>(dataspaceVector[1]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStarts.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[2]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStrides.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[4]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentDataspaces.push_back(atoi((*iter).c_str()));
-          }
+	  XdmfStringUtils::split(dataspaceVector[1], contentStarts);
+	  XdmfStringUtils::split(dataspaceVector[2], contentStrides);
+	  XdmfStringUtils::split(dataspaceVector[4], contentDataspaces);
         }
 
         contentStep = 2;
@@ -529,38 +488,17 @@ XdmfCoreItemFactory::generateHeavyDataControllers(const std::map<std::string, st
         }
 
         // split the description based on tokens
-        boost::tokenizer<> dimtokens(std::string(""));
         if (dataspaceVector.size() == 1) {
-          dimtokens = boost::tokenizer<>(dataspaceDescription);
+	  XdmfStringUtils::split(dataspaceDescription, contentDims);
         }
         else if (dataspaceVector.size() == 4) {
-          dimtokens = boost::tokenizer<>(dataspaceVector[2]);
-        }
-        for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-            iter != dimtokens.end();
-            ++iter) {
-          contentDims.push_back(atoi((*iter).c_str()));
+	  XdmfStringUtils::split(dataspaceVector[2], contentDims);
         }
 
         if (dataspaceVector.size() == 4) {
-          dimtokens = boost::tokenizer<>(dataspaceVector[0]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStarts.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[1]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStrides.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[3]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentDataspaces.push_back(atoi((*iter).c_str()));
-          }
+	  XdmfStringUtils::split(dataspaceVector[0], contentStarts);
+	  XdmfStringUtils::split(dataspaceVector[1], contentStrides);
+	  XdmfStringUtils::split(dataspaceVector[3], contentDataspaces);
         }
 
         contentStep = 2;
@@ -635,38 +573,17 @@ XdmfCoreItemFactory::generateHeavyDataControllers(const std::map<std::string, st
         }
 
         // split the description based on tokens
-        boost::tokenizer<> dimtokens(std::string(""));
         if (dataspaceVector.size() == 1) {
-          dimtokens = boost::tokenizer<>(dataspaceDescription);
+          XdmfStringUtils::split(dataspaceDescription, contentDims);
         }
         else if (dataspaceVector.size() == 4) {
-          dimtokens = boost::tokenizer<>(dataspaceVector[2]);
-        }
-        for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-            iter != dimtokens.end();
-            ++iter) {
-          contentDims.push_back(atoi((*iter).c_str()));
+	  XdmfStringUtils::split(dataspaceVector[2], contentDims);
         }
 
         if (dataspaceVector.size() == 4) {
-          dimtokens = boost::tokenizer<>(dataspaceVector[0]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStarts.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[1]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentStrides.push_back(atoi((*iter).c_str()));
-          }
-          dimtokens = boost::tokenizer<>(dataspaceVector[3]);
-          for(boost::tokenizer<>::const_iterator iter = dimtokens.begin();
-              iter != dimtokens.end();
-              ++iter) {
-            contentDataspaces.push_back(atoi((*iter).c_str()));
-          }
+	  XdmfStringUtils::split(dataspaceVector[0], contentStarts);
+	  XdmfStringUtils::split(dataspaceVector[1], contentStrides);
+	  XdmfStringUtils::split(dataspaceVector[3], contentDataspaces);
         }
 
         contentStep = 2;

core/XdmfCoreReader.cpp

@@ -34,8 +34,6 @@
 #include "XdmfCoreItemFactory.hpp"
 #include "XdmfCoreReader.hpp"
 #include "XdmfError.hpp"
-#include "XdmfFunction.hpp"
-#include "XdmfSubset.hpp"
 #include "XdmfItem.hpp"
 #include "XdmfSystemUtils.hpp"
 

core/XdmfStringUtils.hpp

+/*****************************************************************************/
+/*                                    XDMF                                   */
+/*                       eXtensible Data Model and Format                    */
+/*                                                                           */
+/*  Id : XdmfStringUtils.hpp                                                 */
+/*                                                                           */
+/*  Author:                                                                  */
+/*     Kenneth Leiter                                                        */
+/*     kenneth.leiter@arl.army.mil                                           */
+/*     US Army Research Laboratory                                           */
+/*     Aberdeen Proving Ground, MD                                           */
+/*                                                                           */
+/*     Copyright @ 2011 US Army Research Laboratory                          */
+/*     All Rights Reserved                                                   */
+/*     See Copyright.txt for details                                         */
+/*                                                                           */
+/*     This software is distributed WITHOUT ANY WARRANTY; without            */
+/*     even the implied warranty of MERCHANTABILITY or FITNESS               */
+/*     FOR A PARTICULAR PURPOSE.  See the above copyright notice             */
+/*     for more information.                                                 */
+/*                                                                           */
+/*****************************************************************************/
+
+#ifndef XDMFSTRINGUTILS_HPP_
+#define XDMFSTRINGUTILS_HPP_
+
+#include "XdmfCore.hpp"
+
+#ifdef __cplusplus
+
+#include <algorithm>
+#include <iterator>
+#include <sstream>
+#include <vector>
+
+/**
+ * @brief String parsing utilities
+ *
+ * Collects all string parsing utilities used by Xdmf
+ */
+class XDMFCORE_EXPORT XdmfStringUtils {
+
+ public:
+
+  /**
+   * Split a string by whitespace and insert into container
+   *
+   * @param stringToSplit a string to split by spaces.
+   * @param containerToInsert a container to insert the split string into.
+   */
+  template <typename T>
+  static void split(const std::string & stringToSplit,
+		    std::vector<T> & containerToInsert);
+
+ protected:
+
+  XdmfStringUtils();
+  ~XdmfStringUtils();
+
+ private:
+
+  XdmfStringUtils(const XdmfStringUtils &);  // Not implemented.
+  void operator=(const XdmfStringUtils &);  // Not implemented.
+
+};
+
+template <typename T>
+void 
+XdmfStringUtils::split(const std::string & stringToSplit,
+		       std::vector<T> & containerToInsert)
+{
+  std::istringstream stream(stringToSplit);
+  std::copy(std::istream_iterator<T>(stream),
+	    std::istream_iterator<T>(),
+	    std::back_inserter(containerToInsert));
+}
+
+#endif
+
+#endif /* XDMFSTRINGUTILS_HPP_ */

core/XdmfSubset.cpp

@@ -23,7 +23,6 @@
 
 #include <numeric>
 #include <functional>
-#include <boost/tokenizer.hpp>
 #include "string.h"
 #include "XdmfArray.hpp"
 #include "XdmfError.hpp"
@@ -31,9 +30,9 @@
 #include "XdmfWriter.hpp"
 
 XdmfSubset::XdmfSubset(shared_ptr<XdmfArray> referenceArray,
-                       std::vector<unsigned int> & start,
-                       std::vector<unsigned int> & stride,
-                       std::vector<unsigned int> & dimensions) :
+                       const std::vector<unsigned int> & start,
+                       const std::vector<unsigned int> & stride,
+                       const std::vector<unsigned int> & dimensions) :
   mParent(referenceArray),
   mDimensions(dimensions),
   mStart(start),
@@ -55,11 +54,14 @@ const std::string XdmfSubset::ItemTag = "Subset";
 
 shared_ptr<XdmfSubset>
 XdmfSubset::New(shared_ptr<XdmfArray> referenceArray,
-                std::vector<unsigned int> & start,
-                std::vector<unsigned int> & stride,
-                std::vector<unsigned int> & dimensions)
+                const std::vector<unsigned int> & start,
+                const std::vector<unsigned int> & stride,
+                const std::vector<unsigned int> & dimensions)
 {
-  shared_ptr<XdmfSubset> p(new XdmfSubset(referenceArray, start, stride, dimensions));
+  shared_ptr<XdmfSubset> p(new XdmfSubset(referenceArray, 
+					  start, 
+					  stride, 
+					  dimensions));
   return p;
 }
 
@@ -88,36 +90,28 @@ XdmfSubset::getItemProperties() const
                        "one value contained within");
   }
 
-  std::map<std::string, std::string> subsetMap = XdmfArrayReference::getItemProperties();
+  std::map<std::string, std::string> subsetMap = 
+    XdmfArrayReference::getItemProperties();
 
   std::stringstream vectorStream;