Context Navigation

r2c8934	rcd5047
11	11
12	12	Process::Process(int _maxSteps, std::string _name, bool _doRegister) :
	13	Observable("Process"),
13	14	Action(_name,_doRegister),
14	15	maxSteps(_maxSteps),

src/Parser/ChangeTracker.cpp

-              r2c8934
+              rcd5047
  * Constructor. Signs on as an observer for the World.
  */
+ChangeTracker::ChangeTracker() {
+ChangeTracker::ChangeTracker() :
+  Observable("ChangeTracker")
+{
   isConsistent = true;
   World::getInstance().signOn(this);

src/Parser/FormatParser.cpp

-              r2c8934
+              rcd5047
  * Constructor.
  */
+FormatParser::FormatParser() {
+FormatParser::FormatParser() :
+  Observer("FormatParser")
+{
   ChangeTracker::get()->signOn(this);
   saveStream = NULL;

src/Patterns/Cacheable.hpp

-              r2c8934
+              rcd5047
         return busy;
+      }
+    virtual std::string getName()=0;
     protected:
       bool busy;
 …
         // nothing to do when entering this
+      }
+      virtual std::string getName(){
+        return "invalid";
+      }
     };
 …
         State::busy = false;
+      }
+      virtual std::string getName(){
+        return "valid";
+      }
     private:
       T content;
 …
         // nothing to do when entering this state
+      }
+      virtual std::string getName(){
+        return "destroyed";
+      }
     };
 …
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name);
     virtual ~Cacheable();
 …
   template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
+    Observer(name + "(Cached)"),
     owner(_owner),
     recalcMethod(_recalcMethod)
 …
   void Cacheable<T>::switchState(state_ptr newState){
     ASSERT(!state->isBusy(),"LOOP DETECTED: Cacheable state switched while recalculating.\nDid the recalculation trigger the Observable?");
+#ifdef LOG_OBSERVER
+    observerLog().addMessage() << "## Cacheable " << observerLog().getName(this) << " changed state (" << state->getName()
+                               << "->" << newState->getName() << ")" << std::endl;
+#endif
     state = newState;
     state->enter();

src/Patterns/Observer.cpp

-              r2c8934
+              rcd5047
 #include "Helpers/Assert.hpp"
+#include "Helpers/MemDebug.hpp"
 using namespace std;
 …
   // if no entry for this observable is found, an new one is created
   // by the STL and initialized to 0 (see STL documentation)
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << ">> Locking " << observerLog().getName(publisher) << endl;
+#endif
   depth[publisher]++;
+}
 …
   // if zero is reached all observed blocks are done and we can
   // start to notify our observers
+  if(--(depth[publisher])){}
+  --depth[publisher];
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << "<< Unlocking " << observerLog().getName(publisher) << endl;
+#endif
+  if(depth[publisher]){}
   else{
     publisher->notifyAll();
 …
       callees_t::iterator iter;
       for(iter=callees.begin();iter!=callees.end();++iter){
+#ifdef LOG_OBSERVER
+        observerLog().addMessage() << "-> Sending update from " << observerLog().getName(this)
+                                   << " to " << observerLog().getName((*iter).second)
+                                   << " (priority=" << (*iter).first << ")"<< endl;
+#endif
         (*iter).second->update(this);
+      }
 …
     // we do not need to publish all the changes at each time we are called
     if(depth.find(this)==depth.end()) {
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-* Update from " << observerLog().getName(publisher)
+                                 << " propagated by " << observerLog().getName(this) << endl;
+#endif
       notifyAll();
+    }
+    else{
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-| Update from " <<  observerLog().getName(publisher)
+                                 << " not propagated by " << observerLog().getName(this) << endl;
+#endif
+    }
+  }
 …
 void Observable::signOn(Observer *target,int priority) {
   ASSERT(priority>=-20 && priority<=+20, "Priority out of range [-20:+20] when signing on Observer");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "@@ Signing on " << observerLog().getName(target) << " to " << observerLog().getName(this) << endl;
+#endif
   bool res = false;
   callees_t &callees = callTable[this];
 …
 void Observable::signOff(Observer *target) {
   ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "** Signing off " << observerLog().getName(target) << " from " << observerLog().getName(this) << endl;
+#endif
   callees_t &callees = callTable[this];
 …
 /** Constructor for class Observable.
  */
+Observable::Observable()
+{}
+Observable::Observable(string name) :
+  Observer(Observer::BaseConstructor())
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observable " << observerLog().getName(this) << endl;
+#endif
+}
 /** Destructor for class Observable.
 …
 Observable::~Observable()
+{
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "-- Destroying Observable " << observerLog().getName(this) << endl;
+#endif
   if(callTable.count(this)) {
     // delete all entries for this observable
 …
 /** Constructor for class Observer.
  */
+Observer::Observer()
+{}
+Observer::Observer(string name)
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observer " << observerLog().getName(this) << endl;
+#endif
+}
+/**
+ * Base Constructor for class Observer
+ *
+ * only called from Observable Constructor
+ */
+Observer::Observer(Observer::BaseConstructor){
+#ifdef LOG_OBSERVER
+  observerLog().addObservable(this);
+#endif
+}
 /** Destructor for class Observer.
  */
 Observer::~Observer()
