AlgObj.cpp

Go to the documentation of this file.

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

///AlgObj.cpp
/// simian core

#include "AlgObj.h"
#include "DataObj.h"
#include "SourceObj.h"

///////////////////////////////////////////////////////////////////////////
/// Construction
///////////////////////////////////////////////////////////////////////////
AlgObj::AlgObj()
:AlgObjIF(),
 _inputs(0),
 _nInputs(0)
{

}

AlgObj::AlgObj(unsigned int numInputs)
:AlgObjIF(),
 _inputs(0),
 _nInputs(0)
{
   setNumInputs(numInputs);
}


AlgObj::~AlgObj()
{
   if(_inputs)
      delete[] _inputs;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Execute Interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Execute if anything changed
///////////////////////////////////////////////////////////////////////////
void AlgObj::execute()
{
   //derr("execute()");

   /// if update was called, this is a duplicate,
   /// Let's just assume we don't have a millon inputs
   if(!checkInputs())
   {
      derr("execute(), inputs not ready!!");
   }

   //derr("execute(), after check inputs");

   //if(_updating)/// TODO: debug loop check
   //{
   //   derr("execute(), loop detected");
   //}
   
   if(inputsModified()) _modified = true;

   if(_modified)
   {
      //derr("execDef->");
      execDef();
      _modified = false;
   }
}

///////////////////////////////////////////////////////////////////////////
/// Execute no matter what!
///////////////////////////////////////////////////////////////////////////
void AlgObj::force()
{
   if(!checkInputs())
   {
      derr("force(), inputs not ready, deffering execution");
      _modified = true;
      return;
   }
   execDef();
   _modified = false;
   _forward = false;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Update Interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Update Data object
///////////////////////////////////////////////////////////////////////////
void AlgObj::update_(DataObjSP d)
{
   /// must mark forward!!!
   if(!_forward) return;
   _modified = true;
   if(!checkInputs())
   {
      //derr("update_(DataObjSP), inputs not ready, differing exectution");
      return;
   }
   execute();
   /// not forward no more
   _forward = false;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Protected Member Functions
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// check if we have modified inputs
///////////////////////////////////////////////////////////////////////////
bool AlgObj::inputsModified()
{
   for(int i=0; i<_nInputs; ++i)
   {
      if(!_inputs[i].isNull())
      {  
         if(_inputs[i]->isModified())
         {
            derr("inputs modified()");
            return true;
         }
      }
   }
   return false;
}

///////////////////////////////////////////////////////////////////////////
/// Check inputs
///////////////////////////////////////////////////////////////////////////
bool AlgObj::checkInputs()
{
  // check each input
   for(int i=0; i<_nInputs; ++i) 
   {
      // null pointers are bad!
      if(!_inputs[i].isNull()) 
      {
         // see if the request was successfull
         if(!_inputs[i]->request_()) 
         {
            return false;  // request failed
         }
      }
      else // null pointer, report it
      {
         derr("request(), null DataObj encountered");
      }
   }
   /// everything checked out so we must be ok
   return true;
}

///////////////////////////////////////////////////////////////////////////
/// Add Input
///////////////////////////////////////////////////////////////////////////
void AlgObj::addInput(DataObjSP d)
{
   if(d.isNull())
   {
      derr("addInput(), attempting to add NULL input");
      return;
   }
   setInputN(_nInputs, d);
}

///////////////////////////////////////////////////////////////////////////
/// Del Input
///////////////////////////////////////////////////////////////////////////
void AlgObj::delInput(DataObjSP d)
{
   if(!isInput(d))
   {
      derr("delInput(), DataObject is not input");
      return;
   }
   
   DataObjSP *objNew = new DataObjSP[_nInputs - 1];
   int idx = 0;
   for(int i=0; i<_nInputs; ++i)
   {
      if(d != _inputs[i])
      {
         objNew[idx] = _inputs[i];
         ++idx;
      }
   }

   d->delConsumer(SimModObjSP(this));

   delete[] _inputs;
   _inputs = objNew;
   --_nInputs;
}

///////////////////////////////////////////////////////////////////////////
/// isInput
///////////////////////////////////////////////////////////////////////////
bool AlgObj::isInput(const DataObjSP d) const
{
   if(d.isNull()) return false;
   for(int i=0; i<_nInputs; ++i)
   {
      if(d == _inputs[i]) return true;
   }
   return false;
}

///////////////////////////////////////////////////////////////////////////
/// SetNumInputs
///////////////////////////////////////////////////////////////////////////
void AlgObj::setNumInputs(int nInputs)
{
   if(nInputs == _nInputs) /// nothing to do
   {
      return;
   }
   /// create new input array
   DataObjSP *inputsNew = new DataObjSP[nInputs];
   
   /// copy old inputs
   for(int i=0; i<nInputs && i<_nInputs; ++i)
   {
      inputsNew[i] = _inputs[i];
   }

   /// nuke old input array
   delete[] _inputs;

   /// set new array
   _inputs = inputsNew;
   _nInputs = nInputs;

}

///////////////////////////////////////////////////////////////////////////
/// Set Input "N"
///////////////////////////////////////////////////////////////////////////
void AlgObj::setInputN(int inNum, DataObjSP d)
{
   if(d.isNull())
   {
      derr("setInputN(), attempting to set a null input!!");
      return;
   }
   if(inNum >= _nInputs)
   {
      setNumInputs(_nInputs + 1);
   }

   _inputs[inNum] = d;
   d->addConsumer(SimModObjSP(this));
}

///////////////////////////////////////////////////////////////////////////
/// Get Input "N"
///////////////////////////////////////////////////////////////////////////
DataObjIF *AlgObj::getInputN(int inNum)
{
   if(inNum >= _nInputs)
   {
      derr("getInputN(), index number greater than number of inputs");
      return 0;
   }
   return _inputs[inNum].getPtr();
}

---

Send questions, comments, and bug reports to: