vtkTraversal.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkTraversal.h,v 1.2 2004/08/10 07:37:22 xpxqx Exp $
 *
 * Copyright (c) 2004 Sean McInerney
 * All rights reserved.
 *
 * See Copyright.txt or http://vtkextensions.sourceforge.net/Copyright.html
 * 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 VTK_TRAVERSAL_H_
#  define VTK_TRAVERSAL_H_
#  include "vtkExtensionsHybridConfigure.h" // vtkExtensions configuration
#  include "vtkExtensionsTypes.h"           // vtkExtensions types
// VTK Common
#  include "vtkDataObject.h"    // for inline methods
#  include "vtkSource.h"        // for inline methods

#  define VTK_TRAVERSAL_DISCONNECTED            0x01
#  define VTK_TRAVERSAL_PRECEDING               0x02
#  define VTK_TRAVERSAL_FOLLOWING               0x04
#  define VTK_TRAVERSAL_CONTAINS                0x08
#  define VTK_TRAVERSAL_CONTAINED_BY            0x10
#  define VTK_TRAVERSAL_IMPLEMENTATION_SPECIFIC 0x20

class vtkCollection;
class vtkDataObjectCollection;

VTK_EXTENSIONS_NAMESPACE_BEGIN

class vtkProcessObjectCollection;

VTK_EXTENSIONS_HYBRID_NESTED_NAMESPACE_BEGIN

class VTK_EXTENSIONS_HYBRID_EXPORT vtkTraversal
{
public:
  static vtkTraversal* New (void) { return new vtkTraversal; }

  vtkTraversal (void);
  //BTX
  vtkTraversal (vtkProcessObject* a);
  virtual ~vtkTraversal();
  //ETX

  void  UpdateTop (vtkProcessObject* aNode);

  void  UpdateTop (void);

  vtkProcessObject*     InitTraversal (vtkProcessObject* aNode);

  vtkProcessObject*     InitTraversal (void);

  vtkProcessObject*     TraverseUp (void);

  vtkProcessObject*     TraverseForward (int& depth);

  vtkProcessObject*     TraverseForward (void);

  vtkProcessObject*     TraverseBackward (void);

  vtkProcessObject*     Find (vtkProcessObject* node);

  vtkProcessObject*     FindByType (const char* classname);
  vtkProcessObject*     FindBySupertype (const char* superclassname);

public:
  static vtkProcessObject*      GetInputSource (vtkDataObject* o);

  static vtkDataObject*         GetFirstInput (vtkProcessObject* o);

  static vtkDataObject*         GetParent (vtkDataObject* o);

  static vtkProcessObject*      GetParent (vtkProcessObject* o);

  //BTX
  static vtkCollection*
  GetConsumers (vtkDataObject* parent, vtkCollection** = 0);

  static vtkDataObjectCollection*
  GetOutputs (vtkProcessObject* parent, vtkDataObjectCollection** = 0);

  static vtkDataObjectCollection*
  GetChildren (vtkDataObject* parent, vtkDataObjectCollection** = 0);

  static vtkCollection*
  GetConsumers (vtkProcessObject* parent, vtkCollection** = 0);

  static vtkProcessObjectCollection*
  GetChildren (vtkProcessObject* parent, vtkProcessObjectCollection** = 0);

  static int    GetNumberOfChildren (vtkDataObject* parent,
                                     vtkDataObjectCollection** = 0);

  static int    GetNumberOfChildren (vtkProcessObject* parent,
                                     vtkProcessObjectCollection** = 0);
  //ETX

  static vtkObject*             GetFirstConsumer (vtkDataObject* o);
  static vtkProcessObject*      GetFirstProcessObject (vtkDataObject* o);
  static vtkDataObject*         GetFirstOutput (vtkProcessObject* o);

  static vtkDataObject*         GetFirstChild (vtkDataObject* o);
  static vtkObject*             GetFirstConsumer (vtkProcessObject* o);
  static vtkProcessObject*      GetFirstChild (vtkProcessObject* o);

  static vtkObject*             GetLastConsumer (vtkDataObject* o);
  static vtkProcessObject*      GetLastProcessObject (vtkDataObject* o);
  static vtkDataObject*         GetLastOutput (vtkProcessObject* o);

  static vtkDataObject*         GetLastChild (vtkDataObject* o);
  static vtkObject*             GetLastConsumer (vtkProcessObject* o);
  static vtkProcessObject*      GetLastChild (vtkProcessObject* o);

  static vtkDataObject*         GetNextSibling (vtkDataObject* o);
  static vtkProcessObject*      GetNextSibling (vtkProcessObject* o);
  static vtkDataObject*         GetPreviousSibling (vtkDataObject* o);
  static vtkProcessObject*      GetPreviousSibling (vtkProcessObject*);

  static vtkDataObject*         GetTop (vtkDataObject* o);
  static vtkProcessObject*      GetTop (vtkProcessObject* o);

  static vtkProcessObject*      Splice (vtkProcessObject* newNode,
                                        vtkProcessObject* refNode);

  static vtkProcessObject*      Replace (vtkProcessObject* newNode,
                                         vtkProcessObject* oldNode);

  static vtkProcessObject*      Remove (vtkProcessObject* oldNode);

  static vtkSource*             Append (vtkSource*        newNode,
                                        vtkProcessObject* refNode);

  static vtkBoolType            HasChildren (vtkDataObject* o);
  static vtkBoolType            HasChildren (vtkProcessObject* o);

  static unsigned short ComparePosition (vtkProcessObject* o) { return 0; }

  static vtkBoolType    IsSame (vtkProcessObject* o) {return false;}
  static vtkBoolType    IsEqual (vtkProcessObject* o) {return false;}

protected:
  vtkProcessObject*     Top;
  vtkProcessObject*     Current;

  //BTX
  typedef vtkTraversal Self;
  //ETX

  static int            GetConsumerIndex (vtkDataObject* o,
                                          vtkObject*     consumer);

  static int            GetOutputIndex (vtkProcessObject* o,
                                        vtkDataObject*    output);

  static int            SetNthInput (vtkProcessObject* node,
                                     int               index,
                                     vtkDataObject*    input);

  static vtkBoolType    IsSelfOrAncestor (vtkProcessObject* node,
                                          vtkProcessObject* child);

private:
  vtkTraversal (const vtkTraversal&);
  void operator= (const vtkTraversal&);
};

// ----------------------------------------------------------------------------
inline int
vtkTraversal::GetConsumerIndex (vtkDataObject* aDataObject,
                                vtkObject*     aConsumer)
{
  if (aConsumer != NULL && aDataObject != NULL)
    {
    int n;

    if ((n = aDataObject->GetNumberOfConsumers()) > 0)
      for (int i=0; i<n; i++)
        if (aDataObject->GetConsumer(i) == aConsumer)
          return i;
    }

  return -1;
}

inline int
vtkTraversal::GetOutputIndex (vtkProcessObject* aProcessObject,
                              vtkDataObject*    aOutput)
{
  vtkSource* source;

  if ( aOutput != NULL &&
       (source = vtkSource::SafeDownCast(aProcessObject)) != NULL )
    {
    int n;
    
    if ((n = source->GetNumberOfOutputs()) > 0)
      for (int i=0; i<n; i++)
        if ((source->GetOutputs())[i] == aOutput)
          return i;
    }

  return -1;
}

inline int
vtkTraversal::SetNthInput (vtkProcessObject* aProcessObject,
                           int               aIndex,
                           vtkDataObject*    aInput)
{
  vtkDataObject** input;

  if ( (aProcessObject == NULL) ||
       (aIndex < 0) ||
       (aIndex >= aProcessObject->GetNumberOfInputs()) )
    return VTK_ERROR; // Cannot increase number of inputs at this access level.

  if (*(input = &((aProcessObject->GetInputs())[aIndex])) == aInput)
    return VTK_OK;

  if (*input != NULL)
    {
    (*input)->RemoveConsumer(aProcessObject);
    (*input)->UnRegister(aProcessObject);
    *input = NULL;
    }
  
  if (aInput != NULL)
    {
    aInput->AddConsumer(aProcessObject);
    aInput->Register(aProcessObject);
    *input = aInput; // DANGER ?!?
    }

  aProcessObject->Modified();

  return VTK_OK;
}

inline vtkBoolType
vtkTraversal::IsSelfOrAncestor (vtkProcessObject* aNode,
                                vtkProcessObject* aChild)
{
  if (aNode == aChild)
    {
    return VTK_TRUE;
    }

  // If aChild doesn't have children it can't be our ancestor.
  if (!Self::HasChildren(aChild))
    {
    return VTK_FALSE;
    }

  vtkProcessObject* parentNode = Self::GetParent(aNode);

  while (parentNode != NULL)
    {
    if (parentNode == aChild)
      {
      return VTK_TRUE; // Found aChild as one of our ancestors.
      }
    parentNode = Self::GetParent(parentNode);
    }

  return VTK_FALSE;
}

// ----------------------------------------------------------------------------
vtkProcessObject*
vtkTraversal::GetInputSource (vtkDataObject* aInput)
{
  if (aInput == NULL)
    return NULL;

  // Return the next edge up.
  return aInput->GetSource();
}

vtkDataObject*
vtkTraversal::GetFirstInput (vtkProcessObject* aProcessObject)
{
  if (aProcessObject == NULL || aProcessObject->GetNumberOfInputs() < 1)
    return NULL;

  if (aProcessObject->GetNumberOfInputs() > 1)
    vtkGenericWarningMacro(<< "vtkTraversal does not handle > 1 inputs.");

  // Return the next edge up.
  return (aProcessObject->GetInputs())[0];
}

// ----------------------------------------------------------------------------
vtkDataObject*
vtkTraversal::GetParent (vtkDataObject* aDataObject)
{
  vtkProcessObject* source;
 
  // Get the edge connecting this node.
  if ((source = Self::GetInputSource(aDataObject)) != NULL)
    // Return the next node up.
    return Self::GetFirstInput(source);
   
  return NULL;
}

vtkProcessObject*
vtkTraversal::GetParent (vtkProcessObject* aProcessObject)
{
  vtkDataObject* dataObject;
 
  // Get the edge connecting this node.
  if ((dataObject = Self::GetFirstInput(aProcessObject)) != NULL)
    // Return the next node up.
    return Self::GetInputSource(dataObject);
   
  return NULL;
}

// ----------------------------------------------------------------------------
vtkObject*
vtkTraversal::GetFirstConsumer (vtkDataObject* aDataObject)
{
  vtkObject* o = NULL;
  int n, i = 0;

  if (aDataObject != NULL && (n = aDataObject->GetNumberOfConsumers()) > 0)
    while (i < n && (o = aDataObject->GetConsumer(i)) == NULL) i++;

  return o;
}

vtkProcessObject*
vtkTraversal::GetFirstProcessObject (vtkDataObject* aDataObject)
{
  vtkProcessObject* o = NULL;
  int n, i = 0;

  if (aDataObject != NULL && (n = aDataObject->GetNumberOfConsumers()) > 0)
    while ( i < n &&
            (o = vtkProcessObject::SafeDownCast(aDataObject->GetConsumer(i)))
            == NULL) i++;

  return o;
}

vtkDataObject*
vtkTraversal::GetFirstOutput (vtkProcessObject* aProcessObject)
{
  vtkDataObject* result = NULL;
  vtkSource*     source;

  if ((source = vtkSource::SafeDownCast(aProcessObject)) != NULL)
    {
    int n, i = 0;

    if (source != NULL && (n = source->GetNumberOfOutputs()) > 0)
      while (i < n && (result = (source->GetOutputs())[i]) == NULL) i++;
    }

  return result;
}

// ----------------------------------------------------------------------------
vtkDataObject*
vtkTraversal::GetFirstChild (vtkDataObject* aDataObject)
{
  vtkDataObject*    result = NULL;
  vtkProcessObject* processObject;

  if ((processObject = Self::GetFirstProcessObject(aDataObject)) != NULL)
    while ( processObject != NULL &&
            (result = Self::GetFirstOutput(processObject)) == NULL )
      processObject = Self::GetNextSibling(processObject);

  return result;
}

vtkObject*
vtkTraversal::GetFirstConsumer (vtkProcessObject* aProcessObject)
{
  vtkObject*     result = NULL;
  vtkDataObject* output;

  if ((output = Self::GetFirstOutput(aProcessObject)) != NULL)
    while (output != NULL && (result = Self::GetFirstConsumer(output)) == NULL)
      output = Self::GetNextSibling(output);

  return result;
}

vtkProcessObject*
vtkTraversal::GetFirstChild (vtkProcessObject* aProcessObject)
{
  vtkProcessObject* result = NULL;
  vtkDataObject*    output;

  if ((output = Self::GetFirstOutput(aProcessObject)) != NULL)
    while (output!=NULL && (result = Self::GetFirstProcessObject(output))==NULL)
      output = Self::GetNextSibling(output);

  return result;
}

// ----------------------------------------------------------------------------
vtkObject*
vtkTraversal::GetLastConsumer (vtkDataObject* aDataObject)
{
  vtkObject* o = NULL;
  int n;

  if (aDataObject != NULL && (n = aDataObject->GetNumberOfConsumers()) > 0)
    while (n > 0 && (o = aDataObject->GetConsumer(n-1)) == NULL) n--;

  return o;
}

vtkProcessObject*
vtkTraversal::GetLastProcessObject (vtkDataObject* aDataObject)
{
  vtkProcessObject* o = NULL;
  int n;

  if (aDataObject != NULL && (n = aDataObject->GetNumberOfConsumers()) > 0)
    while ( n > 0 &&
            (o = vtkProcessObject::SafeDownCast(aDataObject->GetConsumer(n-1)))
            == NULL ) n--;

  return o;
}

vtkDataObject*
vtkTraversal::GetLastOutput (vtkProcessObject* aProcessObject)
{
  vtkDataObject* result = NULL;
  vtkSource*     source;

  if ((source = vtkSource::SafeDownCast(aProcessObject)) != NULL)
    {
    int n;

    if (source != NULL && (n = source->GetNumberOfOutputs()) > 0)
      while (n > 0 && (result = (source->GetOutputs())[n-1]) == NULL) n--;
    }

  return result;
}

// ----------------------------------------------------------------------------
vtkDataObject*
vtkTraversal::GetLastChild (vtkDataObject* aDataObject)
{
  vtkDataObject*    result = NULL;
  vtkProcessObject* processObject;

  if ((processObject = Self::GetLastProcessObject(aDataObject)) != NULL)
    while ( processObject != NULL &&
            (result = Self::GetLastOutput(processObject)) == NULL )
      processObject = Self::GetPreviousSibling(processObject);

  return result;
}

vtkObject*
vtkTraversal::GetLastConsumer (vtkProcessObject* aProcessObject)
{
  vtkObject*     result = NULL;
  vtkDataObject* output;

  if ((output = Self::GetLastOutput(aProcessObject)) != NULL)
    while (output != NULL && (result = Self::GetLastConsumer(output)) == NULL)
      output = Self::GetPreviousSibling(output);

  return result;
}

vtkProcessObject*
vtkTraversal::GetLastChild (vtkProcessObject* aProcessObject)
{
  vtkProcessObject* result = NULL;
  vtkDataObject*    output;

  if ((output = Self::GetLastOutput(aProcessObject)) != NULL)
    while (output!=NULL && (result = Self::GetLastProcessObject(output))==NULL)
      output = Self::GetPreviousSibling(output);

  return result;
}

// ----------------------------------------------------------------------------
vtkDataObject*
vtkTraversal::GetNextSibling (vtkDataObject* aDataObject)
{
  vtkDataObject* result = NULL;
  vtkSource*     up;
  int            i;

  if ((up = vtkSource::SafeDownCast(Self::GetInputSource(aDataObject))) != NULL)
    if ((i = Self::GetOutputIndex(up, aDataObject) + 1) > 0)
      while ( i < up->GetNumberOfOutputs() &&
              (result = (up->GetOutputs())[i]) == NULL )
        i++;

  return result;
}

vtkProcessObject*
vtkTraversal::GetNextSibling (vtkProcessObject* aProcessObject)
{
  vtkProcessObject* result = NULL;
  vtkDataObject*    up;
  int               i;

  if ((up = Self::GetFirstInput(aProcessObject)) != NULL)
    if ((i = Self::GetConsumerIndex(up, aProcessObject) + 1) > 0)
      while ( i < up->GetNumberOfConsumers() &&
              (result=vtkProcessObject::SafeDownCast(up->GetConsumer(i)))==NULL)
        i++;

  return result;
}

vtkDataObject*
vtkTraversal::GetPreviousSibling (vtkDataObject* aDataObject)
{
  vtkDataObject* result = NULL;
  vtkSource*     up;
  int            i;

  if ((up = vtkSource::SafeDownCast(Self::GetInputSource(aDataObject))) != NULL)
    if ((i = Self::GetOutputIndex(up, aDataObject) - 1) >= 0)
      while ( i >= 0 &&
              (result = (up->GetOutputs())[i]) == NULL )
        i--;

  return result;
}

vtkProcessObject*
vtkTraversal::GetPreviousSibling (vtkProcessObject* aProcessObject)
{
  vtkProcessObject* result = NULL;
  vtkDataObject*    up;
  int               i;

  if ((up = Self::GetFirstInput(aProcessObject)) != NULL)
    if ((i = Self::GetConsumerIndex(up,aProcessObject) - 1) >= 0)
      while ( i >= 0 &&
              (result=vtkProcessObject::SafeDownCast(up->GetConsumer(i)))==NULL)
        i--;

  return result;
}

// ----------------------------------------------------------------------------
vtkDataObject*
vtkTraversal::GetTop (vtkDataObject* aDataObject)
{
  vtkDataObject* child = aDataObject;
  vtkDataObject* parent;

  while ((parent = Self::GetParent(child)) != NULL) child = parent;

  return child;
}

vtkProcessObject*
vtkTraversal::GetTop (vtkProcessObject* aProcessObject)
{
  vtkProcessObject* child = aProcessObject;
  vtkProcessObject* parent;

  while ((parent = Self::GetParent(child)) != NULL) child = parent;

  return child;
}

// ----------------------------------------------------------------------------
inline void
vtkTraversal::UpdateTop (vtkProcessObject* aNode)
{
  this->Top     = Self::GetTop(aNode);
  this->Current = aNode;
}

inline void
vtkTraversal::UpdateTop (void)
{
  this->Top = Self::GetTop(this->Top);
}

inline vtkProcessObject*
vtkTraversal::InitTraversal (vtkProcessObject* aNode)
{
  return (this->Current = aNode);
}

inline vtkProcessObject*
vtkTraversal::InitTraversal (void)
{
  return (this->Current = this->Top);
}

inline vtkProcessObject*
vtkTraversal::TraverseUp (void)
{
  if (this->Current != NULL) this->Current = Self::GetParent(this->Current);

  return this->Current;
}

inline vtkProcessObject*
vtkTraversal::TraverseForward (int& aDepth)
{
  vtkProcessObject* ptr;

  // If the current node is set and has a child ...
  if ((ptr = Self::GetFirstChild(this->Current)) != NULL)
    {
    this->Current = ptr;
    aDepth++;

    return this->Current;
    }

  vtkProcessObject* child;

  // If the current node is set and has a next sibling ...
  if ((ptr = vtkTraversal::GetNextSibling(this->Current)) != NULL)
    {
    this->Current = ptr;

    return this->Current;
    }

  // Traverse upward in search of a next sibling ...
  while ((this->Current != NULL) && (ptr == NULL))
    {
    this->Current = Self::GetParent(this->Current);
    ptr = vtkTraversal::GetNextSibling(this->Current);
    aDepth--;
    }
  if (this->Current != NULL)
    {
    this->Current = ptr;
    }

  return this->Current;
}

inline vtkProcessObject*
vtkTraversal::TraverseForward (void)
{
  int d;

  return this->TraverseForward(d);
}

inline vtkProcessObject*
vtkTraversal::TraverseBackward (void)
{
  vtkProcessObject* ptr;

  // If the current node is set and has a previous sibling ...
  if ((ptr = Self::GetPreviousSibling(this->Current)) != NULL)
    {
    while ((ptr = Self::GetFirstChild(this->Current = ptr)) != NULL)
      {
      while ((ptr = Self::GetNextSibling(this->Current = ptr)) != NULL)
        {
        if ( Self::GetNextSibling(this->Current = ptr) == NULL &&
             (ptr = Self::GetFirstChild(this->Current)) != NULL )
          {
          this->Current = ptr;
          }
        }
      }
    }
  else
    {
    this->Current = Self::GetParent(this->Current);
    }

  return this->Current;
}

inline vtkProcessObject*
vtkTraversal::Find (vtkProcessObject* aTarget)
{
  if (aTarget != NULL)
    {
    for ( vtkProcessObject* node = this->InitTraversal();
          node != NULL;
          node = this->TraverseForward() )
      if (node == aTarget)
        return node;
    }

  return NULL;
}

inline vtkProcessObject*
vtkTraversal::FindByType (const char* aName)
{
  if (aName != NULL && aName[0] != '\0')
    {
    for ( vtkProcessObject* node = this->InitTraversal();
          node != NULL;
          node = this->TraverseForward() )
      if (strcmp(node->GetClassName(), aName) == 0)
        return node;
    }

  return NULL;
}

inline vtkProcessObject*
vtkTraversal::FindBySupertype (const char* aName)
{
  if (aName != NULL && aName[0] != '\0')
    {
    for ( vtkProcessObject* node = this->InitTraversal();
          node != NULL;
          node = this->TraverseForward() )
      if (node->IsA(aName) == 1)
        return node;
    }

  return NULL;
}

#if 0
// ----------------------------------------------------------------------------
inline int
vtkTraversal::InsertBefore (vtkProcessObject* aInsertion,
                            vtkProcessObject* aReference)
{
  if (aInsertion == NULL)
    {
    vtkGenericWarningMacro(<< "NULL pointer to child to be inserted.");
    return VTK_ERROR;
    }

  if (aReference == NULL)
    {
    vtkGenericWarningMacro(<< "NULL pointer to insertion reference child.");
    return VTK_ERROR;
    }

  vtkProcessObject* refParent;

  if ((refParent = Self::GetParent(aReference)) == NULL)
    {
    vtkGenericWarningMacro(<< "Insertion reference child is parentless.");
    return VTK_ERROR;
    }

  // Make sure the new child is not "this" node or an ancestor of "this" node.
  if (Self::IsSelfOrAncestor(refParent, aInsertion))
    {
    vtkGenericWarningMacro(<< "Bad request to insert ancestor as child.");
    return VTK_ERROR;
    }

  vtkProcessObject* oldParent;

  /*
   * Remove the element from the old parent if one exists, since oldParent
   * is a vtkNode this will do the right thing even if the parent of
   * aInsertion is at top level. This code also handles the case where the
   * new child is alleady a child of this node 
   * -- jst@citec.fi
   */
  if ((oldParent = Self::GetParent(aInsertion)) != NULL)
    {
    vtkProcessObject* tmpNode;
    int origChildCount, newChildCount;

    origChildCount = Self::GetNumberOfChildren(refParent);

    // Does not matter if this call fails here or not.
    Self::RemoveChild(oldParent, aInsertion, tmpNode);

    newChildCount = Self::GetNumberOfChildren(refParent);

    /*
     * Check if our child count changed during the RemoveChild call, if
     * it did then oldParent is most likely this node. In this case we
     * must check if refPos is still correct (unless it's zero).
     */
    if ((refPos != 0) && (origChildCount != newChildCount))
      {
      /*
       * Check that aReference is now at refPos - 1.
       * This will happen if the new child was one of aReferences'
       * previous siblings.
       */
      if (aReference == Self::ChildAt(refParent, refPos - 1))
        {
        refPos--;
        }
      }
    }

  return this->InsertChildAt(aInsertion, refPos);
}
#endif /* 0 */

VTK_EXTENSIONS_HYBRID_NAMESPACE_END

#endif /* VTK_TRAVERSAL_H_ */
/*
 * End of: $Id: vtkTraversal.h,v 1.2 2004/08/10 07:37:22 xpxqx Exp $.
 * 
 */

---