Crank.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     3-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// Crank.cpp


#include "Crank.h"
#include "EnvKeys.h"
#include <mathGutz.h>

using namespace glift;
using namespace gutz;
using namespace std;


////////////////////////////////////////////////////
////////////////////////////////////////////////////
//// meta program management.
////////////////////////////////////////////////////
////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////
/// add MP
///////////////////////////////////////////////////////////////////
int        Crank::addMP(MetaProgSP m)
{
   if(checkKind(m))
   {
      kindErr("addMP()");
      return -1;
   }
   _mprogs.push_back(m);
   return int(_mprogs.size()) - 1;
}

///////////////////////////////////////////////////////////////////
/// insert MP
///////////////////////////////////////////////////////////////////
int        Crank::insertMP(int idx, MetaProgSP m)
{
   if(checkKind(m))
   {
      kindErr("addMP()");
      return -1;
   }
   if(idx >= int(_mprogs.size()))
   {
      _mprogs.resize(idx+1,MetaProgSP(0));
   }
   _mprogs[idx] = m;
   return idx;
}

///////////////////////////////////////////////////////////////////
/// get MP by name
///////////////////////////////////////////////////////////////////
void       Crank::setMP(SNameType name, MetaProgSP m)
{
   if(checkKind(m))
   {
      kindErr("setMP");
      return;
   }
   int idx = getMPIdx(name);
   if(-1 == idx)
   {
      derr("setMP(), meta-prog not found ", name.c_str());
      return;
   }
   _mprogs[idx] = m;
}

///////////////////////////////////////////////////////////////////
/// set by index
///////////////////////////////////////////////////////////////////
void       Crank::setMP(int idx, MetaProgSP m)
{
   if(checkKind(m))
   {
      kindErr("setMP");
      return;
   }
   if(idx >= int(_mprogs.size()) || idx < 0)
   {
      derr("setMP(), index out of bounds", 0, idx);
      return;
   }
   _mprogs[idx] = m;
}

///////////////////////////////////////////////////////////////////
/// get by index
///////////////////////////////////////////////////////////////////
MetaProgSP Crank::getMP(int idx)
{
   if(idx >= int(_mprogs.size()) || idx < 0)
   {
      derr("getMP(), index out of bounds", 0, idx);
      return MetaProgSP(0);
   }
   return _mprogs[idx];
}

MetaProgSP Crank::getMP(SNameType name)
{
   return getMP(getMPIdx(name));
}

///////////////////////////////////////////////////////////////////
/// get index by name
///////////////////////////////////////////////////////////////////
int        Crank::getMPIdx(SNameType name)
{
   bool found = false;
   int i = 0;
   for(i=0; i<int(_mprogs.size()); ++i)
   {
      if(_mprogs[i].isNull()) continue;
      if(_mprogs[i]->getName() == name)
      {
         found = true;
         break;
      }
   }
   if(found) return i;
   
   derr("getMPIdx(), name not found", name.c_str());
   return -1;
}

///////////////////////////////////////////////////////////////////
/// get index by reference
///////////////////////////////////////////////////////////////////
int        Crank::getMPIdx(MetaProgSP m)
{
   bool found = false;
   MetaProgSPVecIter mpi = _mprogs.begin();
   int i;
   for(i=0; i<int(_mprogs.size()); ++i)
   {
      if(_mprogs[i].isNull()) continue;
      if(_mprogs[i] == m)
      {
         found = true;
         break;
      }
   }

   if(found) return i;
   derr("getMPIdx(), meta-prog not found");
   return -1;
}

///////////////////////////////////////////////////////////////////
/// del by index
///////////////////////////////////////////////////////////////////
MetaProgSP Crank::delMP(int idx)
{
   if(idx >= int(_mprogs.size()) || idx < 0)
   {
      derr("delMP(), index out of bounds ", 0, idx);
      return MetaProgSP(0);
   }
   MetaProgSP ret = getMP(idx);
   _mprogs.erase(_mprogs.begin() + idx);
   return ret;
}

///////////////////////////////////////////////////////////////////
/// del by index
///////////////////////////////////////////////////////////////////
MetaProgSP Crank::delMP(SNameType name)
{
   return delMP(getMPIdx(name));
}

