ENH: Added new data types. Restructure of composite datasets....

ENH: Added new data types. Restructure of composite datasets. vtkMultiGroupDataSet is the new superclass with two subclasses: vtkMultiBlockDataSet and vtkHierarchicalDataSet

Filtering/CMakeLists.txt

@@ -66,9 +66,9 @@ vtkGeometricErrorMetric.cxx
 vtkAttributesErrorMetric.cxx
 vtkHexagonalPrism.cxx
 vtkHexahedron.cxx
-vtkHierarchicalBoxDataSet.cxx
 vtkHierarchicalDataInformation.cxx
 vtkHierarchicalDataIterator.cxx
+vtkHierarchicalBoxDataSet.cxx
 vtkHierarchicalDataSet.cxx
 vtkHierarchicalDataSetAlgorithm.cxx
 vtkHyperOctree.cxx
@@ -117,6 +117,12 @@ vtkLine.cxx
 vtkLocator.cxx
 vtkMapper2D.cxx
 vtkMergePoints.cxx
+vtkMultiBlockDataSet.cxx
+vtkMultiBlockDataSetAlgorithm.cxx
+vtkMultiGroupDataInformation.cxx
+vtkMultiGroupDataIterator.cxx
+vtkMultiGroupDataSet.cxx
+vtkMultiGroupDataSetAlgorithm.cxx
 vtkNonLinearCell.cxx
 vtkOrderedTriangulator.cxx
 vtkParametricSpline.cxx
@@ -252,6 +258,7 @@ vtkInformationStringKey
 vtkInformationUnsignedLongKey
 vtkLocator
 vtkMapper2D
+vtkMultiGroupDataSetAlgorithm
 vtkNonLinearCell
 vtkPointSet
 vtkPointSetSource

Filtering/Testing/CMakeLists.txt

@@ -24,8 +24,8 @@ IF(PYTHON_EXECUTABLE)
     vtkMarchingCubesCases.h
     vtkMarchingSquaresCases.h
     vtkMultiBlockDataSetInternal.h
+    vtkMultiGroupDataSetInternal.h
     vtkDataObjectCollection.h
-    vtkHierarchicalDataSetInternal.h
     vtkHierarchicalBoxDataSetInternal.h
     vtkStructuredPoints.h
     )

Filtering/vtkCompositeDataPipeline.cxx

@@ -16,8 +16,8 @@ PURPOSE.  See the above copyright notice for more information.
 
 #include "vtkAlgorithm.h"
 #include "vtkAlgorithmOutput.h"
-#include "vtkHierarchicalDataInformation.h"
-#include "vtkHierarchicalDataSet.h"
+#include "vtkMultiGroupDataInformation.h"
+#include "vtkMultiGroupDataSet.h"
 #include "vtkInformation.h"
 #include "vtkInformationDoubleKey.h"
 #include "vtkInformationIntegerKey.h"
@@ -35,7 +35,7 @@ PURPOSE.  See the above copyright notice for more information.
 #include "vtkStructuredGrid.h"
 #include "vtkUniformGrid.h"
 
-vtkCxxRevisionMacro(vtkCompositeDataPipeline, "1.28");
+vtkCxxRevisionMacro(vtkCompositeDataPipeline, "1.29");
 vtkStandardNewMacro(vtkCompositeDataPipeline);
 
 vtkInformationKeyMacro(vtkCompositeDataPipeline,BEGIN_LOOP,Integer);
@@ -415,7 +415,7 @@ int vtkCompositeDataPipeline::ExecuteDataObjectForBlock(vtkInformation* request)
           {
           vtkSmartPointer<vtkInformation> r = 
             vtkSmartPointer<vtkInformation>::New();
-          r->Set(vtkHierarchicalDataSet::LEVEL(), 0);
+          r->Set(vtkMultiGroupDataSet::GROUP(), 0);
           r->Set(vtkCompositeDataSet::INDEX(),    0);
           dobj = output->GetDataSet(r);
           }
@@ -562,8 +562,8 @@ int vtkCompositeDataPipeline::ExecuteData(vtkInformation* request,
         continue;
         }
 
-      vtkHierarchicalDataSet* updateInfo = 
-        vtkHierarchicalDataSet::SafeDownCast(
+      vtkMultiGroupDataSet* updateInfo = 
+        vtkMultiGroupDataSet::SafeDownCast(
           inInfo->Get(vtkCompositeDataPipeline::UPDATE_BLOCKS()));
 
       // Tell the producer upstream that looping is about to start
@@ -691,13 +691,13 @@ void vtkCompositeDataPipeline::CheckInputPorts(int& inputPortIsComposite,
 //----------------------------------------------------------------------------
 int vtkCompositeDataPipeline::UpdateBlocks(
   int i, int j, int outputPort, 
-  vtkHierarchicalDataSet* updateInfo, 
+  vtkMultiGroupDataSet* updateInfo, 
   vtkCompositeDataSet* input,
   vtkInformation* inInfo)
 {
   // Execute the streaming demand driven pipeline for each block
-  unsigned int numLevels = updateInfo->GetNumberOfLevels();
-  for (unsigned int k=0; k<numLevels; k++)
+  unsigned int numGroups = updateInfo->GetNumberOfGroups();
+  for (unsigned int k=0; k<numGroups; k++)
     {
     unsigned int numDataSets = updateInfo->GetNumberOfDataSets(k);
     for (unsigned l=0; l<numDataSets; l++)
@@ -710,7 +710,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
       // First pipeline mtime
               
       // Setup the request for pipeline modification time.
-      this->GenericRequest->Set(vtkHierarchicalDataSet::LEVEL(), k);
+      this->GenericRequest->Set(vtkMultiGroupDataSet::GROUP(), k);
       this->GenericRequest->Set(vtkCompositeDataSet::INDEX(), l);
       if(vtkExecutive* e = this->GetInputExecutive(i, j))
         {
@@ -721,7 +721,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
       // Do the data-object creation pass before the information pass.
               
       // Send the request for data object creation.
-      this->DataObjectRequest->Set(vtkHierarchicalDataSet::LEVEL(), k);
+      this->DataObjectRequest->Set(vtkMultiGroupDataSet::GROUP(), k);
       this->DataObjectRequest->Set(vtkCompositeDataSet::INDEX(), l);
       if (!this->ForwardUpstream(i, j, this->DataObjectRequest))
         {
@@ -730,7 +730,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
         }
               
       // Send the request for information.
-      this->InformationRequest->Set(vtkHierarchicalDataSet::LEVEL(), k);
+      this->InformationRequest->Set(vtkMultiGroupDataSet::GROUP(), k);
       this->InformationRequest->Set(vtkCompositeDataSet::INDEX(), l);
       if (!this->ForwardUpstream(i, j, this->InformationRequest))
         {
@@ -756,7 +756,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
         }
             
       // Send the request for update extent propagation.
-      this->UpdateExtentRequest->Set(vtkHierarchicalDataSet::LEVEL(), k);
+      this->UpdateExtentRequest->Set(vtkMultiGroupDataSet::GROUP(), k);
       this->UpdateExtentRequest->Set(vtkCompositeDataSet::INDEX(), l);
       this->UpdateExtentRequest->Set(
         vtkExecutive::FROM_OUTPUT_PORT(), outputPort);
@@ -767,7 +767,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
         }
             
       // Send the request for data.
-      this->DataRequest->Set(vtkHierarchicalDataSet::LEVEL(), k);
+      this->DataRequest->Set(vtkMultiGroupDataSet::GROUP(), k);
       this->DataRequest->Set(vtkCompositeDataSet::INDEX(), l);
       this->DataRequest->Set(FROM_OUTPUT_PORT(), outputPort);
               
@@ -793,7 +793,7 @@ int vtkCompositeDataPipeline::UpdateBlocks(
 
 //----------------------------------------------------------------------------
 int vtkCompositeDataPipeline::SendBeginLoop(
-  int i, int j, vtkInformation* inInfo, vtkHierarchicalDataSet* updateInfo)
+  int i, int j, vtkInformation* inInfo, vtkMultiGroupDataSet* updateInfo)
 {
 
   // Tell the producer upstream that looping is about to start
@@ -889,8 +889,8 @@ void vtkCompositeDataPipeline::ExecuteSimpleAlgorithm(
   vtkCompositeDataSet* input = vtkCompositeDataSet::SafeDownCast(
     inInfo->Get(vtkCompositeDataSet::COMPOSITE_DATA_SET()));
 
-  vtkHierarchicalDataSet* updateInfo = 
-    vtkHierarchicalDataSet::SafeDownCast(
+  vtkMultiGroupDataSet* updateInfo = 
+    vtkMultiGroupDataSet::SafeDownCast(
       inInfo->Get(vtkCompositeDataPipeline::UPDATE_BLOCKS()));
 
   vtkCompositeDataSet* output = 
@@ -911,7 +911,7 @@ void vtkCompositeDataPipeline::ExecuteSimpleAlgorithm(
     // Algorithms process this request after it is forwarded.
     r->Set(vtkExecutive::ALGORITHM_AFTER_FORWARD(), 1);
 
-    unsigned int numLevels = updateInfo->GetNumberOfLevels();
+    unsigned int numGroups = updateInfo->GetNumberOfGroups();
     vtkSmartPointer<vtkDataObject> prevInput = 
       inInfo->Get(vtkDataObject::DATA_OBJECT());
 
@@ -927,14 +927,14 @@ void vtkCompositeDataPipeline::ExecuteSimpleAlgorithm(
     // changes (because we pretend that the max. number of pieces is
     // one to process the whole block)
     this->PushInformation(inInfo);
-    for (unsigned int k=0; k<numLevels; k++)
+    for (unsigned int k=0; k<numGroups; k++)
       {
       unsigned int numDataSets = updateInfo->GetNumberOfDataSets(k);
       for (unsigned l=0; l<numDataSets; l++)
         {
         if (updateInfo->GetDataSet(k,l))
           {
-          r->Set(vtkHierarchicalDataSet::LEVEL(), k);
+          r->Set(vtkMultiGroupDataSet::GROUP(), k);
           r->Set(vtkCompositeDataSet::INDEX(),    l);
           vtkDataObject* dobj = input->GetDataSet(r);
           // There must be a bug somehwere. If this Remove()
@@ -1345,8 +1345,8 @@ vtkCompositeDataSet* vtkCompositeDataPipeline::CreateInputCompositeData(
     if (strcmp(dt, "vtkCompositeDataSet") == 0)
       {
       // If vtkCompositeDataSet is specified, the algorithm
-      // will work with all sub-classes. Create a vtkHierarchicalDataSet
-      dt = "vtkHierarchicalDataSet";
+      // will work with all sub-classes. Create a vtkMultiGroupDataSet
+      dt = "vtkMultiGroupDataSet";
       }
     // If the composite data input to the algorithm is not
     // set, create and assign it. This happens when the producer
@@ -1463,7 +1463,7 @@ int vtkCompositeDataPipeline::CheckCompositeData(
     vtkCompositeDataSet* output = vtkCompositeDataSet::SafeDownCast(doOutput);
     if (!output)
       {
-      output = vtkHierarchicalDataSet::New();
+      output = vtkMultiGroupDataSet::New();
       output->SetPipelineInformation(outInfo);
       output->Delete();
       }

Filtering/vtkCompositeDataPipeline.h

@@ -25,7 +25,7 @@
 //
 // * REQUEST_INFORMATION: The producers have to provide information about
 // the contents of the composite dataset in this pass. This is accomplished
-// by creating and populating a vtkHierarchicalDataInformation and setting
+// by creating and populating a vtkMultiGroupDataInformation and setting
 // it using the COMPOSITE_DATA_INFORMATION() key in the output information
 // vector. Sources that can produce more than one piece (note that a piece is
 // different than a block; each piece consistes of 0 or more blocks) should
@@ -60,9 +60,9 @@
 // Furthermore, if the vtkCompositeDataPipeline is assigned to a simple filter, 
 // it will invoke the  vtkStreamingDemandDrivenPipeline passes in a loop, 
 // passing a different block each time and will collect the results in a 
-// composite dataset (vtkHierarchicalDataSet).
+// composite dataset (vtkMultiGroupDataSet).
 // .SECTION See also
-//  vtkHierarchicalDataInformation vtkCompositeDataSet vtkHierarchicalDataSet
+//  vtkMultiGroupDataInformation vtkCompositeDataSet vtkMultiGroupDataSet
 
 #ifndef __vtkCompositeDataPipeline_h
 #define __vtkCompositeDataPipeline_h
@@ -70,7 +70,7 @@
 #include "vtkStreamingDemandDrivenPipeline.h"
 
 class vtkCompositeDataSet;
-class vtkHierarchicalDataSet;
+class vtkMultiGroupDataSet;
 class vtkInformationDoubleKey;
 class vtkInformationIntegerVectorKey;
 class vtkInformationObjectBaseKey;
@@ -188,11 +188,11 @@ protected:
   
   virtual int SendBeginLoop(int i, int j, 
                             vtkInformation* inInfo, 
-                            vtkHierarchicalDataSet* updateInfo);
+                            vtkMultiGroupDataSet* updateInfo);
   virtual vtkCompositeDataSet* CreateInputCompositeData(
     int i, vtkInformation* inInfo);
   virtual int UpdateBlocks(int i, int j, int outputPort, 
-                           vtkHierarchicalDataSet* updateInfo, 
+                           vtkMultiGroupDataSet* updateInfo, 
                            vtkCompositeDataSet* input,
                            vtkInformation* inInfo);
   virtual void ExecuteSimpleAlgorithm(vtkInformation* request,

Filtering/vtkCompositeDataSet.h

@@ -43,7 +43,7 @@ public:
   virtual vtkCompositeDataIterator* NewIterator() = 0;
 
   // Description:
-  // Return class name of data type (see vtkSystemIncludes.h for
+  // Return class name of data type (see vtkType.h for
   // definitions).
   virtual int GetDataObjectType() {return VTK_COMPOSITE_DATA_SET;}
 

Filtering/vtkDemandDrivenPipeline.cxx

@@ -21,6 +21,8 @@
 #include "vtkDataObject.h"
 #include "vtkDataSet.h"
 #include "vtkGarbageCollector.h"
+#include "vtkMultiBlockDataSet.h"
+#include "vtkMultiGroupDataSet.h"
 #include "vtkHierarchicalBoxDataSet.h"
 #include "vtkHierarchicalDataSet.h"
 #include "vtkInformation.h"
@@ -43,7 +45,7 @@
 
 #include <vtkstd/vector>
 
-vtkCxxRevisionMacro(vtkDemandDrivenPipeline, "1.39");
+vtkCxxRevisionMacro(vtkDemandDrivenPipeline, "1.40");
 vtkStandardNewMacro(vtkDemandDrivenPipeline);
 
 vtkInformationKeyMacro(vtkDemandDrivenPipeline, DATA_NOT_GENERATED, Integer);
@@ -976,6 +978,14 @@ vtkDataObject* vtkDemandDrivenPipeline::NewDataObject(const char* type)
     {
     return vtkUnstructuredGrid::New();
     }
+  else if(strcmp(type, "vtkMultiGroupDataSet") == 0)
+    {
+    return vtkMultiGroupDataSet::New();
+    }
+  else if(strcmp(type, "vtkMultiBlockDataSet") == 0)
+    {
+    return vtkMultiBlockDataSet::New();
+    }
   else if(strcmp(type, "vtkHierarchicalDataSet") == 0)
     {
     return vtkHierarchicalDataSet::New();

Filtering/vtkHierarchicalBoxDataSet.cxx

@@ -16,7 +16,7 @@
 
 #include "vtkHierarchicalBoxDataSetInternal.h"
 
-#include "vtkHierarchicalDataInformation.h"
+#include "vtkMultiGroupDataInformation.h"
 #include "vtkInformation.h"
 #include "vtkInformationIdTypeKey.h"
 #include "vtkInformationIntegerVectorKey.h"
@@ -25,7 +25,7 @@
 #include "vtkUniformGrid.h"
 #include "vtkUnsignedCharArray.h"
 
-vtkCxxRevisionMacro(vtkHierarchicalBoxDataSet, "1.10");
+vtkCxxRevisionMacro(vtkHierarchicalBoxDataSet, "1.11");
 vtkStandardNewMacro(vtkHierarchicalBoxDataSet);
 
 vtkInformationKeyMacro(vtkHierarchicalBoxDataSet,BOX,IntegerVector);
@@ -50,7 +50,7 @@ void vtkHierarchicalBoxDataSet::SetDataSet(
   this->Superclass::SetDataSet(level, id, dataSet);
 
   vtkInformation* info = 
-    this->HierarchicalDataInformation->GetInformation(level, id);
+    this->MultiGroupDataInformation->GetInformation(level, id);
   if (info)
     {
     info->Set(BOX(), 
@@ -69,7 +69,7 @@ vtkUniformGrid* vtkHierarchicalBoxDataSet::GetDataSet(unsigned int level,
     return 0;
     }
 
-  vtkHierarchicalDataSetInternal::LevelDataSetsType& ldataSets = 
+  vtkMultiGroupDataSetInternal::GroupDataSetsType& ldataSets = 
     this->Internal->DataSets[level];
   if (ldataSets.size() <= id)
     {
@@ -82,7 +82,7 @@ vtkUniformGrid* vtkHierarchicalBoxDataSet::GetDataSet(unsigned int level,
     }
 
   vtkInformation* info = 
-    this->HierarchicalDataInformation->GetInformation(level, id);
+    this->MultiGroupDataInformation->GetInformation(level, id);
   if (info)
     {
     int* boxVec = info->Get(BOX());
@@ -134,7 +134,7 @@ int vtkHierarchicalBoxDataSetIsInBoxes(vtkstd::vector<vtkAMRBox>& boxes,
 //----------------------------------------------------------------------------
 void vtkHierarchicalBoxDataSet::GenerateVisibilityArrays()
 {
-  if (!this->HierarchicalDataInformation)
+  if (!this->MultiGroupDataInformation)
     {
     vtkErrorMacro("No information about data layout is specified. "
                   "Cannot generate visibility arrays");
@@ -153,13 +153,13 @@ void vtkHierarchicalBoxDataSet::GenerateVisibilityArrays()
       {
       for (dataSetIdx=0; dataSetIdx<numDataSets; dataSetIdx++)
         {
-        if (!this->HierarchicalDataInformation->HasInformation(
+        if (!this->MultiGroupDataInformation->HasInformation(
               levelIdx+1, dataSetIdx))
           {
           continue;
           }
         vtkInformation* info = 
-          this->HierarchicalDataInformation->GetInformation(
+          this->MultiGroupDataInformation->GetInformation(
             levelIdx+1,dataSetIdx);
         int* boxVec = info->Get(BOX());
         vtkAMRBox coarsebox(3, boxVec, boxVec+3);
@@ -215,11 +215,11 @@ void vtkHierarchicalBoxDataSet::GenerateVisibilityArrays()
           }
         grid->SetCellVisibilityArray(vis);
         vis->Delete();
-        if (this->HierarchicalDataInformation->HasInformation(
+        if (this->MultiGroupDataInformation->HasInformation(
               levelIdx, dataSetIdx))
           {
           vtkInformation* infotmp = 
-            this->HierarchicalDataInformation->GetInformation(
+            this->MultiGroupDataInformation->GetInformation(
               levelIdx,dataSetIdx);
           infotmp->Set(NUMBER_OF_BLANKED_POINTS(), numBlankedPts);
           }
@@ -241,7 +241,7 @@ vtkIdType vtkHierarchicalBoxDataSet::GetNumberOfPoints()
       {
       vtkIdType numBlankedPts = 0;
       vtkInformation* blockInfo = 
-        this->HierarchicalDataInformation->GetInformation(level, dataIdx);
+        this->MultiGroupDataInformation->GetInformation(level, dataIdx);
       if (blockInfo)
         {
         if (blockInfo->Has(

Filtering/vtkHierarchicalBoxDataSet.h

@@ -41,7 +41,7 @@ public:
   void PrintSelf(ostream& os, vtkIndent indent);
 
   // Description:
-  // Return class name of data type (see vtkSystemIncludes.h for
+  // Return class name of data type (see vtkType.h for
   // definitions).
   virtual int GetDataObjectType() {return VTK_HIERARCHICAL_BOX_DATA_SET;}
 

Filtering/vtkHierarchicalBoxDataSetInternal.h

@@ -16,7 +16,7 @@
 #ifndef __vtkHierarchicalBoxDataSetInternal_h
 #define __vtkHierarchicalBoxDataSetInternal_h
 
-#include "vtkHierarchicalDataSetInternal.h"
+#include "vtkMultiGroupDataSetInternal.h"
 #include "vtkAMRBox.h"
 
 struct vtkHierarchicalBoxDataSetInternal

Filtering/vtkHierarchicalDataInformation.cxx

@@ -15,164 +15,19 @@
 #include "vtkHierarchicalDataInformation.h"
 
 #include "vtkHierarchicalDataInformation.h"
-#include "vtkInformation.h"
 #include "vtkObjectFactory.h"
-#include "vtkSmartPointer.h"
 
-vtkCxxRevisionMacro(vtkHierarchicalDataInformation, "1.3");
+vtkCxxRevisionMacro(vtkHierarchicalDataInformation, "1.4");
 vtkStandardNewMacro(vtkHierarchicalDataInformation);
 
-#include <vtkstd/vector>
-
-struct vtkHierarchicalDataInformationInternal
-{
-  typedef vtkstd::vector<vtkSmartPointer<vtkInformation> > LevelInformationType;
-  typedef vtkstd::vector<LevelInformationType> DataInformationType;
-
-  DataInformationType DataInformation;
-};
-
 //----------------------------------------------------------------------------
 vtkHierarchicalDataInformation::vtkHierarchicalDataInformation()
 {
-  this->Internal = new vtkHierarchicalDataInformationInternal;
 }
 
 //----------------------------------------------------------------------------
 vtkHierarchicalDataInformation::~vtkHierarchicalDataInformation()
 {
-  delete this->Internal;
-}
-
-//----------------------------------------------------------------------------
-void vtkHierarchicalDataInformation::Clear()
-{
-  this->Internal->DataInformation.clear();
-}
-
-//----------------------------------------------------------------------------
-void vtkHierarchicalDataInformation::DeepCopy(
-  vtkHierarchicalDataInformation* from)
-{
-  unsigned int numLevels = from->GetNumberOfLevels(); 
-  this->SetNumberOfLevels(numLevels);
-  for (unsigned int i=0; i<numLevels; i++)
-    {
-    unsigned int numDataSets = from->GetNumberOfDataSets(i);
-    this->SetNumberOfDataSets(i, numDataSets);
-    for (unsigned int j=0; j<numDataSets; j++)
-      {
-      vtkInformation* toInf   = this->GetInformation(i, j);
-      vtkInformation* fromInf = from->GetInformation(i, j);
-      toInf->Copy(fromInf);
-      }
-    }
-}
-
-//----------------------------------------------------------------------------
-unsigned int vtkHierarchicalDataInformation::GetNumberOfLevels()
-{
-  return this->Internal->DataInformation.size();
-}
-
-//----------------------------------------------------------------------------
-void vtkHierarchicalDataInformation::SetNumberOfLevels(unsigned int numLevels)
-{
-  if (numLevels <= this->GetNumberOfLevels())
-    {
-    return;
-    }
-  this->Internal->DataInformation.resize(numLevels);
-
-  this->Modified();
-}
-
-//----------------------------------------------------------------------------
-unsigned int vtkHierarchicalDataInformation::GetNumberOfDataSets(
-  unsigned int level)
-{
-  if (this->Internal->DataInformation.size() <= level)
-    {
-    return 0;
-    }
-
-  vtkHierarchicalDataInformationInternal::LevelInformationType& linf = 
-    this->Internal->DataInformation[level];
-
-  return linf.size();
-}
-
-//----------------------------------------------------------------------------
-void vtkHierarchicalDataInformation::SetNumberOfDataSets(
-  unsigned int level, unsigned int numDataSets)
-{
-  if (numDataSets <= this->GetNumberOfDataSets(level))
-    {
-    return;
-    }
-  // Make sure that there is a vector allocated for this level
-  if (this->Internal->DataInformation.size() <= level)
-    {
-    this->SetNumberOfLevels(level+1);
-    }
-
-  vtkHierarchicalDataInformationInternal::LevelInformationType& linf = 
-    this->Internal->DataInformation[level];
-  linf.resize(numDataSets);
-
-  this->Modified();
-}
-
-
-//----------------------------------------------------------------------------
-int vtkHierarchicalDataInformation::HasInformation(
-  unsigned int level, unsigned int id)
-{
-  if (this->Internal->DataInformation.size() <= level)
-    {
-    return 0;
-    }
-
-  vtkHierarchicalDataInformationInternal::LevelInformationType& linf = 
-    this->Internal->DataInformation[level];
-  if (linf.size() <= id)
-    {
-    return 0;
-    }
-
-  vtkInformation* inf = linf[id].GetPointer();
-  if (!inf)
-    {
-    return 0;
-    }
-  return 1;
-}
-
-//----------------------------------------------------------------------------
-vtkInformation* vtkHierarchicalDataInformation::GetInformation(
-  unsigned int level, unsigned int id)
-{
-  if (this->Internal->DataInformation.size() <= level)
-    {
-    return 0;
-    }
-
-  vtkHierarchicalDataInformationInternal::LevelInformationType& linf = 
-    this->Internal->DataInformation[level];
-  if (linf.size() <= id)
-    {
-    return 0;
-    }
-
-  vtkInformation* inf = linf[id].GetPointer();
-  if (!inf)
-    {
-    inf = vtkInformation::New();
-    linf[id] = inf;
-    inf->Delete();
-    }
-
-  return inf;
 }
 
 //----------------------------------------------------------------------------

Filtering/vtkHierarchicalDataInformation.h

@@ -14,73 +14,41 @@
 =========================================================================*/
 // .NAME vtkHierarchicalDataInformation - hierarchical information collection
 // .SECTION Description
-// vtkHierarchicalDataInformation stores information objects in a structure
-// corresponding to that of a hierarchical dataset. This is essentially a
-// vector of vectors of information object pointers. Each entry in the
-// outer vector corresponds to one levels, whereas each entry in the inner
-// vector corresponds to one dataset.
+// Legacy class. Use vtkMultiGroupDataInformation instead.
 // .SECTION See Also
-// vtkHierarchicalDataSet vtkCompositeDataPipeline
+// vtkMultiGroupDataInformation
 
 #ifndef __vtkHierarchicalDataInformation_h
 #define __vtkHierarchicalDataInformation_h
 
-#include "vtkObject.h"
+#include "vtkMultiGroupDataInformation.h"
 
-class vtkInformation;
-//BTX
-struct vtkHierarchicalDataInformationInternal;
-//ETX
-
-class VTK_FILTERING_EXPORT vtkHierarchicalDataInformation : public vtkObject
+class VTK_FILTERING_EXPORT vtkHierarchicalDataInformation : public vtkMultiGroupDataInformation
 {
 public:
   static vtkHierarchicalDataInformation *New();
-  vtkTypeRevisionMacro(vtkHierarchicalDataInformation,vtkObject);
+  vtkTypeRevisionMacro(vtkHierarchicalDataInformation,vtkMultiGroupDataInformation);
   void PrintSelf(ostream& os, vtkIndent indent);
 
   // Description:
   // Returns the number of hierarchy levels.
-  unsigned int GetNumberOfLevels();
+  unsigned int GetNumberOfLevels()
+    {
+      return this->GetNumberOfGroups();
+    }
 
   // Description:
   // Set the number of hierarchy levels.
-  void SetNumberOfLevels(unsigned int numLevels);
-
-  // Description:
-  // Given a level, returns the number of datasets.
-  un