Reconstruction/MdcPatRec/TrkBase/include/TrkBase/TrkFunctors.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: TrkFunctors.h,v 1.2 2007/11/13 07:27:23 codeman Exp $
//
// Description:
//      general, simple tracking predicates
//
//      All classes (or structs) here should inherit from either
//      unary_function< X, Z> or binary_function<X,Y,Z> and
//      provide Z operator()(const X&,const Y&) const.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Gerhard Raven
//------------------------------------------------------------------------
#ifndef TRKFUNCTORS_H
#define TRKFUNCTORS_H
#include <functional>
 
#include "TrkBase/TrkErrCode.h"
#include "TrkBase/TrkHitOnTrk.h"
class TrkHitOnTrkUpdater;
class TrkRep;
 
namespace TrkBase {
  namespace Functors {
 
    class cloneHot : public std::unary_function<TrkHitOnTrk, TrkHitOnTrk*> {
    public:
      cloneHot( TrkRep* parentRep, const TrkDifTraj* trkTraj = 0 )
          : _r( parentRep ), _t( trkTraj ) {}
 
      TrkHitOnTrk* operator()( const TrkHitOnTrk& h ) const { return h.clone( _r, _t ); }
 
    private:
      TrkRep*           _r;
      const TrkDifTraj* _t;
    };
 
    template <class T> struct takeAddress : std::unary_function<T, T*> {
      T* operator()( T& t ) { return &t; }
    };
 
    // Functors which are only accessible by inheriting from TrkHitOnTrkUpdater
    // FIXME: maybe these should live in the TrkHitOnTrkUpdater namespace instead???
 
    class updateMeasurement : public std::unary_function<TrkHitOnTrk, TrkErrCode> {
    public:
      TrkErrCode operator()( TrkHitOnTrk& h ) const { return h.updateMeasurement( _t, _m ); }
 
    private:
      // Only TrkHitOnTrkUpdater can create one of these...
      friend class ::TrkHitOnTrkUpdater;
      updateMeasurement( const TrkDifTraj* traj = 0, bool maintainAmbiguity = false )
          : _t( traj ), _m( maintainAmbiguity ) {}
      const TrkDifTraj* _t;
      bool              _m;
    };
 
    class setActive : public std::unary_function<TrkHitOnTrk, void> {
    public:
      TrkHitOnTrk* operator()( TrkHitOnTrk& h ) const { return h.setActive( _a ); }
      TrkHitOnTrk* operator()( TrkHitOnTrk*& h ) const { return h->setActive( _a ); }
 
    private:
      // Only TrkHitOnTrkUpdater can create one of these...
      friend class ::TrkHitOnTrkUpdater;
      setActive( bool active ) : _a( active ) {}
      bool _a;
    };
 
    class setParent : public std::unary_function<TrkHitOnTrk, void> {
    public:
      TrkHitOnTrk* operator()( TrkHitOnTrk& h ) const { return h.setParent( _p ); }
 
    private:
      // Only TrkHitOnTrkUpdater can create one of these...
      friend class ::TrkHitOnTrkUpdater;
      setParent( TrkRep* parent ) : _p( parent ) {}
      TrkRep* _p;
    };
  } // namespace Functors
} // namespace TrkBase
#endif