RooAbsCache.cxx

Go to the documentation of this file.

/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 *    File: $Id$
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/
 
/**
\file RooAbsCache.cxx
\class RooAbsCache
\ingroup Roofitcore
 
RooAbsCache is the abstract base class for data members of RooAbsArgs
that cache other (composite) RooAbsArg expressions. The RooAbsCache
interface defines the interaction between the owning RooAbsArg object
and the cache data member to communicate server redirects, operation
mode changes and constant term optimization management calls.
**/
 
 
#include "RooFit.h"
#include "RooAbsCache.h"
#include "RooAbsArg.h"
#include "RooArgList.h"
 
using namespace std;
 
ClassImp(RooAbsCache); 
   ;
 
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor. Takes owner as argument and register cache with owner
 
RooAbsCache::RooAbsCache(RooAbsArg* owner) : _owner(owner) 
{ 
  if (_owner) {
    _owner->registerCache(*this) ; 
  }
} 
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor. Takes owner as argument and registers cache with owne
 
RooAbsCache::RooAbsCache(const RooAbsCache&, RooAbsArg* owner ) : _owner(owner) 
{ 
  if (_owner) {
    owner->registerCache(*this) ; 
  }
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor. Unregisters cache with owner
 
RooAbsCache::~RooAbsCache() 
{ 
  if (_owner) {
    _owner->unRegisterCache(*this) ; 
  }
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Interface for processing of cache mode optimization calls
 
void RooAbsCache::optimizeCacheMode(const RooArgSet& /*obs*/, RooArgSet&, RooLinkedList& ) 
{
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Interface for server redirect calls
 
Bool_t RooAbsCache::redirectServersHook(const RooAbsCollection& /*newServerList*/, Bool_t /*mustReplaceAll*/, Bool_t /*nameChange*/, Bool_t /*isRecursive*/) 
{ 
  return kFALSE ; 
} 
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Interface for operation mode changes
 
void RooAbsCache::operModeHook() 
{
} 
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Interface for constant term node finding calls
 
void RooAbsCache::findConstantNodes(const RooArgSet&, RooArgSet&, RooLinkedList& ) 
{  
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Interface for printing of cache guts in tree mode printing
 
void RooAbsCache::printCompactTreeHook(std::ostream&, const char *)
{
}