+{}
+{
+#ifdef LOG_OBSERVER
+  if(!observerLog().isObservable(this)){
+    observerLog().addMessage() << "-- Destroying Observer " << observerLog().getName(this) << endl;
+  }
+#endif
+}
 /**
 …
+  }
+}
+#ifdef LOG_OBSERVER
+/************************* Methods to do logging of the Observer Mechanism *********/
+// The log needs to exist fairly early, so we make it construct on first use,
+// and never destroy it
+ObserverLog &observerLog(){
+  // yes, this memory is never freed... we need it around for the whole programm,
+  // so no freeing is possible
+  static ObserverLog *theLog = Memory::ignore(new ObserverLog());
+  return *theLog;
+}
+ObserverLog::ObserverLog() :
+  count (0)
+{}
+ObserverLog::~ObserverLog(){}
+string ObserverLog::getLog(){return log.str();}
+std::string ObserverLog::getName(void* obj){
+  return names[obj];
+}
+bool ObserverLog::isObservable(void* obj){
+  return observables.count(obj);
+}
+void ObserverLog::addName(void* obj , string name){
+  stringstream sstr;
+  sstr << name << "_" << count++;
+  names[obj] = sstr.str();
+}
+void ObserverLog::addObservable(void* obj){
+  observables.insert(obj);
+}
+void ObserverLog::deleteName(void* obj){
+  names.erase(obj);
+}
+void ObserverLog::deleteObservable(void* obj){
+  observables.erase(obj);
+}
+stringstream &ObserverLog::addMessage(int depth){
+  for(int i=depth;i--;)
+    log << "  ";
+  return log;
+}
+#endif

src/Patterns/Observer.hpp

-              r2c8934
+              rcd5047
 #include <map>
 #include <set>
+#include <string>
+#include <sstream>
 /**
 …
  */
+// Deactivate any logging when we are not in debug mode
+#ifdef NDEBUG
+#undef LOG_OBSERVER
+#endif
 class Observable;
 class Notification;
 …
   template<class> friend class ObservedIterator;
+public:
+  Observer();
+  // indicates the constructor called from Observables
+  struct BaseConstructor{};
+public:
+  Observer(BaseConstructor);
+  Observer(std::string);
   virtual ~Observer();
 …
 class Observable : public Observer {
 public:
   Observable();
+  Observable(std::string _name);
   virtual ~Observable();
 …
 };
+#ifdef LOG_OBSERVER
+/**
+ * This class is used to log the working of the observer mechanism
+ *
+ * TODO: make this conditional dependent on compiler Flag.
+ */
+class ObserverLog{
+  friend class Observable;
+  friend class Observer;
+  template <typename> friend class Cacheable;
+public:
+  ObserverLog();
+  ~ObserverLog();
+  std::string getLog();                        // get everything that has been logged
+  std::string getName(void*);                  // get the name of an actor
+  bool isObservable(void*);
+private:
+  int count;                                   // number to reference each actor in this framework
+  std::map<void*,std::string> names;           // List of names assigned to actors
+  std::set<void*> observables;                 // List of pointers to Observables. Needed to distinguish Observers and Observables
+  void addName(void*, std::string);            // Assign a name to an Actor
+  void addObservable(void*);
+  void deleteName(void*);                      // delete the name of an Actor
+  void deleteObservable(void*);
+  std::stringstream &addMessage(int depth=0);  // Add a Message to the logging
+  std::stringstream log;                       // The internal log object
+};
+ObserverLog &observerLog();
+#endif
 // extra macro is necessary to work with __LINE__
 #define PASTE(a,b) PASTE_HELPER(a,b)

