ermyth/include/callback.h.in

/*
 * $Id: callback.h.in,v 1.1 2007-07-19 08:24:50 pippijn Exp $
 */

#ifndef CALLBACK_H
#define CALLBACK_H

#include <set>
#include <list>

namespace callback
{
  class event_base;

  class has_listeners
  {
  private:
    typedef std::set <event_base *> sender_set;
    typedef sender_set::const_iterator const_iterator;
    typedef sender_set::iterator iterator;

    sender_set m_senders;
    sender_set &invokers ();

    const sender_set &invokers () const;

  public:
    has_listeners ();
    has_listeners (const has_listeners &rhs);

    virtual ~has_listeners ();

    has_listeners &operator = (const has_listeners &rhs);

    void add_invoker (event_base *sender);
    void remove_invoker (event_base *sender);

  protected:
    void copy_invokers (const has_listeners &rhs);
    void disconnect_all ();
  };

  typedef has_listeners listening_base;


  class event_base
  {
  public:
    virtual ~event_base () { }
    event_base () { }

    inline bool detach (listening_base *plistener)
    {
      return this->listener_detach (plistener);
    }

    virtual bool listener_duplicate (const listening_base *poldlistener, listening_base *pnewlistener) = 0;

  protected:
    virtual bool listener_detach (listening_base *plistener) = 0;

    template <typename list_T>
    void free_connections (list_T &list)
    {
      typename list_T::const_iterator it;
      typename list_T::const_iterator it_end = list.end ();

      for (it = list.begin (); it != it_end; ++it)
        {
          (*it)->getdest ()->remove_invoker (this);
          delete *it;
        }

      list.clear ();
    }

    template <typename list_T>
    bool detach (listening_base *plistener, list_T &list)
    {
      typename list_T::iterator it;
      typename list_T::iterator it_end = list.end ();

      for (it = list.begin (); it != it_end; ++it)
        {
          if ((*it)->getdest () == plistener)
            {
              delete *it;
              list.erase (it);
              plistener->remove_invoker (this);

              return true;
            }
        }

      return false;
    }

    template <typename listeningT, typename SetT>
    bool duplicate_connection (const listeningT *oldtarget, listeningT *newtarget, SetT &list)
    {
      typename SetT::iterator it = list.begin ();
      typename SetT::iterator it_end = list.end ();

      bool ret = false;
      for (; it != it_end; ++it)
        {
          if ((*it)->getdest () == oldtarget)
            {
              list.push_back ((*it)->duplicate (newtarget));
              ret = true;
            }
        }
      return ret;
    }

    template <typename SetT>
    void copy_connections (const SetT &src, SetT &tgt)
    {
      if (&src == &tgt)
        return ;
      typename SetT::const_iterator it = src.begin ();
      typename SetT::const_iterator it_end = src.end ();
      typedef typename SetT::value_type ConT;
      ConT clone = 0;
      for (; it != it_end; ++it)
        {
          clone = (*it)->clone ();
          if (!clone)
            continue;
          clone->getdest ()->add_invoker (this);
          tgt.push_back (clone);
        }
    }
  };

  class connection_base0
  {
  public:
    virtual ~connection_base0 () { }
    typedef connection_base0 this_type;
    virtual listening_base *getdest () const = 0;
    virtual void invoke () const = 0;

    virtual this_type *clone () const = 0;
    virtual this_type *duplicate (listening_base *pnewdest) const = 0;
  };


  template <class arg1_type>
  class connection_base1
  {
  public:
    virtual ~connection_base1 () { }
    typedef connection_base1 <arg1_type> this_type;
    virtual listening_base *getdest () const = 0;
    virtual void invoke (arg1_type) const = 0;

    virtual this_type *clone () const = 0;
    virtual this_type *duplicate (listening_base *pnewdest) const = 0;
  };


  template <class dest_type>
  class connection0 : public connection_base0
  {
  public:
    typedef connection_base0 base_type;
    typedef connection0<dest_type> this_type;

    typedef void (dest_type::*listener_fun) ();
    connection0 (): m_pobject (0), m_pmemfun (0){}

