home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / HandlerL.h < prev    next >
C/C++ Source or Header  |  1998-03-25  |  5KB  |  176 lines
  1. // $Id: HandlerL.h,v 1.12 1998/03/25 12:43:24 zeller Exp $
  2. // General-purpose Handler Manager
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _DDD_HandlerList_h
  30. #define _DDD_HandlerList_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. #include "compare.h"
  37. #include "bool.h"
  38. #include "assert.h"
  39.  
  40. typedef void (*HandlerProc)(void *source,    // handler source
  41.                 void *client_data,  // data supplied by client
  42.                 void *call_data);   // data supplied by caller
  43.  
  44.  
  45.  
  46. class HandlerList {
  47. private:
  48.     struct HandlerRec {
  49.     HandlerProc proc;        // handling procedure
  50.     void        *client_data;    // data supplied by client
  51.     HandlerRec  *next;        // for collectors
  52.     bool    remove_me;              // Flag: to be removed?
  53.     
  54.     // Constructor
  55.     HandlerRec(HandlerProc p, void *c, HandlerRec *n = 0):
  56.         proc(p), client_data(c), next(n), 
  57.         remove_me(false)
  58.         {}
  59.  
  60.     private:
  61.     HandlerRec(const HandlerRec&):
  62.         proc(0), client_data(0), next(0), remove_me(false) { assert(0); }
  63.     HandlerRec& operator = (const HandlerRec&) { assert(0); return *this; }
  64.     };
  65.  
  66.     static int compare(const HandlerRec& l1, const HandlerRec& l2)
  67.     {
  68.     int c = ::compare((void *)l1.proc, (void *)l2.proc);
  69.     return c ? c : ::compare(l1.client_data, l2.client_data);
  70.     }
  71.  
  72.     // Data
  73.     unsigned _nTypes;            // #types
  74.     HandlerRec  **handlers;    // handlers
  75.     int *active;        // Flag: currently running?
  76.  
  77. protected:
  78.     // Remove all handlers marked as "remove me"
  79.     void processRemovals(unsigned type) const;
  80.  
  81. private:
  82.     HandlerList& operator = (const HandlerList&) { assert(0); return *this; }
  83.  
  84. public:
  85.     // Constructor
  86.     HandlerList(unsigned n = 10);
  87.  
  88.     // Duplicator
  89.     HandlerList(const HandlerList& l);
  90.  
  91.     // Comparison
  92.     int compare(const HandlerList& l) const;
  93.  
  94.     // Resources
  95.     unsigned nTypes() const { return _nTypes; }
  96.  
  97.     // Add Handler
  98.     void add(unsigned type, HandlerProc proc, void *client_data = 0);
  99.  
  100.     // Add Handler list
  101.     void add(const HandlerList& l)
  102.     {
  103.     for (unsigned type = 0; type < l.nTypes(); type++)
  104.         for (HandlerRec *h = l.handlers[type]; h != 0; h = h->next)
  105.         add(type, h->proc, h->client_data);
  106.     }
  107.  
  108.     // Remove Handler
  109.     void remove(unsigned type, HandlerProc proc, void *client_data = 0);
  110.  
  111.     // Remove all Handlers
  112.     void removeAll(unsigned type);
  113.  
  114.     // Remove all Handlers for all types
  115.     void removeAll();
  116.  
  117.     // Call Handlers
  118.     void call(unsigned type, void *const source = 0, 
  119.           void *const call_data = 0) const;
  120.  
  121.     // Check if Handler available
  122.     int has(unsigned type) const
  123.     {
  124.     return type < nTypes() && handlers[type] != 0;
  125.     }
  126.  
  127.     // Destructor
  128.     ~HandlerList()
  129.     {
  130.     removeAll();
  131.     for (unsigned type = 0; type < nTypes(); type++)
  132.         processRemovals(type);
  133.  
  134.     delete[] handlers;
  135.     delete[] active;
  136.     }
  137. };
  138.  
  139. // Alternative interfaces to member function 'compare'
  140. inline int compare(const HandlerList& l1, const HandlerList& l2)
  141. {
  142.     return l1.compare(l2);
  143. }
  144.  
  145. inline int operator == (const HandlerList& l1, const HandlerList& l2)
  146. {
  147.     return compare(l1, l2) == 0;
  148. }
  149.  
  150. inline int operator != (const HandlerList& l1, const HandlerList& l2)
  151. {
  152.     return compare(l1, l2) != 0;
  153. }
  154.  
  155. inline int operator < (const HandlerList& l1, const HandlerList& l2)
  156. {
  157.     return compare(l1, l2) < 0;
  158. }
  159.  
  160. inline int operator > (const HandlerList& l1, const HandlerList& l2)
  161. {
  162.     return compare(l1, l2) > 0;
  163. }
  164.  
  165. inline int operator <= (const HandlerList& l1, const HandlerList& l2)
  166. {
  167.     return compare(l1, l2) <= 0;
  168. }
  169.  
  170. inline int operator >= (const HandlerList& l1, const HandlerList& l2)
  171. {
  172.     return compare(l1, l2) >= 0;
  173. }
  174.  
  175. #endif
  176.