vtkAbstractSequence.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkAbstractSequence.h,v 1.2 2004/06/03 18:58:28 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_ABSTRACT_SEQUENCE_H_
#  define VTK_ABSTRACT_SEQUENCE_H_
#  include "vtkContainer.h"
#  include "vtkAbstractSequenceIterator.h"

VTK_EXTENSIONS_CONTAINERS_NAMESPACE_BEGIN

class VTK_EXTENSIONS_CONTAINERS_EXPORT vtkAbstractSequence
  : public vtkContainer
{
public:
  vtkTypeRevisionMacro (vtkAbstractSequence, vtkContainer);
  void PrintSelf (ostream&, vtkIndent);

  //BTX
  typedef int (*CompareFunction)(const vtkObjectBase* & a1,
                                 const vtkObjectBase* & a2);
  //ETX

  virtual int                   Swap (vtkAbstractSequence* container) = 0;

  virtual vtkIdType             GetCapacity (void) const;

  virtual int                   SetCapacity (vtkIdType capacity) = 0;

  virtual vtkObjectBase*        At (vtkIdType position) const;

  virtual vtkIdType             Find (const vtkObjectBase* object) const;

  //BTX
  virtual vtkIdType             Find (const vtkObjectBase* object,
                                      CompareFunction      comparison) const;
  //ETX

  virtual int                   IsPresent (const vtkObjectBase* object) const;

  virtual int                   Insert (vtkIdType       position,
                                        vtkObjectBase*  object) = 0;

  virtual int                   Insert (vtkIdType            position,
                                        vtkAbstractSequence* sequence);

  virtual int                   PushFront (vtkObjectBase* object);

  int                           PopFront (void);

  virtual int                   PushBack (vtkObjectBase* object) = 0;

  int                           PopBack (void);

  virtual int                   PushBack (vtkAbstractSequence* sequence);

  virtual int                   Assign (vtkIdType      position,
                                        vtkObjectBase* object) = 0;

  virtual int                   Erase (vtkIdType position) = 0;

  void                          DebugSequence (ostream& stream);

  virtual vtkAbstractSequenceIterator* CreateIterator (void) = 0;

protected:
  vtkAbstractSequence (void) {}
  ~vtkAbstractSequence() {}

private:
  //BTX
  int Swap (vtkContainer* a)
    { return this->Swap(static_cast<vtkAbstractSequence*>(a)); }
  //ETX

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

// ----------------------------------------------------------------------------
inline vtkIdType
vtkAbstractSequence::GetCapacity (void) const
{
  return 0;
}

inline vtkObjectBase*
vtkAbstractSequence::At (vtkIdType) const
{
  return (vtkObjectBase *) 0;
}

inline vtkIdType
vtkAbstractSequence::Find (const vtkObjectBase*) const
{
  return -1;
}

inline vtkIdType
vtkAbstractSequence::Find (const vtkObjectBase*, CompareFunction) const
{
  return -1;
}

// ----------------------------------------------------------------------------
inline int
vtkAbstractSequence::IsPresent (const vtkObjectBase* a) const
{
  return (this->Find(a)<0 ? VTK_FALSE : VTK_TRUE);
}

inline int
vtkAbstractSequence::Insert (vtkIdType            aPosition,
                             vtkAbstractSequence* aSequence)
{
  for (vtkIdType i=0; i<aSequence->GetSize(); i++)
    {
    if (this->Insert(aPosition + i, aSequence->At(i)) == VTK_FALSE)
      {
      // roll back changes on error.
      for (vtkIdType ii=aPosition+i-1; ii>=aPosition; ii--)
        {
        (void) this->Erase(ii); // Erase errors ignored.
        }
      return VTK_FALSE;
      }
    }
  return VTK_TRUE;
}

inline int
vtkAbstractSequence::PushFront (vtkObjectBase* a)
{
  return this->Insert(0, a);
}

inline int
vtkAbstractSequence::PopFront (void)
{
  return this->Erase(0);
}

inline int
vtkAbstractSequence::PopBack (void)
{
  return this->Erase(this->GetSize() - 1);
}

inline int
vtkAbstractSequence::PushBack (vtkAbstractSequence* aSequence) 
{
  for (vtkIdType i=0; i<aSequence->GetSize(); i++)
    {
    if (this->PushBack(aSequence->At(i)) == VTK_FALSE)
      {
      // roll back changes on error.
      for (vtkIdType ii=0; ii<i; ii++)
        {
        (void) this->PopBack(); // Erase errors ignored.
        }
      return VTK_FALSE;
      }
    }
  return VTK_TRUE;
}

VTK_EXTENSIONS_CONTAINERS_NAMESPACE_END

#endif /* VTK_ABSTRACT_SEQUENCE_H_ */
/* 
 * End of: $Id: vtkAbstractSequence.h,v 1.2 2004/06/03 18:58:28 xpxqx Exp $.
 * 
 */

---