    virtual ~connection0 () { }

    connection0 (dest_type *pobject, listener_fun pmemfun): m_pobject (pobject), m_pmemfun (pmemfun){}

    virtual base_type *clone () const
    {
      return new this_type (*this);
    }

    virtual base_type *duplicate (listening_base *pnewdest) const
    {
      return new this_type (dynamic_cast <dest_type *> (pnewdest), m_pmemfun);
    }

    virtual void invoke () const
    {
      (m_pobject->*m_pmemfun) ();
    }

    virtual listening_base *getdest () const
    {
      return m_pobject;
    }

  private:
    dest_type *m_pobject;
    listener_fun m_pmemfun;
  };

  template <class dest_type, class arg1_type>
  class connection1 : public connection_base1<arg1_type>
  {
  public:
    typedef connection_base1<arg1_type> base_type;
    typedef connection1<dest_type, arg1_type> this_type;
    typedef void (dest_type::*listener_fun) (arg1_type);
    connection1 (): m_pobject (0), m_pmemfun (0){}

    connection1 (dest_type *pobject, listener_fun pmemfun): m_pobject (pobject), m_pmemfun (pmemfun){}

    virtual ~connection1 () { }

    virtual base_type *clone () const
    {
      return new this_type (*this);
    }

    virtual base_type *duplicate (listening_base *pnewdest) const
    {
      return new this_type (dynamic_cast <dest_type *> (pnewdest), m_pmemfun);
    }

    virtual void invoke (arg1_type a1) const
    {
      (m_pobject->*m_pmemfun) (a1);
    }

    virtual listening_base *getdest () const
    {
      return m_pobject;
    }

  private:
    dest_type *m_pobject;
    listener_fun m_pmemfun;
  };


  class event0 : public event_base
  {
  public:
    typedef std::list <connection_base0 *> connection_list;

    event0 () { }

    event0 (const event0 &s): event_base (s)
    {
      this->copy_connections (s.connections (), this->connections ());
    }

    event0 &operator = (const event0 &s)
    {
      this->copy_connections (s.connections (), this->connections ());
      return *this;
    }

    virtual ~event0 ()
    {
      this->disconnect_all ();
    }

    void disconnect_all ()
    {
      this->free_connections (this->connections ());
    }


    template <class desttype>
    void attach (desttype *pclass, void (desttype::*pmemfun) ())
    {
      connection_base0 *conn = new connection0<desttype> (pclass, pmemfun);
      this->connections ().push_back (conn);
      pclass->add_invoker (this);
    }


    bool listener_duplicate (const listening_base *oldtarget, listening_base *newtarget)
    {
      return this->duplicate_connection (oldtarget, newtarget, this->connections ());
    }


    void invoke () const
    {
      connection_list::const_iterator it;
      connection_list::const_iterator end = this->connections ().end ();

      for (it = this->connections ().begin (); it != end; ++it)
        (*it)->invoke ();
    }

    void operator () () const
    {
      this->invoke ();
    }

  protected:
    connection_list &connections ()
    {
      return this->m_connected_listeners;
    }

    const connection_list &connections () const
    {
      return this->m_connected_listeners;
    }

    bool listener_detach (listening_base *plistener)
    {
      return this->detach (plistener, this->connections ());
    }

  private:
    connection_list m_connected_listeners;
  };

  template <class arg1_type>
  class event1 : public event_base
  {
  public:
    typedef std::list<connection_base1<arg1_type> *> connection_list;

    event1 () { }

    event1 (const event1 <arg1_type>  &s): event_base (s) { }

    template <class dest_type>
    void attach (dest_type *pclass, void (dest_type::*pmemfun) (arg1_type))
    {
      connection_base1<arg1_type>  *conn = new connection1<dest_type, arg1_type> (pclass, pmemfun);
      this->connections ().push_back (conn);
      pclass->add_invoker (this);
    }

    void invoke (arg1_type a1) const
    {
      typename connection_list::const_iterator it;
      typename connection_list::const_iterator it_end = this->connections ().end ();

      for (it = this->connections ().begin (); it != it_end; ++it)
        {
          (*it)->invoke (a1);
        }
    }

