ssAccumulationFunctor.h

Go to the documentation of this file.

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

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

//
// A functor intended for use with the spatial subdivision set of classes.  It's 
// primary usage is to accumulate pointers to elements in its internal container, 
// The type pointed to is the second template parameter of the functor.  
// Expected usage:
// When passed to the intersection functions, it accumulates pointers to the 
// second parameter to its function operator in its internal container. For example
// it will build up a list of all cells that intersect a given primitive when 
// passed into an ss intersection object.  (for example, in the terrain inserter 
// class.)
// 
template <typename IgnoredType, typename ContainedType>
class DtSsAccumulationFunctor: public DtSsFunctor<IgnoredType, ContainedType>
{
public:
   // Typedefs used by the functor
   // This functor currently uses a vector as container of accumulated elements.
   typedef std::vector<ContainedType*> DtAccumulationContainer;
   
   // Constructor
   DtSsAccumulationFunctor();

   // Destructor
   virtual ~DtSsAccumulationFunctor();

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

public:
   // Accumulates the second parameter in the internal container
   // The first parameter, ignoredItem, is ignored by this functor.
   // 
   // @returns This functor is never "done processing" and so it always returns false.
   // 
   // @note This is intended to be used with the spatial subdivision intersectors,
   // where the second parameter is the subdivision cell result from an intersection test.
   virtual bool operator()(IgnoredType& ignoredItem, ContainedType& itemToAccumulate);

   // Get/Set the container of accumulated items
   // @{
   virtual DtAccumulationContainer& container();
   virtual void setContainer(DtAccumulationContainer& newContainer);
   // @}

private:
   DtAccumulationContainer myContainer;
};


//------------------------------------------------------
//  INLINE METHODS
//------------------------------------------------------
template <typename IgnoredType, typename ContainedType>
DtSsAccumulationFunctor<IgnoredType, ContainedType>::DtSsAccumulationFunctor()
: DtSsFunctor<IgnoredType, ContainedType>()
, myContainer()
{
}


template <typename IgnoredType, typename ContainedType>
DtSsAccumulationFunctor<IgnoredType, ContainedType>::~DtSsAccumulationFunctor()
{
}


template <typename IgnoredType, typename ContainedType>
bool DtSsAccumulationFunctor<IgnoredType, ContainedType>::operator()(IgnoredType& ignoredItem, ContainedType& itemToAccumulate)
{
   // Ignore the first parameter as this functor only accumulates the second.
   container().insert(container().end(), &itemToAccumulate);
   
   // Always returns false, as it is never "done" processing.
   return false;
}


template <typename IgnoredType, typename ContainedType>
typename DtSsAccumulationFunctor<IgnoredType, ContainedType>::DtAccumulationContainer& DtSsAccumulationFunctor<IgnoredType, ContainedType>::container() 
{ 
   return myContainer; 
};


template <typename IgnoredType, typename ContainedType>
void DtSsAccumulationFunctor<IgnoredType, ContainedType>::setContainer(typename DtSsAccumulationFunctor<IgnoredType, ContainedType>::DtAccumulationContainer& newContainer) 
{ 
   myContainer = newContainer; 
};

#endif