chordBundle.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2001 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: chordBundle.h,v $ $Revision: 1.5 $ $State: Exp $
*********************************************************************/
#ifndef chordBundle_H_
#define chordBundle_H_

// \file chordBundle.h 
// \brief Contains the declaration of the DtChordBundle class.

#include "geometry/geometryDefines.h"
#include <string.h>
#include "geometry/extent.h"
#include "geometry/chord.h"


// \brief This class is a container of DtChords, bundled together for efficiency.
//
// Instances of DtChordBundle are collections of similar (nearby and probably
// parallel) DtChords that can be used to search GDB terrain databases more
// efficiently than searching with the DtChords one-by-one. 
// DtChordBundles store a fixed number of chords directly, and if more than
// the limit are added, a child bundle is created and appended on the end.
// In order to make the use of this class as efficient as possible (for
// bundles smaller than BUNDLE_SIZE), most of its functions are inlined.
class DT_DLL_geometry DtChordBundle
{
public:
   // The maximum optimal size of a bundle of DtChords.  Larger sizes will be
   // handled correctly, but not as efficiently.
   enum
   {
      BUNDLE_SIZE = 10
   };

   // default constructor
   DtChordBundle();

   // copy constructor
   // Note: the copy constructor only copies the bundle, it does not copy the
   // DtChords pointed to by the bundle.
   DtChordBundle(const DtChordBundle& orig);

   // destructor  Note: it does not delete the DtChords.
   virtual ~DtChordBundle();

   // assignment operator
   // Note: the assignment operator only copies the DtChord pointers, it does
   // not delete its old DtChords, nor does it clone the DtChords being added.
   DtChordBundle& operator=(const DtChordBundle& orig);

   // Get a particular DtChord pointer from the list
   const DtChord* operator[](unsigned int index) const;

   // addToEnd appends a DtChord pointer to the end of the bundle's chord
   // pointer list.
   void addToEnd(const DtChord* arg);

   // removeAll empties the list.  Note: it does not delete the DtChords.
   virtual void removeAll();
   
   // Get the total count of DtChords stored in (or below) this bundle.
   unsigned int count() const;

   // Get the extents of this bundle.
   const DtExtent& extent() const;

protected:
   // This function is similar to operator[], except that it is not inline
   const DtChord* item(unsigned int index);

   DtChordBundle* clone();

protected:
   // An array of pointers to the DtChords in this bundle
   const DtChord* myChordArray[BUNDLE_SIZE];

   // The total count of DtChords in this and child bundles
   unsigned int myCount;

   // A pointer to the first child bundle (only used if more than BUNDLE_SIZE
   // chords have been added)
   DtChordBundle* myNextBundle;

   // An extents box that contains all the chords added to this bundle
   DtExtent myExtent;
};

//
// Inline functions
//
inline DtChordBundle::DtChordBundle() :
   myCount(0),
   myNextBundle(0),
   myExtent()
{
   memset(myChordArray, 0, sizeof(myChordArray));
}

inline DtChordBundle::DtChordBundle(const DtChordBundle& orig) :
   myCount(orig.myCount),
   myNextBundle(0),
   myExtent(orig.myExtent)
{
   memcpy(myChordArray, orig.myChordArray, sizeof(myChordArray));

   if (orig.myNextBundle != 0)
   {
      myNextBundle = orig.myNextBundle->clone();
   }
}

inline DtChordBundle::~DtChordBundle() 
{
   if (myNextBundle != 0)
   {
      delete myNextBundle;
      myNextBundle = 0;
   }
}

inline const DtChord* DtChordBundle::operator[](unsigned int index) const
{
   if (index < BUNDLE_SIZE)
   {
      return myChordArray[index];
   }
   else if (myNextBundle == 0)
   {
      return 0;
   }
   else
   {
      return myNextBundle->item(index - BUNDLE_SIZE);
   }
}

inline void DtChordBundle::addToEnd(const DtChord* arg)
{
   if (arg == 0)
   {
      return;
   }

   myExtent.expandToInclude(arg->extent());

   if (myCount < BUNDLE_SIZE)
   {
      myChordArray[myCount++] = arg;
      return;
   }

   if (myCount == BUNDLE_SIZE)
   {
      myNextBundle = new DtChordBundle();
   }

   myNextBundle->addToEnd(arg);
}

inline unsigned int DtChordBundle::count() const
{
   return myCount;
}

inline const DtExtent& DtChordBundle::extent() const
{
   return myExtent;
}

#endif