Public API Reference

csutil/cssubscription.h

/*
  Crystal Space 3D engine - Event Subscription internals
  Copyright (C) 2005 by Adam D. Bradley <[email protected]>

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSEVENTSUBSCRIPTION_H__
#define __CS_CSEVENTSUBSCRIPTION_H__

#include "csutil/partialorder.h"
#include "csutil/tree.h"
#include "csutil/list.h"
#include "csutil/eventhandlers.h"
#include "iutil/eventh.h"

class csEventQueue;


class csEventTree : public csTreeNode
{
public:
  // forward declarator
  class SubscriberIterator;

  csEventTree *FindNode (csEventID name, csEventQueue *q);
  bool Subscribe (csHandlerID, csEventID, csEventQueue *q);
  void Unsubscribe(csHandlerID, csEventID, csEventQueue *q);
  
  void Notify();
  void Dispatch(iEvent &e);
  
#ifdef ADB_DEBUG
  // Dump the event tree and subscriptions to stderr.
  void Dump();
#endif
  
  static inline csEventTree *CreateRootNode(csRef<iEventHandlerRegistry> &reg1,
                                            csRef<iEventNameRegistry> &reg2, 
                                            csEventQueue *q)
  {
    return new csEventTree (reg1, reg2, reg2->GetID(""), 0, q);
  }
  
  static inline void DeleteRootNode(csEventTree *node)
  {
    CS_ASSERT(node);
    CS_ASSERT(node->self == node->name_reg->GetID(""));
    delete node;
  }
    
private:
  csRef<iEventHandlerRegistry> handler_reg;
  csRef<iEventNameRegistry> name_reg;
#ifdef ADB_DEBUG
  void Dump(int depth);
#endif

  csEventTree *FindNodeInternal(csEventID &name, csEventQueue *q);
  
  csEventTree (csRef<iEventHandlerRegistry> &,
               csRef<iEventNameRegistry> &, 
               csEventID name, csEventTree *parent, csEventQueue *q);
  ~csEventTree ();
  
  csEventID self;
  csEventQueue *queue;
  
  bool SubscribeInternal (csHandlerID, csEventID);
  void UnsubscribeInternal (csHandlerID);
  bool fatNode;

  class FatRecordObject
  {
  private:
    csRef<iEventHandlerRegistry> handler_reg;
    csRef<iEventNameRegistry> name_reg;
  public:
    FatRecordObject(csEventTree *root,
                    csRef<iEventHandlerRegistry> &h_reg,
                    csRef<iEventNameRegistry> &n_reg,
                    csPartialOrder<csHandlerID> *new_sg,
                    csList<iEventHandler *> *new_sq) :
      handler_reg (h_reg), name_reg (n_reg), 
      SubscriberGraph (new_sg), SubscriberQueue (new_sq), 
      my_root (root), iterator (0), iterating_for (0)
    {
      /* If there's no SQ, mark it for creation */
      StaleSubscriberQueue = (SubscriberQueue==0);
    }

    ~FatRecordObject()
    {
      delete SubscriberGraph;
      if (SubscriberQueue)
        delete SubscriberQueue;
      CS_ASSERT (iterator == 0);
      CS_ASSERT (iterating_for == 0);
    }

    void RebuildQueue();
    csPartialOrder<csHandlerID> *SubscribeInternal(csHandlerID, csEventID);
    void UnsubscribeInternal(csHandlerID);

    csPartialOrder<csHandlerID> *SubscriberGraph;
    csList<iEventHandler *> *SubscriberQueue;
    bool StaleSubscriberQueue;
    csEventTree *my_root;
    SubscriberIterator *iterator;
    csEventTree *iterating_for;
  };

  FatRecordObject *fatRecord;

  void ForceFatCopy();

  void KillFatCopy();

  void PushFatCopy(FatRecordObject *);
  

 public:
  class SubscriberIterator 
  {
  public:
    SubscriberIterator (iEventHandlerRegistry* r, csEventTree *t, 
      csEventID bevent) : handler_reg(r), record(t->fatRecord), 
        baseevent(bevent), mode(SI_LIST), qit(0)
    {
      CS_ASSERT(record->iterator == 0);
      record->iterator = this;
      record->iterating_for = t;
      if (t->fatRecord->SubscriberQueue)
        qit = new csList<iEventHandler *>::Iterator (
          *t->fatRecord->SubscriberQueue);
      else
        GraphMode();
    }

    ~SubscriberIterator ()
    {
      CS_ASSERT(record->iterator == this);
      record->iterator = 0;
      record->iterating_for = 0;
      delete qit;
    }

    inline bool HasNext () 
    {
      switch(mode) 
      {
      case SI_LIST:
        return qit->HasNext ();
        
      case SI_GRAPH:
        do 
        {
          csHandlerID id = record->SubscriberGraph->GetEnabled (
                CS_HANDLER_INVALID);
          if (id == CS_HANDLER_INVALID)
            break;
          else if (handler_reg->IsInstance(id))
            return true;
          else
            record->SubscriberGraph->Mark(id);
        } 
        while (true);
        return false;
        
      default:
        CS_ASSERT((mode == SI_LIST) ||
                  (mode == SI_GRAPH));
        return false;
      }
    }

    inline iEventHandler *Next () 
    {
      switch(mode) 
      {
      case SI_LIST:
        /* DOME : see if the current element has been deleted. */
        return qit->Next ();
        
      case SI_GRAPH:
        /* see if the current element has been flagged for deletion. */
        do 
        {
          csHandlerID id = record->SubscriberGraph->GetEnabled (
                CS_HANDLER_INVALID);
          if (id == CS_HANDLER_INVALID)
            break;
          else if (handler_reg->IsInstance (id)) 
          {
            record->SubscriberGraph->Mark (id);
            return handler_reg->GetHandler (id);
          } 
          else
            record->SubscriberGraph->Mark(id);
        } 
        while (true);
        return 0;
        
      default:
        CS_ASSERT((mode == SI_LIST) ||
                  (mode == SI_GRAPH));
        return 0;
      }
    }
    
    /* SI_GRAPH mode data structures and methods */
    void GraphMode (); // change to graph (SI_GRAPH) iterator mode.
    
  private:
    friend class csEventTree;
    friend class csEventQueueTest;

    csRef<iEventHandlerRegistry> handler_reg;
    FatRecordObject *record;
    csEventID baseevent;
    enum
    {
      SI_LIST,
      SI_GRAPH
    } mode;
    
    /* SI_LIST mode data structures */
    csList<iEventHandler *>::Iterator* qit;
  };
  friend class SubscriberIterator;
  friend class csEventQueueTest;

  SubscriberIterator *GetIterator();

};

#endif // __CS_CSEVENTSUBSCRIPTION_H__

---