baseVtxLst.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: baseVtxLst.h,v $ $Revision: 1.8 $ $State: Exp $
*********************************************************************/

#ifndef baseVtxLst_H_
#define baseVtxLst_H_

// include files
#include "gdb/gdbDefines.h"
#include "gdb/gdbNode.h"

#include "geometry/point.h"

//forward declarations
class DtChord;
class DtChordIntersectionRecord;
class DtTerrainDatabase;

//
//
// class DtBaseVertexList:
//
// DtBaseVertexList is a base class for representing vertex lists. Grid post
// lists, as well as a list of 3D points, can be represented as vertex lists
// derived from this class.
// 
// I have removed surface list from being a member variable of  
// base vertex list. A grid post list, however, has a surface list associated
// with it -- RVK 
//
//

class DT_DLL_gdb DtBaseVertexList :public DtGdbNode
{
public:

   // default constructor
   DtBaseVertexList();

   // create a vertex list of specified capacity.
   DtBaseVertexList(unsigned int maxNumVertices);

   // destructor
   virtual ~DtBaseVertexList();

   // returns the number of vertices currently held in the vertex list.    
   virtual unsigned int size() const;

   // increments the size of the vertex list by 1, and returns the new
   // size.
   virtual unsigned int incrementSize();

   // returns the maximum number of vertices specified for the
   // vertex list.
   virtual unsigned int maxNumberOfVertices() const;

   // set the maximum number of vertices that may be in the 
   // vertex list
   virtual void  setMaxNumberOfVertices(unsigned int maxNumVertices);

   // set the number of vertices that are in the 
   // vertex list
   virtual void  setNumberOfVertices(unsigned int numVertices);

   //get the i-th vertex from vertex list
   virtual DtPoint vertex(unsigned int i) const = 0;
   virtual bool getVertex(DtPoint& retVal, unsigned int i) const = 0;

   //determine the extent of the vertex list
   virtual DtExtent extent() const;

   //modify extent to include all points in the vertex list
   virtual void expandExtent(DtExtent& extent) const;

   //determine if the vertex list is filled to capacity   
   virtual bool isFull() const;

   //determine if an index into the vertex list is within bounds.
   // 0 <= i < maxNumberOfVertices()
   virtual bool indexWithinBounds(unsigned int i) const;

   //determine if an index into the vertex list is valid.
   // 0 <= i < size()
   virtual bool validIndex(unsigned int i) const;

   //debugging utility
   virtual void dump(int indentLevel) const;

   virtual int sizeInBytes() const;

protected:

   // copy constructor
   DtBaseVertexList(const DtBaseVertexList& orig);

   // assignment operator
   DtBaseVertexList& operator=(const DtBaseVertexList& orig);

protected:

   unsigned int  myNumberOfVertices;     //current size
   unsigned int  myMaxNumberOfVertices;  //maximum capacity

};



inline unsigned int DtBaseVertexList::maxNumberOfVertices() const
{
   return myMaxNumberOfVertices;
}

inline void DtBaseVertexList::setMaxNumberOfVertices(unsigned int n)
{
   myMaxNumberOfVertices = n;
}

inline void DtBaseVertexList::setNumberOfVertices(unsigned int n)
{
   if (myMaxNumberOfVertices >= n)
   {
      myNumberOfVertices = n;
   }
}

inline unsigned int DtBaseVertexList::size() const
{
   return myNumberOfVertices;
}

inline unsigned int DtBaseVertexList::incrementSize()
{
   return myNumberOfVertices++;
}


#endif