include/gdb/ssAnyIntersectionsFunctor.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2005 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: ssAnyIntersectionsFunctor.h,v $ $Revision: 1.4 $ $State: Exp $
*********************************************************************/
#ifndef ssAnyIntersectionFunctor_H_
#define ssAnyIntersectionFunctor_H_

#include <vlutil/vlConfig.h> 
#include "geometry/spatialSubdivision.h"
#include "geometry/ssFunctor.h"

#include "geometry/chrdIntRec.h"
#include "gdb/gdbNode.h"
#include <assert.h>

//
// A functor intended for use with the spatial subdivision set of classes.  It's 
// primary usage is to intersect the first parameter into the second.  
// 
// Expected usage:
// When passed to the intersection objects intersection functions, this functor 
// intersects the first item into the second one.  Used primarily for intersecting the
// different spatial sorted elements into their appropriate spatial subdivisions.
// For an example, see the gdbNode intersecter class.
// 
template <typename TypeToIntersect, typename Container>
class DtSsAnyIntersectionFunctor : public DtSsFunctor<TypeToIntersect, Container>
{
public:
   // Constructor
   DtSsAnyIntersectionFunctor();

   // Destructor
   virtual ~DtSsAnyIntersectionFunctor();

private:
   // not implemented
   DtSsAnyIntersectionFunctor(const DtSsAnyIntersectionFunctor& original);   
   DtSsAnyIntersectionFunctor& operator=(const DtSsAnyIntersectionFunctor& original);

public:
   // Function operator - when applied intersects the first element with the
   // second element.
   // @param itemToIntersect The item to intersect into the second parameter.
   // @param container The container of elements into which to intersect the first
   // parameter.
   //
   // @returns Always returns false as it is never done processing - it can
   // always continue intersecting elements.
   virtual bool operator()(TypeToIntersect& itemToIntersect, Container& container);

   virtual DtChordIntersectionRecord* intersectionRecord() const;

   virtual void setIntersectionRecord(DtChordIntersectionRecord* newIntersectionRecord);

   virtual DtGdbNode::DtIntersectRecordType intersectionRecordType() const;

   virtual void setIntersectionRecordType(
      DtGdbNode::DtIntersectRecordType& newIntersectionRecordType);


private:

   DtChordIntersectionRecord*        myIntersectionRecord;
   DtGdbNode::DtIntersectRecordType myIntersectionRecordType;
};


//------------------------------------------------------
//  INLINE METHODS
//------------------------------------------------------
template <typename TypeToIntersect, typename Container>
DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::DtSsAnyIntersectionFunctor()
: DtSsFunctor<TypeToIntersect, Container>()
, myIntersectionRecord(0)
, myIntersectionRecordType(DtGdbNode::IRT_IPOINT)
{
}


template <typename TypeToIntersect, typename Container>
DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::~DtSsAnyIntersectionFunctor()
{
}

template <typename TypeToIntersect, typename Container>
bool DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::operator()
   (TypeToIntersect& itemToIntersect, Container& containerToIntersect) 
{
   bool retVal = false;
   
   assert(myIntersectionRecord != 0);

   typename Container::iterator iter = containerToIntersect.begin();
   typename Container::iterator endIter = containerToIntersect.end();
   for (; iter != endIter, !retVal; ++iter)
   {
      if ((*iter)->intersect(itemToIntersect, *myIntersectionRecord, myIntersectionRecordType))
      {
         assert(myIntersectionRecord->intersectionFound());
         retVal = true;
      }
   }

   return retVal;
}


template <typename TypeToIntersect, typename Container>
DtChordIntersectionRecord* 
DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::intersectionRecord() const
{
   return myIntersectionRecord;
}


template <typename TypeToIntersect, typename Container>
void DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::
setIntersectionRecord(DtChordIntersectionRecord* newIntersectionRecord)
{
   assert(newIntersectionRecord != 0);
   myIntersectionRecord = newIntersectionRecord;
}


template <typename TypeToIntersect, typename Container>
DtGdbNode::DtIntersectRecordType 
DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::intersectionRecordType() const
{
   return myIntersectionRecordType;
}

template <typename TypeToIntersect, typename Container>
void DtSsAnyIntersectionFunctor<TypeToIntersect, Container>::
setIntersectionRecordType(DtGdbNode::DtIntersectRecordType& newIntersectionRecordType) 
{  
   myIntersectionRecordType = newIntersectionRecordType;
}

#endif