///////////////////////////////////////////////////////////////////
/// del by reference
///////////////////////////////////////////////////////////////////
MetaProgSP Crank::delMP(MetaProgSP m)
{
   return delMP(getMPIdx(m));
}

////////////////////////////////////////////////////
////////////////////////////////////////////////////
//// generic tape management.
////////////////////////////////////////////////////
////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////
/// add tape
///////////////////////////////////////////////////////////////////
void     Crank::addTape(TapeSPVec &v, TapeSP t)
{
   v.push_back(t);
}

///////////////////////////////////////////////////////////////////
/// insert tape
///////////////////////////////////////////////////////////////////
void     Crank::insertTape(TapeSPVec &v, int idx, TapeSP t)
{
   if( idx == v.size() )
   {
      addTape(v, t);
      return;
   }
   if( idx < int(v.size()) )
   {
      TapeSPVecIter ti = v.begin() + idx;
      v.insert(ti, t);
      return;
   }

   derr("insertTape(), warning inserting null tapes", 0, idx - v.size());
   v.resize(idx+1);
   v[idx] = t;
}

///////////////////////////////////////////////////////////////////
/// set tape
///////////////////////////////////////////////////////////////////
void     Crank::setTape(TapeSPVec &v, int i, TapeSP t)
{
   if( i < int(v.size()))
   {
      v[i] = t;
      return;
   }
   else
   {
      derr("setTape(), setting tape out of bounds", 0, i);
      insertTape(v, i, t);
   }
}

///////////////////////////////////////////////////////////////////
/// get tape
///////////////////////////////////////////////////////////////////
TapeSP   Crank::getTape(TapeSPVec &v, int i)
{
   if( i < int(v.size()))
   {
      return v[i];
   }
   else
   {
      derr("getTape(), accessing tape out of bounds", 0, i);
      return TapeSP(0);
   }
}

///////////////////////////////////////////////////////////////////
/// del tape, by index
///////////////////////////////////////////////////////////////////
void     Crank::delTape(TapeSPVec &v, int i)
{
   if( i < int(v.size()))
   {
      v.erase(v.begin() + i);
      return;
   }
   else
   {
      derr("delTape(), deleting tape out of bounds", 0, i);
      return;
   }
}

///////////////////////////////////////////////////////////////////
/// del tape, by value
///////////////////////////////////////////////////////////////////
void     Crank::delTape(TapeSPVec &v, TapeSP t)
{
   bool found = false;
   TapeSPVecIter ti = v.begin();
   while(ti != v.end())
   {
      if((*ti) == t)
      {
         found = true;
         break;
      }
      ++ti;
   }
   if(!found)
   {
      derr("delTape(TapeSP), tape not found, can't delete");
      return;
   }
   v.erase(ti);
}

///////////////////////////////////////////////////////////////////
/// del tape, by value
///   this function mostly adds keys defined in <EnvKeys.h>
///////////////////////////////////////////////////////////////////
GrinderKeysSP Crank::buildFPEnvKeys()
{

   /// create keys
   GrinderKeysSP gkeys;

   /// add environment keys
   gkeys->addKey(EnvKey);

   /// TODO: flesh this out will ya.
      
   return gkeys;
}

///////////////////////////////////////////////////////////////////
/// check if any of the meta-progs changed
///////////////////////////////////////////////////////////////////
bool Crank::mpsChanged()
{
   bool changed = false;
   if(_lastCh.size() != int(_mprogs.size()))
   {
      arrayo1i tmp(_lastCh);
      _lastCh = arrayo1i(_mprogs.size(),-1);
      for(int i=0; i<g_min(tmp.size(),_lastCh.size()); ++i) _lastCh[i] = tmp[i];
      changed = true;
   }

   for(int i=0; i<int(_mprogs.size()); ++i)
   {
      if(_mprogs[i].isNull())
      {
         if(_lastCh[i] != -1)
         {
            changed = true;
            _lastCh[i] = -1;
         }
         continue;
      }
      if(_mprogs[i]->getChangeID() != _lastCh[i])
      {
         _lastCh[i] = _mprogs[i]->getChangeID();
         changed = true;
      }
   }

   return changed;

}

---

Send questions, comments, and bug reports to: