BaseCut.C

Go to the documentation of this file.

#include "BaseCut.h"
#include "BaseCutHelpers.h"
#include "FillIterator.h"

#include <cassert>
#include <stdio.h>
#include <cstring>
#include <iostream>

static const char *ident="@(#)$Id: BaseCut.C,v 1.7 2005/07/08 15:01:34 blist Exp $";

FloatFun& BaseCut::Float () const {
  return *new FloatBaseCut(*this);
}

IntFun& BaseCut::Int () const {
  return *new IntBaseCut(*this);
}

FloatBaseCut::FloatBaseCut (const BaseCut& theBaseCut_, const char *name_) 
: FloatFun (name_ ? name_ : std::string("float(")+theBaseCut_.getName()+")"),
  theBaseCut (theBaseCut_) 
{}

IntBaseCut::IntBaseCut (const BaseCut& theBaseCut_, const char *name_) 
: IntFun (name_ ? name_ : std::string("int(")+theBaseCut_.getName()+")"),
  theBaseCut (theBaseCut_) 
{}

   
TwoCutCompound::TwoCutCompound (const BaseCut& lhs_, const std::string opname_, const BaseCut& rhs_) 
: BaseCut (str('(')+lhs_.getName()+')'+opname_+'('+rhs_.getName()+')'), 
  lhs (lhs_), 
  rhs (rhs_)
{}

TwoCutCompound::TwoCutCompound (const BaseCut& lhs_, const BaseCut& rhs_, const std::string name_) 
: BaseCut (name_), 
  lhs (lhs_), 
  rhs (rhs_)
{}


const FillIterator *TwoCutCompound::getIterator() const { 
  assert (!lhs.getIterator() || !rhs.getIterator() || lhs.getIterator()==rhs.getIterator());
  return (lhs.getIterator()) ? lhs.getIterator() : rhs.getIterator();
}
   
OneCutCompound::OneCutCompound (const std::string& funname_, const BaseCut& arg_) 
: BaseCut (funname_+'('+arg_.getName()+')'), 
  arg (arg_)
{}

OneCutCompound::OneCutCompound (const BaseCut& arg_, const std::string& name_) 
: BaseCut (name_), 
  arg (arg_)
{}

CachedBaseCut::CachedBaseCut (const ROListPoR& rol,
                              const BaseCut&  arg_ 
                             )
: BaseCut (std::string("cached(")+arg_.getName()+')'), 
  CachedO (rol), 
  arg(arg_), 
  cacheValid (false)                    
{}   

CachedBaseCut::CachedBaseCut (const ROListPoR& rol,
                              const BaseCut&  arg_,
                              const std::string& name_ 
                             )
: BaseCut (name_), 
  CachedO (rol), 
  arg(arg_), 
  cacheValid (false)                    
{}   

bool CachedBaseCut::operator() () const {
  if (!cacheValid) {
    cachedValue = arg();
    cacheValid = true;
  }
  return cachedValue;
}

CachedBaseCutIt::CachedBaseCutIt (const ROListPoR&     rol, 
                                  const BaseCut&      arg_, 
                                  const FillIterator&  iter_ 
                                 )
: BaseCut (std::string("cached(")+arg_.getName()+')'),
  CachedO (rol),
  arg (arg_), 
  iter (iter_), 
  cacheValid (), 
  cachedValues ()              
{} 
  
CachedBaseCutIt::CachedBaseCutIt (const ROListPoR&     rol, 
                                  const BaseCut&      arg_
                                 )
: BaseCut (std::string("cached(")+arg_.getName()+')'),
  CachedO (rol),
  arg (arg_), 
  iter (*(arg_.getIterator())), 
  cacheValid (), 
  cachedValues ()              
{
  assert (&iter);
}   

CachedBaseCutIt::CachedBaseCutIt (const ROListPoR&     rol, 
                                  const BaseCut&       arg_, 
                                  const FillIterator&  iter_,
                                  const std::string  & name_ 
                                 )
: BaseCut (name_),
  CachedO (rol),
  arg (arg_), 
  iter (iter_), 
  cacheValid (), 
  cachedValues ()              
{} 
  
CachedBaseCutIt::CachedBaseCutIt (const ROListPoR&    rol, 
                                  const BaseCut&      arg_,
                                  const std::string&  name_ 
                                 )
: BaseCut (name_),
  CachedO (rol),
  arg (arg_), 
  iter (*(arg_.getIterator())), 
  cacheValid (), 
  cachedValues ()              
{
  assert (&iter);
}   

bool CachedBaseCutIt::operator() () const {
  int i = iter();
  assert (i >= 0);
  if (static_cast<unsigned int>(i) >= cacheValid.size()) growCache (i+1); 
  if (!cacheValid[i]) {
    cacheValid[i] = true;
    cachedValues[i] = arg();
  }
  return cachedValues[i];
}

void CachedBaseCutIt::growCache (unsigned int s) const {
  unsigned int oldsize = cacheValid.size();
  if (s < oldsize) return;
  cacheValid.resize (s);
  cachedValues.resize(s);
  for (unsigned int i = oldsize; i < s; ++i) cacheValid[i] = false;
}

BaseCut& cached (const ROListPoR&   rol,    
                  const BaseCutPoR& cut,    
                  const FillIteratorPoR& iter
                 ) {
  assert (cut.pbc);                     
  if (iter.pfi) return *new CachedBaseCutIt (rol, *cut.pbc, *iter.pfi);
  if (const FillIterator *fi = cut.pbc->getIterator()) 
    return  *new CachedBaseCutIt (rol, *cut.pbc, *fi);
  return *new CachedBaseCut (rol, *cut.pbc);                  
}
    

// External functions that implement logical operators between
// BaseCut objects, so that we can write e.g. "cuta && (cutb || !cutc)"

BaseCut& operator&& (const BaseCut& lhs_, const BaseCut& rhs_) {
  return *new AndOfTwoCuts (lhs_, rhs_);
}

BaseCut& operator|| (const BaseCut& lhs_, const BaseCut& rhs_) {
  return *new OrOfTwoCuts (lhs_, rhs_);
}

BaseCut& operator! (const BaseCut& rhs_) {
  return *new NotOfACut (rhs_);
}

FloatFun& Float (const BaseCut& arg) {
  return *new FloatBaseCut(arg);
}

IntFun& Int (const BaseCut& arg) {
  return *new IntBaseCut(arg);
}

---