    void operator () (arg1_type a1) const
    {
      this->invoke (a1);
    }

    event1 &operator = (const event1 &s)
    {
      this->copy_connections (s.connections (), this->connections ());
      return *this;
    }

    bool listener_duplicate (const listening_base *oldtarget, listening_base *newtarget)
    {
      return this->duplicate_connection (oldtarget, newtarget, this->connections ());
    }

    ~event1 ()
    {
      this->disconnect_all ();
    }

    void disconnect_all ()
    {
      this->free_connections (connections ());
    }

  protected:
    connection_list &connections ()
    {
      return this->m_connected_listeners;
    }

    const connection_list &connections () const
    {
      return this->m_connected_listeners;
    }

    bool listener_detach (listening_base *plistener)
    {
      return this->detach (plistener, this->connections ());
    }

  private:
    connection_list m_connected_listeners;
  };

@CALLBACKS@
  
} // namespace callback

class has_callbacks
{
protected:
   struct callbacks
   {
     callback::event1 <has_callbacks *> created;
     callback::event1 <has_callbacks *> destroyed;
   };
   
   static callbacks callback;
   
   has_callbacks  ();
   ~has_callbacks ();
};

#endif // CALLBACK_H
Revision:	1.2
Committed:	Tue Aug 28 17:12:24 2007 UTC (16 years, 9 months ago) by pippijn
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	removed old files
#	User	Rev	Content
1	pippijn	1.1	/*
2	pippijn	1.2	* $Id: callback.h.in,v 1.1 2007-07-19 08:24:50 pippijn Exp $
3	pippijn	1.1	*/
4
5			#ifndef CALLBACK_H
6			#define CALLBACK_H
7
8			#include <set>
9			#include <list>
10
11			namespace callback
12			{
13			class event_base;
14
15			class has_listeners
16			{
17			private:
18			typedef std::set <event_base *> sender_set;
19			typedef sender_set::const_iterator const_iterator;
20			typedef sender_set::iterator iterator;
21
22			sender_set m_senders;
23			sender_set &invokers ();
24
25			const sender_set &invokers () const;
26
27			public:
28			has_listeners ();
29			has_listeners (const has_listeners &rhs);
30
31			virtual ~has_listeners ();
32
33			has_listeners &operator = (const has_listeners &rhs);
34
35			void add_invoker (event_base *sender);
36			void remove_invoker (event_base *sender);
37
38			protected:
39			void copy_invokers (const has_listeners &rhs);
40			void disconnect_all ();
41			};
42
43			typedef has_listeners listening_base;
44
45
46			class event_base
47			{
48			public:
49			virtual ~event_base () { }
50			event_base () { }
51
52			inline bool detach (listening_base *plistener)
53			{
54			return this->listener_detach (plistener);
55			}
56
57			virtual bool listener_duplicate (const listening_base poldlistener, listening_base pnewlistener) = 0;
58
59			protected:
60			virtual bool listener_detach (listening_base *plistener) = 0;
61
62			template <typename list_T>
63			void free_connections (list_T &list)
64			{
65			typename list_T::const_iterator it;
66			typename list_T::const_iterator it_end = list.end ();
67
68			for (it = list.begin (); it != it_end; ++it)
69			{
70			(*it)->getdest ()->remove_invoker (this);
71			delete *it;
72			}
73
74			list.clear ();
75			}
76
77			template <typename list_T>
78			bool detach (listening_base *plistener, list_T &list)
79			{
80			typename list_T::iterator it;
81			typename list_T::iterator it_end = list.end ();
82
83			for (it = list.begin (); it != it_end; ++it)
84			{
85			if ((*it)->getdest () == plistener)
86			{
87			delete *it;
88			list.erase (it);
89			plistener->remove_invoker (this);
90
91			return true;
92			}
93			}
94
95			return false;
96			}
97
98			template <typename listeningT, typename SetT>
99			bool duplicate_connection (const listeningT oldtarget, listeningT newtarget, SetT &list)
100			{
101			typename SetT::iterator it = list.begin ();
102			typename SetT::iterator it_end = list.end ();
103
104			bool ret = false;
105			for (; it != it_end; ++it)
106			{
107			if ((*it)->getdest () == oldtarget)
108			{
109			list.push_back ((*it)->duplicate (newtarget));
110			ret = true;
111			}
112			}
113			return ret;
114			}
115
116			template <typename SetT>
117			void copy_connections (const SetT &src, SetT &tgt)
118			{
119			if (&src == &tgt)
120			return ;
121			typename SetT::const_iterator it = src.begin ();
122			typename SetT::const_iterator it_end = src.end ();
123			typedef typename SetT::value_type ConT;
124			ConT clone = 0;
125			for (; it != it_end; ++it)
126			{
127			clone = (*it)->clone ();
128			if (!clone)
129			continue;
130			clone->getdest ()->add_invoker (this);
131			tgt.push_back (clone);
132			}
133			}
134			};
135
136			class connection_base0
137			{
138			public:
139			virtual ~connection_base0 () { }
140			typedef connection_base0 this_type;
141			virtual listening_base *getdest () const = 0;
142			virtual void invoke () const = 0;
143
144			virtual this_type *clone () const = 0;
145			virtual this_type duplicate (listening_base pnewdest) const = 0;
146			};
147
148
149			template <class arg1_type>
150			class connection_base1
151			{
152			public:
153			virtual ~connection_base1 () { }
154			typedef connection_base1 <arg1_type> this_type;
155			virtual listening_base *getdest () const = 0;
156			virtual void invoke (arg1_type) const = 0;
157
158			virtual this_type *clone () const = 0;
159			virtual this_type duplicate (listening_base pnewdest) const = 0;
160			};
161
162
163			template <class dest_type>
164			class connection0 : public connection_base0
165			{
166			public:
167			typedef connection_base0 base_type;
168			typedef connection0<dest_type> this_type;
169
170			typedef void (dest_type::*listener_fun) ();
171			connection0 (): m_pobject (0), m_pmemfun (0){}
172
173			virtual ~connection0 () { }
174
175			connection0 (dest_type *pobject, listener_fun pmemfun): m_pobject (pobject), m_pmemfun (pmemfun){}
176
177			virtual base_type *clone () const
178			{
179			return new this_type (*this);
180			}
181
182			virtual base_type duplicate (listening_base pnewdest) const
183			{
184			return new this_type (dynamic_cast <dest_type *> (pnewdest), m_pmemfun);
185			}
186
187			virtual void invoke () const
188			{
189			(m_pobject->*m_pmemfun) ();
190			}
191
192			virtual listening_base *getdest () const
193			{
194			return m_pobject;
195			}
196
197			private:
198			dest_type *m_pobject;
199			listener_fun m_pmemfun;
200			};
201
202			template <class dest_type, class arg1_type>
203			class connection1 : public connection_base1<arg1_type>
204			{
205			public:
206			typedef connection_base1<arg1_type> base_type;
207			typedef connection1<dest_type, arg1_type> this_type;
208			typedef void (dest_type::*listener_fun) (arg1_type);
209			connection1 (): m_pobject (0), m_pmemfun (0){}
210
211			connection1 (dest_type *pobject, listener_fun pmemfun): m_pobject (pobject), m_pmemfun (pmemfun){}
212
213			virtual ~connection1 () { }
214
215			virtual base_type *clone () const
216			{
217			return new this_type (*this);
218			}
219
220			virtual base_type duplicate (listening_base pnewdest) const
221			{
222			return new this_type (dynamic_cast <dest_type *> (pnewdest), m_pmemfun);
223			}
224
225			virtual void invoke (arg1_type a1) const
226			{
227			(m_pobject->*m_pmemfun) (a1);
228			}
229
230			virtual listening_base *getdest () const
231			{
232			return m_pobject;
233			}
234
235			private:
236			dest_type *m_pobject;
237			listener_fun m_pmemfun;
238			};
239
240
241			class event0 : public event_base
242			{
243			public:
244			typedef std::list <connection_base0 *> connection_list;
245
246			event0 () { }
247
248			event0 (const event0 &s): event_base (s)
249			{
250			this->copy_connections (s.connections (), this->connections ());
251			}
252
253			event0 &operator = (const event0 &s)
254			{
255			this->copy_connections (s.connections (), this->connections ());
256			return *this;
257			}
258
259			virtual ~event0 ()
260			{
261			this->disconnect_all ();
262			}
263
264			void disconnect_all ()
265			{
266			this->free_connections (this->connections ());
267			}
268
269
270			template <class desttype>
271			void attach (desttype pclass, void (desttype::pmemfun) ())
272			{
273			connection_base0 *conn = new connection0<desttype> (pclass, pmemfun);
274			this->connections ().push_back (conn);
275			pclass->add_invoker (this);
276			}
277
278
279			bool listener_duplicate (const listening_base oldtarget, listening_base newtarget)
280			{
281			return this->duplicate_connection (oldtarget, newtarget, this->connections ());
282			}
283
284
285			void invoke () const
286			{
287			connection_list::const_iterator it;
288			connection_list::const_iterator end = this->connections ().end ();
289
290			for (it = this->connections ().begin (); it != end; ++it)
291			(*it)->invoke ();
292			}
293
294			void operator () () const
295			{
296			this->invoke ();
297			}
298
299			protected:
300			connection_list &connections ()
301			{
302			return this->m_connected_listeners;
303			}
304
305			const connection_list &connections () const
306			{
307			return this->m_connected_listeners;
308			}
309
310			bool listener_detach (listening_base *plistener)
311			{
312			return this->detach (plistener, this->connections ());
313			}
314
315			private:
316			connection_list m_connected_listeners;
317			};
318
319			template <class arg1_type>
320			class event1 : public event_base
321			{
322			public:
323			typedef std::list<connection_base1<arg1_type> *> connection_list;
324
325			event1 () { }
326
327			event1 (const event1 <arg1_type> &s): event_base (s) { }
328
329			template <class dest_type>
330			void attach (dest_type pclass, void (dest_type::pmemfun) (arg1_type))
331			{
332			connection_base1<arg1_type> *conn = new connection1<dest_type, arg1_type> (pclass, pmemfun);
333			this->connections ().push_back (conn);
334			pclass->add_invoker (this);
335			}
336
337			void invoke (arg1_type a1) const
338			{
339			typename connection_list::const_iterator it;
340			typename connection_list::const_iterator it_end = this->connections ().end ();
341
342			for (it = this->connections ().begin (); it != it_end; ++it)
343			{
344			(*it)->invoke (a1);
345			}
346			}
347
348			void operator () (arg1_type a1) const
349			{
350			this->invoke (a1);
351			}
352
353			event1 &operator = (const event1 &s)
354			{
355			this->copy_connections (s.connections (), this->connections ());
356			return *this;
357			}
358
359			bool listener_duplicate (const listening_base oldtarget, listening_base newtarget)
360			{
361			return this->duplicate_connection (oldtarget, newtarget, this->connections ());
362			}
363
364			~event1 ()
365			{
366			this->disconnect_all ();
367			}
368
369			void disconnect_all ()
370			{
371			this->free_connections (connections ());
372			}
373
374			protected:
375			connection_list &connections ()
376			{
377			return this->m_connected_listeners;
378			}
379
380			const connection_list &connections () const
381			{
382			return this->m_connected_listeners;
383			}
384
385			bool listener_detach (listening_base *plistener)
386			{
387			return this->detach (plistener, this->connections ());
388			}
389
390			private:
391			connection_list m_connected_listeners;
392			};
393
394			@CALLBACKS@
395
396			} // namespace callback
397
398			class has_callbacks
399			{
400			protected:
401			struct callbacks
402			{
403			callback::event1 <has_callbacks *> created;
404			callback::event1 <has_callbacks *> destroyed;
405			};
406
407			static callbacks callback;
408
409			has_callbacks ();
410			~has_callbacks ();
411			};
412
413			#endif // CALLBACK_H