upmpdcli / Code / Diff of /src/netcon.h

Diff of /src/netcon.h [0f8387] .. [a53cdf]

Switch to unified view


...
#else
#include "config.h"
#endif

#include <sys/time.h>

#include <string>

#include <memory>

/// A set of classes to manage client-server communication over a
/// connection-oriented network, or a pipe.
///
...
    /// connection timeout issues.
    virtual int set_nonblock(int onoff);

    /// Decide what events the connection will be looking for
    /// (NETCONPOLL_READ, NETCONPOLL_WRITE)
    int setselevents(int evs);


    /// Retrieve the connection's currently monitored set of events
    int getselevents() {
        return m_wantedEvents;








    }

    friend class SelectLoop;
    SelectLoop *getloop() {
        return m_loop;
...
protected:
    char *m_peer;   // Name of the connected host
    int   m_fd;
    bool  m_ownfd;
    int   m_didtimo;
    // Used when part of the selectloop.
    short m_wantedEvents;
    SelectLoop *m_loop;
    // Method called by the selectloop when something can be done with a netcon
    virtual int cando(Netcon::Event reason) = 0;
    // Called when added to loop
...


/// The selectloop interface is used to implement parallel servers.
// The select loop mechanism allows several netcons to be used for io
// in a program without blocking as long as there is data to be read
// or written. In a multithread program, if each thread needs
// non-blocking IO it may make sense to have one SelectLoop active per
// thread.
class SelectLoop {
public:
    SelectLoop();
    SelectLoop(const SelectLoop&) = delete;
    SelectLoop& operator=(const SelectLoop&) = delete;
    ~SelectLoop();
    
    /// Add a connection to be monitored (this will usually be called
    /// from the server's listen connection's accept callback)
    int addselcon(NetconP con, int events);

    /// Remove a connection from the monitored set. This is
    /// automatically called when EOF is detected on a connection.
    int remselcon(NetconP con);

    /// Set a function to be called periodically, or a time before return.
    /// @param handler the function to be called.
    ///  - if it is 0, doLoop() will return after ms mS (and can be called
    ///    again)
    ///  - if it is not 0, it will be called at ms mS intervals. If its return
    ///    value is <= 0, selectloop will return.
    /// @param clp client data to be passed to handler at every call.
    /// @param ms milliseconds interval between handler calls or
    ///   before return. Set to 0 for no periodic handler.
    void setperiodichandler(int (*handler)(void *), void *clp, int ms);

    /// Loop waiting for events on the connections and call the
    /// cando() method on the object when something happens (this will in
    /// turn typically call the app callback set on the netcon). Possibly
    /// call the periodic handler (if set) at regular intervals.
    /// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic
    ///  timeout (should call back in after processing)
    int doLoop();

    /// Call from data handler: make doLoop() return @param value
    void loopReturn(int value);










    friend class Netcon;










private:
    class Internal;
    Internal *m;















};

///////////////////////
class NetconData;


	a/src/netcon.h		b/src/netcon.h
	...		...
21	#else	21	#else
22	#include "config.h"	22	#include "config.h"
23	#endif	23	#endif
24		24
25	#include <sys/time.h>	25	#include <sys/time.h>
26	#include <map>	26
27	#include <string>	27	#include <string>
28
29	#include <memory>	28	#include <memory>
30		29
31	/// A set of classes to manage client-server communication over a	30	/// A set of classes to manage client-server communication over a
32	/// connection-oriented network, or a pipe.	31	/// connection-oriented network, or a pipe.
33	///	32	///
	...		...
83	/// connection timeout issues.	82	/// connection timeout issues.
84	virtual int set_nonblock(int onoff);	83	virtual int set_nonblock(int onoff);
85		84
86	/// Decide what events the connection will be looking for	85	/// Decide what events the connection will be looking for
87	/// (NETCONPOLL_READ, NETCONPOLL_WRITE)	86	/// (NETCONPOLL_READ, NETCONPOLL_WRITE)
88	int setselevents(int evs) {	87	int setselevents(int evs);
89	return m_wantedEvents = evs;
90	}
91	/// Retrieve the connection's currently monitored set of events	88	/// Retrieve the connection's currently monitored set of events
92	int getselevents() {	89	int getselevents() {
93	return m_wantedEvents;	90	return m_wantedEvents;
94	}
95	/// Add events to current set
96	int addselevents(int evs) {
97	return m_wantedEvents \|= evs;
98	}
99	/// Clear events from current set
100	int clearselevents(int evs) {
101	return m_wantedEvents &= ~evs;
102	}	91	}
103		92
104	friend class SelectLoop;	93	friend class SelectLoop;
105	SelectLoop *getloop() {	94	SelectLoop *getloop() {
106	return m_loop;	95	return m_loop;
	...		...
113	protected:	102	protected:
114	char *m_peer; // Name of the connected host	103	char *m_peer; // Name of the connected host
115	int m_fd;	104	int m_fd;
116	bool m_ownfd;	105	bool m_ownfd;
117	int m_didtimo;	106	int m_didtimo;
118	// Used when part of the selectloop map.	107	// Used when part of the selectloop.
119	short m_wantedEvents;	108	short m_wantedEvents;
120	SelectLoop *m_loop;	109	SelectLoop *m_loop;
121	// Method called by the selectloop when something can be done with a netcon	110	// Method called by the selectloop when something can be done with a netcon
122	virtual int cando(Netcon::Event reason) = 0;	111	virtual int cando(Netcon::Event reason) = 0;
123	// Called when added to loop	112	// Called when added to loop
	...		...
128		117
129		118
130	/// The selectloop interface is used to implement parallel servers.	119	/// The selectloop interface is used to implement parallel servers.
131	// The select loop mechanism allows several netcons to be used for io	120	// The select loop mechanism allows several netcons to be used for io
132	// in a program without blocking as long as there is data to be read	121	// in a program without blocking as long as there is data to be read
133	// or written. In a multithread program which is also using select, it	122	// or written. In a multithread program, if each thread needs
134	// would typically make sense to have one SelectLoop active per	123	// non-blocking IO it may make sense to have one SelectLoop active per
135	// thread.	124	// thread.
136	class SelectLoop {	125	class SelectLoop {
137	public:	126	public:
138	SelectLoop()	127	SelectLoop();
139	: m_selectloopDoReturn(false), m_selectloopReturnValue(0),	128	SelectLoop(const SelectLoop&) = delete;
140	m_placetostart(0),	129	SelectLoop& operator=(const SelectLoop&) = delete;
141	m_periodichandler(0), m_periodicparam(0), m_periodicmillis(0) {	130	~SelectLoop();
142	}	131
		132	/// Add a connection to be monitored (this will usually be called
		133	/// from the server's listen connection's accept callback)
		134	int addselcon(NetconP con, int events);
		135
		136	/// Remove a connection from the monitored set. This is
		137	/// automatically called when EOF is detected on a connection.
		138	int remselcon(NetconP con);
		139
		140	/// Set a function to be called periodically, or a time before return.
		141	/// @param handler the function to be called.
		142	/// - if it is 0, doLoop() will return after ms mS (and can be called
		143	/// again)
		144	/// - if it is not 0, it will be called at ms mS intervals. If its return
		145	/// value is <= 0, selectloop will return.
		146	/// @param clp client data to be passed to handler at every call.
		147	/// @param ms milliseconds interval between handler calls or
		148	/// before return. Set to 0 for no periodic handler.
		149	void setperiodichandler(int (handler)(void ), void *clp, int ms);
143		150
144	/// Loop waiting for events on the connections and call the	151	/// Loop waiting for events on the connections and call the
145	/// cando() method on the object when something happens (this will in	152	/// cando() method on the object when something happens (this will in
146	/// turn typically call the app callback set on the netcon). Possibly	153	/// turn typically call the app callback set on the netcon). Possibly
147	/// call the periodic handler (if set) at regular intervals.	154	/// call the periodic handler (if set) at regular intervals.
148	/// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic	155	/// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic
149	/// timeout (should call back in after processing)	156	/// timeout (should call back in after processing)
150	int doLoop();	157	int doLoop();
151		158
152	/// Call from data handler: make selectloop return the param value	159	/// Call from data handler: make doLoop() return @param value
153	void loopReturn(int value) {	160	void loopReturn(int value);
154	m_selectloopDoReturn = true;
155	m_selectloopReturnValue = value;
156	}
157	/// Add a connection to be monitored (this will usually be called
158	/// from the server's listen connection's accept callback)
159	int addselcon(NetconP con, int events);
160	/// Remove a connection from the monitored set. This is
161	/// automatically called when EOF is detected on a connection.
162	int remselcon(NetconP con);
163		161
164	/// Set a function to be called periodically, or a time before return.	162	friend class Netcon;
165	/// @param handler the function to be called.
166	/// - if it is 0, selectloop() will return after ms mS (and can be called
167	/// again
168	/// - if it is not 0, it will be called at ms mS intervals. If its return
169	/// value is <= 0, selectloop will return.
170	/// @param clp client data to be passed to handler at every call.
171	/// @param ms milliseconds interval between handler calls or
172	/// before return. Set to 0 for no periodic handler.
173	void setperiodichandler(int (handler)(void ), void *clp, int ms);
174
175	private:	163	private:
176	// Set by client callback to tell selectloop to return.	164	class Internal;
177	bool m_selectloopDoReturn;	165	Internal *m;
178	int m_selectloopReturnValue;
179	int m_placetostart;
180
181	// Map of NetconP indexed by fd
182	std::map<int, NetconP> m_polldata;
183
184	// The last time we did the periodic thing. Initialized by setperiodic()
185	struct timeval m_lasthdlcall;
186	// The call back function and its parameter
187	int (m_periodichandler)(void );
188	void *m_periodicparam;
189	// The periodic interval
190	int m_periodicmillis;
191	void periodictimeout(struct timeval *tv);
192	int maybecallperiodic();
193	};	166	};
194		167
195	///////////////////////	168	///////////////////////
196	class NetconData;	169	class NetconData;
197		170