src/UIElements/CommandLineUI/CommandLineStatusIndicator.cpp

-              r2c8934
+              rcd5047
 using namespace std;
+CommandLineStatusIndicator::CommandLineStatusIndicator()
+CommandLineStatusIndicator::CommandLineStatusIndicator() :
+    Observer("CommandLineStatusIndicator")
+{
   Process::AddObserver(this);

src/UIElements/TextUI/TextStatusIndicator.cpp

-              r2c8934
+              rcd5047
 using namespace std;
+TextStatusIndicator::TextStatusIndicator()
+TextStatusIndicator::TextStatusIndicator() :
+  Observer("TextStatusIndicator")
+{
   Process::AddObserver(this);

src/World.cpp

r2c8934	rcd5047
277	277
278	278	World::World() :
	279	Observable("World"),
279	280	periode(new periodentafel),
280	281	configuration(new config),

src/builder.cpp

-              r2c8934
+              rcd5047
   ActionRegistry::purgeInstance();
   ActionHistory::purgeInstance();
+#ifdef LOG_OBSERVER
+  cout << observerLog().getLog();
+#endif
   Memory::getState();
+}

src/molecule.cpp

-              r2c8934
+              rcd5047
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
 molecule::molecule(const periodentafel * const teil) : elemente(teil),
   MDSteps(0),
   BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.),
   ActiveFlag(false), IndexNr(-1),
   formula(this,boost::bind(&molecule::calcFormula,this)),
   AtomCount(this,boost::bind(&molecule::doCountAtoms,this)), last_atom(0),  InternalPointer(begin())
+molecule::molecule(const periodentafel * const teil) :
+  Observable("molecule"),
+  elemente(teil),  MDSteps(0),  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0),
+  NoCyclicBonds(0), BondDistance(0.),  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this),"formula"),
+  AtomCount(this,boost::bind(&molecule::doCountAtoms,this),"AtomCount"), last_atom(0),  InternalPointer(begin())
+{

src/moleculelist.cpp

r2c8934	rcd5047
29	29	*/
30	30	MoleculeListClass::MoleculeListClass(World *_world) :
	31	Observable("MoleculeListClass"),
31	32	world(_world)
32	33	{

src/unittests/CacheableTest.cpp

-              r2c8934
+              rcd5047
   threeNumbers(int _x,int _y, int _z) :
+    Observable("threeNumbers"),
     x(_x),y(_y),z(_z),
     sum(this,boost::bind(&threeNumbers::calcSum,this)),
+    sum(this,boost::bind(&threeNumbers::calcSum,this),"sum"),
     hasRecalced(false)
   {}

src/unittests/ObserverTest.cpp

-              r2c8934
+              rcd5047
 public:
   UpdateCountObserver() :
+    Observer("UpdateCountObserver"),
     updates(0)
   {};
 …
 class SimpleObservable : public Observable {
 public:
+  SimpleObservable() :
+    Observable("SimpleObservable")
+  {}
   void changeMethod() {
     OBSERVE;
 …
 class CallObservable : public Observable {
 public:
+  CallObservable() :
+    Observable("CallObservable")
+  {}
   void changeMethod1() {
     OBSERVE;
 …
 class BlockObservable : public Observable {
 public:
+  BlockObservable() :
+    Observable("BlockObservable")
+  {}
   void changeMethod1(){
     OBSERVE;
 …
 class SuperObservable : public Observable {
 public:
+  SuperObservable(){
+  SuperObservable():
+    Observable("SuperObservable")
+  {
     subObservable = new SimpleObservable();
     subObservable->signOn(this);
 …
 public:
   NotificationObservable() :
+      notification1(new Notification(this)),
+      notification2(new Notification(this))
+    Observable("NotificationObservable"),
+    notification1(new Notification(this)),
+    notification2(new Notification(this))
   {}
 …
 public:
   NotificationObserver(Notification_ptr notification) :
+    Observer("NotificationObserver"),
     requestedNotification(notification),
     wasNotified(false)
 …
   ObservableCollection(int _num) :
+  num(_num)
+    Observable("ObservableCollection"),
+    num(_num)
+  {
     for(int i=0; i<num; ++i){

src/unittests/manipulateAtomsTest.cpp

r2c8934	rcd5047
55	55	public:
56	56	countObserver() :
	57	Observer("countObserver"),
57	58	count(0)
58	59	{}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset cd5047 for src

Legend:

Download in other formats: