vtkUniqueCollection.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkUniqueCollection.h,v 1.7 2004/08/10 07:37:21 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_UNIQUE_COLLECTION_H_
#  define VTK_UNIQUE_COLLECTION_H_
#  include "vtkExtensionsCommonConfigure.h" // vtkExtensions configuration
// VTK Common
#  include "vtkCollection.h"

VTK_EXTENSIONS_NAMESPACE_BEGIN

class VTK_EXTENSIONS_COMMON_EXPORT vtkUniqueCollection
  : public vtkCollection
{
public:
  static vtkUniqueCollection* New (void);
  vtkTypeRevisionMacro (vtkUniqueCollection, vtkCollection);
  void PrintSelf (ostream&, vtkIndent);

  vtkSetMacro (CheckUnique, int);
  vtkGetMacro (CheckUnique, int);
  vtkBooleanMacro (CheckUnique, int);
  void          AddItem (vtkObject* item);

  //BTX
  void          ReplaceItem (int i, vtkObject* item, vtkObject** ret);
  //ETX
  void          ReplaceItem (int i, vtkObject* item)
    { this->ReplaceItem(i, item, NULL); }
  //BTX
  void          RemoveItem (int i, vtkObject** ret);
  //ETX
  void          RemoveItem (int i)
    { this->RemoveItem(i, NULL); }
  //BTX
  void          RemoveItem (vtkObject* item, vtkObject** ret);
  //ETX
  void          RemoveItem (vtkObject* item)
    { this->RemoveItem(item, NULL); }
  int           IndexOf (vtkObject* item);

  vtkObject*    GetNextItem (void);

  vtkObject*    GetItem (int i);

  vtkObject*    GetFirstItem (void);
  
  vtkObject*    GetLastItem (void);

  //BTX
  void          RemoveLastItem (vtkObject** removed);
  //ETX
  void          RemoveLastItem (void)
    { this->RemoveLastItem(NULL); }
  int           PrependItem (vtkObject* item);

  int           AppendItem (vtkObject* item);

  int           InsertItemAt (vtkObject* item, int i);

  int           GetNumberOfItemsByType (const char* type);

  vtkObject*    InitTraversalByType (const char* type);

  vtkObject*    GetNthItemByType (int n, const char* type);

  vtkObject*    GetNextItemByType (const char* type);

  virtual unsigned long GetMTime (void);

protected:
  vtkUniqueCollection (void) : CheckUnique(1) {}
  ~vtkUniqueCollection() {}

  int   CheckUnique;

  vtkCollectionElement* FindCollectionElementAt (int i);

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

// ----------------------------------------------------------------------------
inline void
vtkUniqueCollection::AddItem (vtkObject* aItem) 
{
  if (!this->CheckUnique || !this->IsItemPresent(aItem))
    {
    this->vtkCollection::AddItem(aItem);
    }
}

// ----------------------------------------------------------------------------
inline void
vtkUniqueCollection::ReplaceItem (int            aIndex,
                                  vtkObject*     aNewItem,
                                  vtkObject**    aReturn)
{
  vtkObject* oldItem = this->GetItemAsObject(aIndex);
  vtkObject* newItem = aNewItem;

  if (oldItem == NULL || oldItem == aNewItem)
    {
    return; // No replacement done.
    }

  if (aReturn != NULL)
    {
    // Pass the replaced item out through the call parameter.
    *aReturn = oldItem;
    (*aReturn)->Register(this);
    }

  int existingLocation = this->IsItemPresent(aNewItem);

  this->vtkCollection::ReplaceItem(aIndex, aNewItem);

  if (this->CheckUnique && existingLocation != 0)
    {
    this->vtkCollection::RemoveItem(existingLocation - 1);
    }
}

// ----------------------------------------------------------------------------
inline void
vtkUniqueCollection::RemoveItem (int aIndex, vtkObject** aReturn)
{
  vtkObject* item;

  if (aReturn != NULL && (item = this->GetItem(aIndex)) != NULL)
    {
    // Pass the removed item out through the call parameter.
    *aReturn = item;
    (*aReturn)->Register(this);
    }

  this->vtkCollection::RemoveItem(aIndex);
}

// ----------------------------------------------------------------------------
inline void
vtkUniqueCollection::RemoveItem (vtkObject* aItem, vtkObject** aReturn)
{
  if (aReturn != NULL && this->IsItemPresent(aItem))
    {
    // Pass the removed item out through the call parameter.
    *aReturn = aItem;
    (*aReturn)->Register(this);
    }

  this->vtkCollection::RemoveItem(aItem);
}

// ----------------------------------------------------------------------------
inline int
vtkUniqueCollection::IndexOf (vtkObject* aItem)
{ return this->IsItemPresent(aItem) - 1; }

// ----------------------------------------------------------------------------
inline vtkObject*
vtkUniqueCollection::GetNextItem (void) 
{ return this->GetNextItemAsObject(); }

// ----------------------------------------------------------------------------
inline vtkObject*
vtkUniqueCollection::GetItem (int aIndex)
{ return this->GetItemAsObject(aIndex); }

// ----------------------------------------------------------------------------
inline vtkObject*
vtkUniqueCollection::GetFirstItem (void)
{ return (this->Top != NULL ? this->Top->Item : NULL); }

// ----------------------------------------------------------------------------
inline vtkObject*
vtkUniqueCollection::GetLastItem (void)
{ return (this->Bottom != NULL ? this->Bottom->Item : NULL); }

// ----------------------------------------------------------------------------
inline void
vtkUniqueCollection::RemoveLastItem (vtkObject** aReturn)
{ this->RemoveItem(this->GetLastItem(), aReturn); }

// ----------------------------------------------------------------------------
inline int
vtkUniqueCollection::PrependItem (vtkObject* aItem)
{
  if (aItem == NULL)
    {
    vtkErrorMacro(<< "PrependItem() called with NULL node pointer.");
    return VTK_ERROR;
    }

  int index = this->IndexOf(aItem);

  if (index == 0)
    {
    return VTK_OK; // aItem is already at head of list.
    }
  else if (index > 0)
    {
    this->RemoveItem(index, &aItem); // aItem is being moved.
    }

  vtkCollectionElement* newElem;

  try
    {
    newElem = new vtkCollectionElement;
    }
  catch (...)
    {
    delete newElem;
    return VTK_ERROR;
    }

  newElem->Item = aItem;

  if (index < 0/*index may ONLY be used to know if item is new or moved.*/)
    { // If the item is not merely being moved, increment its reference count.
    newElem->Item->Register(this);
    }

  newElem->Next = this->Top;
  this->Top = newElem;

  if (this->Bottom == NULL)
    {
    this->Bottom = this->Top;
    }

  this->NumberOfItems++;
  this->Modified();

  return VTK_OK;
}

// ----------------------------------------------------------------------------
inline int
vtkUniqueCollection::AppendItem (vtkObject* aItem)
{
  if (aItem == NULL)
    {
    vtkErrorMacro(<< "AppendItem() called with NULL node pointer.");
    return VTK_ERROR;
    }

  if (this->Bottom == NULL)
    {
    return this->PrependItem(aItem);
    }

  int index = this->IndexOf(aItem);

  if (index == (this->NumberOfItems - 1))
    {
    return VTK_OK; // aItem is already at end of list.
    }
  else if (index >= 0)
    {
    this->RemoveItem(index, &aItem); // aItem is being moved.
    }

  vtkCollectionElement* newElem;

  try
    {
    newElem = new vtkCollectionElement;
    }
  catch (...)
    {
    delete newElem;
    return VTK_ERROR;
    }

  newElem->Item = aItem;

  if (index < 0/*index may ONLY be used to know if item is new or moved.*/)
    { // If the item is not merely being moved, increment its reference count.
    newElem->Item->Register(this);
    }

  this->Bottom->Next = newElem;
  this->Bottom = newElem;

  this->NumberOfItems++;
  this->Modified();

  return VTK_OK;
}

// ----------------------------------------------------------------------------
inline vtkCollectionElement*
vtkUniqueCollection::FindCollectionElementAt (int aIndex)
{
  int i = 0;

  for (vtkCollectionElement* elem = this->Top; elem != NULL; elem = elem->Next)
    {
    if (i == aIndex)
      {
      return elem;
      }
    i++;
    }
  
  return NULL;
}

// ----------------------------------------------------------------------------
inline int
vtkUniqueCollection::InsertItemAt (vtkObject* aItem, int aIndex)
{
  if (aItem == NULL)
    {
    vtkWarningMacro(<< "InsertItemAt() called with NULL node pointer.");
    return VTK_ERROR;
    }

  if (aIndex < 0 || aIndex > this->NumberOfItems)
    {
    vtkWarningMacro(<< "InsertItemAt() called with invalid index.");
    return VTK_ERROR;
    }

  if (aIndex == 0)
    {
    return this->PrependItem(aItem);
    }
  else if (aIndex == this->NumberOfItems)
    {
    return this->AppendItem(aItem);
    }

  int index = this->IndexOf(aItem);

  if (index == aIndex)
    {
    return VTK_OK; // aItem is already at specified index.
    }
  else if (index >= 0)
    {
    this->RemoveItem(index, &aItem); // aItem is being moved.
    }

  vtkCollectionElement* currElem;

  if ((currElem = this->FindCollectionElementAt(aIndex-1)) != NULL)
    {
    vtkCollectionElement* newElem;

    try
      {
      newElem = new vtkCollectionElement;
      }
    catch (...)
      {
      delete newElem;
      return VTK_ERROR;
      }
    
    newElem->Next = currElem->Next;
    newElem->Item = aItem;

    if (index < 0/*index may ONLY be used to know if item is new or moved.*/)
      { // If the item is not merely being moved, increment its reference count.
      newElem->Item->Register(this);
      }

    currElem->Next = newElem;

    this->NumberOfItems++;
    this->Modified();

    return VTK_OK;
    }

  return VTK_ERROR;
}

// ----------------------------------------------------------------------------
inline int
vtkUniqueCollection::GetNumberOfItemsByType (const char* aType)
{
  vtkCollectionElement* elem = this->Top;
  int num = 0;

  while (elem != NULL)
    {
    if (elem->Item->IsA(aType)) num++;
    elem = elem->Next;
    }

  return num;
}

inline vtkObject*
vtkUniqueCollection::GetNextItemByType (const char* aType)
{
  vtkCollectionElement* elem = this->Current;

  if (elem != NULL) elem = elem->Next;

  while (elem != NULL && !elem->Item->IsA(aType)) elem = elem->Next;
  
  if (elem != NULL)
    {
    this->Current = elem;
    return this->Current->Item;
    }

  return NULL;
}

inline vtkObject*
vtkUniqueCollection::InitTraversalByType (const char* aType)
{
  vtkCollectionElement* elem = this->Top;

  while (elem != NULL && !elem->Item->IsA(aType)) elem = elem->Next;
  
  if (elem != NULL)
    {
    this->Current = elem;
    return this->Current->Item;
    }

  return NULL;
}

inline vtkObject*
vtkUniqueCollection::GetNthItemByType (int aIndex, const char* aType)
{
  vtkCollectionElement* elem = this->Top;
  int j = 0;

  while (elem != NULL)
    {
    if (elem->Item->IsA(aType))
      if (aIndex == j++)
        return elem->Item;

    elem = elem->Next;
    }

  return NULL;
}

// ----------------------------------------------------------------------------
inline unsigned long
vtkUniqueCollection::GetMTime (void)
{
  vtkObject*    item;
  unsigned long itemMTime;
  unsigned long mtime = this->vtkCollection::GetMTime();
  
  for (this->InitTraversal(); (item = this->GetNextItem()) != NULL; )
    {
    if ((itemMTime = item->GetMTime()) > mtime)
      {
      mtime = itemMTime;
      }
    }

  return mtime;
}

VTK_EXTENSIONS_NAMESPACE_END

#endif /* VTK_UNIQUE_COLLECTION_H_ */
/*
 * End of: $Id: vtkUniqueCollection.h,v 1.7 2004/08/10 07:37:21 xpxqx Exp $.
 * 
 */

---