ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.pod
(Generate patch)

Comparing libev/ev.pod (file contents):
Revision 1.70 by root, Fri Dec 7 19:23:48 2007 UTC vs.
Revision 1.71 by root, Fri Dec 7 20:13:09 2007 UTC

… …
1744 1744
1745To use it, 1745To use it,
1746 1746
1747 #include <ev++.h> 1747 #include <ev++.h>
1748 1748
1749(it is not installed by default). This automatically includes F<ev.h> 1749This automatically includes F<ev.h> and puts all of its definitions (many
1750and puts all of its definitions (many of them macros) into the global 1750of them macros) into the global namespace. All C++ specific things are
1751namespace. All C++ specific things are put into the C<ev> namespace. 1751put into the C<ev> namespace. It should support all the same embedding
1752options as F<ev.h>, most notably C<EV_MULTIPLICITY>.
1752 1753
1753It should support all the same embedding options as F<ev.h>, most notably 1754Care has been taken to keep the overhead low. The only data member added
1754C<EV_MULTIPLICITY>. 1755to the C-style watchers is the event loop the watcher is associated with
1756(or no additional members at all if you disable C<EV_MULTIPLICITY> when
1757embedding libev).
1758
1759Currently, functions and static and non-static member functions can be
1760used as callbacks. Other types should be easy to add as long as they only
1761need one additional pointer for context. If you need support for other
1762types of functors please contact the author (preferably after implementing
1763it).
1755 1764
1756Here is a list of things available in the C<ev> namespace: 1765Here is a list of things available in the C<ev> namespace:
1757 1766
1758=over 4 1767=over 4
1759 1768
… …
1775 1784
1776All of those classes have these methods: 1785All of those classes have these methods:
1777 1786
1778=over 4 1787=over 4
1779 1788
1780=item ev::TYPE::TYPE (object *, object::method *) 1789=item ev::TYPE::TYPE ()
1781 1790
1782=item ev::TYPE::TYPE (object *, object::method *, struct ev_loop *) 1791=item ev::TYPE::TYPE (struct ev_loop *)
1783 1792
1784=item ev::TYPE::~TYPE 1793=item ev::TYPE::~TYPE
1785 1794
1786The constructor takes a pointer to an object and a method pointer to 1795The constructor (optionally) takes an event loop to associate the watcher
1787the event handler callback to call in this class. The constructor calls 1796with. If it is omitted, it will use C<EV_DEFAULT>.
1788C<ev_init> for you, which means you have to call the C<set> method 1797
1789before starting it. If you do not specify a loop then the constructor 1798The constructor calls C<ev_init> for you, which means you have to call the
1790automatically associates the default loop with this watcher. 1799C<set> method before starting it.
1800
1801It will not set a callback, however: You have to call the templated C<set>
1802method to set a callback before you can start the watcher.
1803
1804(The reason why you have to use a method is a limitation in C++ which does
1805not allow explicit template arguments for constructors).
1791 1806
1792The destructor automatically stops the watcher if it is active. 1807The destructor automatically stops the watcher if it is active.
1808
1809=item w->set<class, &class::method> (object *)
1810
1811This method sets the callback method to call. The method has to have a
1812signature of C<void (*)(ev_TYPE &, int)>, it receives the watcher as
1813first argument and the C<revents> as second. The object must be given as
1814parameter and is stored in the C<data> member of the watcher.
1815
1816This method synthesizes efficient thunking code to call your method from
1817the C callback that libev requires. If your compiler can inline your
1818callback (i.e. it is visible to it at the place of the C<set> call and
1819your compiler is good :), then the method will be fully inlined into the
1820thunking function, making it as fast as a direct C callback.
1821
1822Example: simple class declaration and watcher initialisation
1823
1824 struct myclass
1825 {
1826 void io_cb (ev::io &w, int revents) { }
1827 }
1828
1829 myclass obj;
1830 ev::io iow;
1831 iow.set <myclass, &myclass::io_cb> (&obj);
1832
1833=item w->set (void (*function)(watcher &w, int), void *data = 0)
1834
1835Also sets a callback, but uses a static method or plain function as
1836callback. The optional C<data> argument will be stored in the watcher's
1837C<data> member and is free for you to use.
1838
1839See the method-C<set> above for more details.
1793 1840
1794=item w->set (struct ev_loop *) 1841=item w->set (struct ev_loop *)
1795 1842
1796Associates a different C<struct ev_loop> with this watcher. You can only 1843Associates a different C<struct ev_loop> with this watcher. You can only
1797do this when the watcher is inactive (and not pending either). 1844do this when the watcher is inactive (and not pending either).
1798 1845
1799=item w->set ([args]) 1846=item w->set ([args])
1800 1847
1801Basically the same as C<ev_TYPE_set>, with the same args. Must be 1848Basically the same as C<ev_TYPE_set>, with the same args. Must be
1802called at least once. Unlike the C counterpart, an active watcher gets 1849called at least once. Unlike the C counterpart, an active watcher gets
1803automatically stopped and restarted. 1850automatically stopped and restarted when reconfiguring it with this
1851method.
1804 1852
1805=item w->start () 1853=item w->start ()
1806 1854
1807Starts the watcher. Note that there is no C<loop> argument as the 1855Starts the watcher. Note that there is no C<loop> argument, as the
1808constructor already takes the loop. 1856constructor already stores the event loop.
1809 1857
1810=item w->stop () 1858=item w->stop ()
1811 1859
1812Stops the watcher if it is active. Again, no C<loop> argument. 1860Stops the watcher if it is active. Again, no C<loop> argument.
1813 1861
… …
1838 1886
1839 myclass (); 1887 myclass ();
1840 } 1888 }
1841 1889
1842 myclass::myclass (int fd) 1890 myclass::myclass (int fd)
1843 : io (this, &myclass::io_cb),
1844 idle (this, &myclass::idle_cb)
1845 { 1891 {
1892 io .set <myclass, &myclass::io_cb > (this);
1893 idle.set <myclass, &myclass::idle_cb> (this);
1894
1846 io.start (fd, ev::READ); 1895 io.start (fd, ev::READ);
1847 } 1896 }
1848 1897
1849 1898
1850=head1 MACRO MAGIC 1899=head1 MACRO MAGIC

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines