include/geometry/ssFunctor.h

Go to the documentation of this file.

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

#include "geometry/spatialSubdivision.h"

//
// This is the base class for spatial subdivision related functors. 
// For efficiency and flexibility, the spatial subdivision intersectors use 
// functors as a parameter to some of their intersection functions.  The functors
// are applied to the intersection results, with the intersector determining the
// specific parameters.
// For more information on the usage of the functors, see the specific 
// spatial subdivision intersectors.

// IMPORTANT:
// The functors are different from standard library functors in two important ways.
// 1) The SS Functors return value expresses whether or not the functors are done
// processing, @b not whether or not an error occurred.  When an intersector is
// applying the functor to the intersection results, a return value of true
// means that the intersector no longer needs to apply the functor.
// The benefit of this is efficiency - functors that have found what they are looking
// for (or whatever else signals done processing) do have to be applied anymore.
// The drawback of this approach is a slightly tighter coupling between the 
// ss intersectors and the functors (the functors know more about the intersectors
// then they should.
// 
// With regards to error handling, either the functors should be designed to 
// not have errors (other than a few exceptional cases, such as out of memory),
// or some other error handling mechanism should be used (exceptions, internal 
// error state, etc.) 
//
// 2) The functors expect themselves to be passed by @ reference.  This is very 
// important as it is different from the standard practice of passing functors 
// by value.  This is done because of the need for some functors to maintain complicated
// internal state, which makes copying inefficient and lifecycle management of hte
// internal state, such as by using pointers, complicated.
// 
template <typename S, typename T>
class DtSsFunctor
{
public:
   DtSsFunctor();
   virtual ~DtSsFunctor();

   // @returns Always returns true as this functor does nothing.
   virtual bool operator()(S& item, T& item2);

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

};

//------------------------------------------------------
//  INLINE METHODS
//------------------------------------------------------
template <typename S, typename T>
DtSsFunctor<S, T>::DtSsFunctor()
{
}

template <typename S, typename T>
DtSsFunctor<S, T>::~DtSsFunctor()
{
}

template <typename S, typename T>
bool DtSsFunctor<S, T>::operator()(S& item, T& item2) 
{ 
   return true;
};


#endif