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


/// DataObj.cpp
///  core Simian

#include "DataObj.h"
#include "SourceObj.h"
#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////////////////////
/// Construct
///////////////////////////////////////////////////////////////////////////
DataObj::DataObj()
: DataObjIF(),
  _source(),
  _consumers(0),
  _nConsumers(0),
  _noForward(false)
{
}

///////////////////////////////////////////////////////////////////////////
/// Destruct
///////////////////////////////////////////////////////////////////////////
DataObj::~DataObj()
{
   if(_consumers)
   {
      delete[] _consumers;
   }
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Update interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void DataObj::update_()
{
   //if(_updating)///TODO: debug loop detection
   //{
   //   derr("update(), loop detected");
   //}

   _forward = false;
   _updating = true;
   if(_modified)
   {
      _modified = false;
      for(int i=0; i<_nConsumers; ++i)
      {
         if(!_consumers[i].isNull())
         {
            ///derr("updateConsumer()");
            _consumers[i]->update_(DataObjSP((DataObjIF*)this));                 
         }
      }
   }
   _updating = false;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Request Interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
bool DataObj::request_()
{

   /// no reqests pass if we are forward modified
   if(_forward)
   {
      //derr("request(), a backward call when forward marked");
      return false;
   }
   else
   {
      /// this is modified
      if(_modified) 
      {
         /// see if source has work to do   
         if(_source.isNull())
         {
            derr("request(), no source for data!!!");
            return false;
         }
         if(_source->request(DataObjSP(this)))
         {
            /// nope source is good, so are we
            _modified = false;
            return true;
         }
         else 
         {
            /// hmm, can't go we aren't ready
            return false;
         }
      }
      /// not modified, not forward modified,
      /// must be good
      return true;
   }
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Source interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void DataObj::setSource(SourceObjSP source)
{
   if(_source == source) return;
   if(source.isNull())
   {
      derr("setSource(), source is null!");
      return;
   }
   _source = source;
}


///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Consumer interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// add Consumer
///////////////////////////////////////////////////////////////////////////
void  DataObj::addConsumer(SimModObjSP smo)
{
   if(smo.isNull())
   {
      derr("addConsumer(), adding NULL consumer!");
      return;
   }
   if(isConsumer(smo))
   {
      derr("addConsumer(), consumer already in list");
      return;
   }
   SimModObjSP *consumers = new SimModObjSP[_nConsumers + 1];
   //bool        *upCons = new bool[_nConsumers + 1];
   for(int i=0; i<_nConsumers; ++i)
   {
      consumers[i] = _consumers[i];
      //upCons[i]  = _upConsumers[i];
   }
   consumers[_nConsumers] = smo;
   //upCons[_nConsumers] = false;
   delete[] _consumers;
   //delete[] _upConsumers;
   _consumers = consumers;
   //_upConsumers = upCons;
   ++_nConsumers;
}

///////////////////////////////////////////////////////////////////////////
/// del Consumer
///////////////////////////////////////////////////////////////////////////
void  DataObj::delConsumer(SimModObjSP smo)
{
   if(smo.isNull())
   {
      derr("delConsumer(), deleting NULL consumer!");
      return;
   }
   if(!isConsumer(smo)) //< is it there?
   {
      derr("delConsumer(), consumer not found");
      return;
   }
   /// now remove it from list
   SimModObjSP *consumers = new SimModObjSP[_nConsumers-1];
   //bool        *upCons = new bool[_nConsumers - 1];
   int nidx = 0;
   for(int i=0; i<_nConsumers; ++i)
   {
      if(smo != _consumers[i])
      {
         consumers[nidx] = _consumers[i];
         //upCons[nidx] = _upConsumers[i];
         ++nidx;
      }
   }
   delete[] _consumers;
   //delete[] _upConsumers;
   _consumers = consumers;
   //_upConsumers = upCons;
   --_nConsumers;
}

///////////////////////////////////////////////////////////////////////////
/// get Consumer
///////////////////////////////////////////////////////////////////////////
SimModObjSP  DataObj::getConsumer(unsigned int i)
{
   if( int(i) >= _nConsumers )
   {
      derr("getConsumer(), consumer index greater than number of consumers");
      return SimModObjSP();
   }
   return _consumers[i];
}

///////////////////////////////////////////////////////////////////////////
/// is Consumer
///////////////////////////////////////////////////////////////////////////
bool DataObj::isConsumer(const SimModObjSP  smo) const
{
   if(!_consumers || smo.isNull()) return false;
   for(int i=0; i<_nConsumers; ++i)
   {
      if(_consumers[i] == smo)
      {
         return true;
      }
   }
   return false;
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Framework interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

void DataObj::setForwardModified()
{
   if(_noForward) return;

   _forward = true;
   for(int i=0; i<_nConsumers; ++i)
   {
      if(!_consumers[i].isNull())
      {
         /// only need to forward modify if those
         /// in front of us aren't
         if(!_consumers[i]->isForwardModified())
         {
            _consumers[i]->setForwardModified();
         }
      }
      else
      {
         derr("setForwardModified(), null DataObject encoundered");
      }
   }
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// Protected Functions
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// update Consumers
///////////////////////////////////////////////////////////////////////////
void DataObj::updateConsumers()
{

}

---

Send questions, comments, and bug reports to: