SourceObj.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"
//-------------------------------------------------------------------------


///SourceObj.cpp
///  simian core

#include "SourceObj.h"
#include <mathGutz.h>

///////////////////////////////////////////////////////////////////////////
/// Construction
///////////////////////////////////////////////////////////////////////////
SourceObj::SourceObj()
:SourceObjIF(),
 _outputs(0),
 _nOutputs(0)
{

}

SourceObj::SourceObj(unsigned int numOutputs)
:SourceObjIF(),
 _outputs(0),
 _nOutputs(0)
{
   setNumOutputs(numOutputs);
}

SourceObj::SourceObj(unsigned int numInputs, unsigned int numOutputs)
:SourceObjIF(numInputs),
 _outputs(0),
 _nOutputs(0)
{
   setNumOutputs(numOutputs);
}

///////////////////////////////////////////////////////////////////////////
/// Destruction
///////////////////////////////////////////////////////////////////////////
SourceObj::~SourceObj()
{
   if(_outputs)
      delete[] _outputs;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Public Execute Interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Execute if anything changed
///////////////////////////////////////////////////////////////////////////
void SourceObj::execute()
{
   AlgObj::execute();
   updateOutputs();
}

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

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Request Interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

bool SourceObj::request(DataObjSP d)
{
   if(_forward)
   {
      derr("request(), marked forward modified");
      return false;
   }

   /// how could this happen?
   /// shouldn't get a request for data we don't own
   if(!isOutput(d))
   {
      derr("request(), dataObject is not an output");
      /// it's ready, cuz we don't know about it
      return true;
   }
   /// how could this happen? 
   /// we should be forward too!
   if(!checkInputs())
   {
      derr("request(), inputs not ready, but this module is??");
      return false;
   }
   /// how could this happen?
   /// we have been changed, better update
   /// but not if we are a true source!
   if(_modified)
   {
      //derr("request(), we were modified but data was ready");
      execute();
   }

   return true;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Framework interfaces
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void SourceObj::setForwardModified()
{
   _forward = true;
   for(int i=0; i<_nOutputs; ++i)
   {
      if(!_outputs[i].isNull())
      {
         /// only forward modify if we have to
         if(!_outputs[i]->isForwardModified())
         {
            _outputs[i]->setForwardModified();
         }
      }
      else
      {
         derr("setForwardModified(), null DataObj encountered");
      }
   }
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Protected Member functions
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void SourceObj::updateOutputs()
{
   //if(_updating) /// TODO: debug check, loop reporter
   //{
   //   derr("updateOuputs(), loop detected");
   //}
   _updating = true;
   /// for each output, send forward notification
   for(int i=0; i<_nOutputs; ++i)
   {
      /// error check
      if(!_outputs[i].isNull())
      {
         /// if it was changed
         if(_outputs[i]->isModified())
         {
            /// mark it for update
            _outputs[i]->setForwardModified();
         }
         else /// output unmodified, debug output
         {
            //derr("updateOutputs(), skipping un-modified output");
         }
      }
      else /// output was null, report it
      {
         derr("updateOutputs(), null DataObj encountered");
      }
   }

   /// now update each output
   for(int i=0; i<_nOutputs; ++i)
   {
      /// error check, always!
      if(!_outputs[i].isNull())
      {
         /// skip unodified outputs
         if(_outputs[i]->isModified())
         {
            ///derr("updateOutputs()");
            /// update the output
            _outputs[i]->update_ ();
         }
      }
   }
   _updating = false;
}

///////////////////////////////////////////////////////////////////////////
/// Set Number Outputs
///////////////////////////////////////////////////////////////////////////
void SourceObj::setNumOutputs(int nOut)
{
   if(_nOutputs == nOut) return;

   DataObjSP *outNew = 0;
   if(nOut)
      outNew = new DataObjSP[nOut];

   /// copy old outputs
   for(int i=0; i<_nOutputs && i<nOut; ++i)
   {
      outNew[i] = _outputs[i];
   }
   
   /// unset any (about to be) nuked outputs
   for(int i=gutz::g_max(nOut-1,0); i<_nOutputs; ++i)
   {
      if(!_outputs[i].isNull())
         _outputs[i]->setSource(SourceObjSP());
   }

   if(_outputs)
      delete[] _outputs;
   _outputs = outNew;
   _nOutputs = nOut;

}

///////////////////////////////////////////////////////////////////////////
/// set Output number "N"
///////////////////////////////////////////////////////////////////////////
void SourceObj::setOutputN(int outNum, DataObjSP d)
{
   if(d.isNull())
   {
      derr("setOutputN(), setting null DataObj output!!");
      return;
   }
   if(outNum >= _nOutputs)
   {
      setNumOutputs(outNum+1);
   }

   _outputs[outNum] = d;
   d->setSource(SourceObjSP(this));
}

///////////////////////////////////////////////////////////////////////////
/// get Output number "N"
///////////////////////////////////////////////////////////////////////////
DataObjIF *SourceObj::getOutputN(int outNum)
{
   if(outNum >= _nOutputs)
   {
      derr("getOutputN(), index greater than number of outputs");
      return 0;
   }
   return _outputs[outNum].getPtr();
}

///////////////////////////////////////////////////////////////////////////
/// add Output
///////////////////////////////////////////////////////////////////////////
void SourceObj::addOutput(DataObjSP d)
{
   if(d.isNull())
   {
      derr("addOutput(), setting null DataObj output!!");
      return;
   }
   setOutputN(_nOutputs,d);
}

///////////////////////////////////////////////////////////////////////////
/// del Output
///////////////////////////////////////////////////////////////////////////
void SourceObj::delOutput(DataObjSP d)
{
   if(!isOutput(d))
   {
      derr("delOutput(), DataObj is not an output.");
      return;
   }
  
   DataObjSP *outNew = new DataObjSP[_nOutputs - 1];

   int idx = 0;
   for(int i=0; i<_nOutputs; ++i)
   {
      if(d != _outputs[i])
      {
         outNew[idx] = _outputs[i];
         ++idx;
      }
   }

   d->setSource(SourceObjSP());
   delete[] _outputs;
   _outputs = outNew;
   --_nOutputs;

}

///////////////////////////////////////////////////////////////////////////
/// is Output
///////////////////////////////////////////////////////////////////////////
bool SourceObj::isOutput(const DataObjSP d) const
{
   if(d.isNull()) return false;
   for(int i=0; i<_nOutputs; ++i)
   {
      if(_outputs[i] == d)
      {
         return true;
      }
   }
   return false;
}

---

Send questions, comments, and bug reports to: