1412101967
2 2
8 libp3net 4 7xrj 12 panda3d.core 
170
178 5 clear 0 4 349 34 PointerToBase< Connection >::clear 0 1 9 0
55
inline void ::PointerToBase< Connection >::clear(void);

179 6 output 0 4 349 35 PointerToBase< Connection >::output 0 1 10 0
63
void ::PointerToBase< Connection >::output(ostream &out) const;

180 9 PointerTo 0 4 348 34 PointerTo< Connection >::PointerTo 0 3 1 2 3 0
175
inline ::PointerTo< Connection >::PointerTo(Connection *ptr = ((Connection *)((void *)(0))));
inline ::PointerTo< Connection >::PointerTo(PointerTo< Connection > const &copy);

181 10 ~PointerTo 0 4 348 35 PointerTo< Connection >::~PointerTo 0 0 0
51
inline ::PointerTo< Connection >::~PointerTo(void);

182 1 p 0 4 348 26 PointerTo< Connection >::p 0 1 4 663
// When downcasting to a derived class from a PointerTo<BaseClass>,
// C++ would normally require you to cast twice: once to an actual
// BaseClass pointer, and then again to your desired pointer.  You
// can use the handy function p() to avoid this first cast and make
// your code look a bit cleaner.
// e.g. instead of (MyType *)(BaseClass *)ptr, use (MyType *)ptr.p()
// If your base class is a derivative of TypedObject, you might want
// to use the DCAST macro defined in typedObject.h instead,
// e.g. DCAST(MyType, ptr).  This provides a clean downcast that
// doesn't require .p() or any double-casting, and it can be
// run-time checked for correctness.
60
inline Connection *::PointerTo< Connection >::p(void) const;

183 10 operator = 0 4 348 35 PointerTo< Connection >::operator = 0 2 5 6 0
195
inline PointerTo< Connection > &::PointerTo< Connection >::operator =(Connection *ptr);
inline PointerTo< Connection > &::PointerTo< Connection >::operator =(PointerTo< Connection > const &copy);

184 7 is_null 0 4 348 32 PointerTo< Connection >::is_null 0 1 7 259
// These functions normally wouldn't need to be redefined here, but
// we do so anyway just to help out interrogate (which doesn't seem
// to want to automatically export the PointerToBase class).  When
// this works again in interrogate, we can remove these.
59
inline bool ::PointerTo< Connection >::is_null(void) const;

185 5 clear 0 4 348 30 PointerTo< Connection >::clear 0 1 8 259
// These functions normally wouldn't need to be redefined here, but
// we do so anyway just to help out interrogate (which doesn't seem
// to want to automatically export the PointerToBase class).  When
// this works again in interrogate, we can remove these.
51
inline void ::PointerTo< Connection >::clear(void);

186 10 NetAddress 0 4 351 22 NetAddress::NetAddress 0 2 11 12 733
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::Constructor
//       Access: Public
//  Description: Constructs an unspecified address.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NetAddress::Constructor
//       Access: Public
//  Description: Constructs an address from a given Socket_Address.
//               Normally, this constructor should not be used by user
//               code; instead, create a default NetAddress and use
//               one of the set_*() functions to set up an address.
////////////////////////////////////////////////////////////////////
81
NetAddress::NetAddress(void);
NetAddress::NetAddress(Socket_Address const &addr);

187 7 set_any 0 4 351 19 NetAddress::set_any 0 1 13 429
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_any
//       Access: Public
//  Description: Sets the address up to refer to a particular port,
//               but not to any particular IP.  Returns true if
//               successful, false otherwise (currently, this only
//               returns true).
////////////////////////////////////////////////////////////////////
35
bool NetAddress::set_any(int port);

188 13 set_localhost 0 4 351 25 NetAddress::set_localhost 0 1 14 303
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_localhost
//       Access: Public
//  Description: Sets the address up to refer to a particular port,
//               on this host.
////////////////////////////////////////////////////////////////////
41
bool NetAddress::set_localhost(int port);

189 13 set_broadcast 0 4 351 25 NetAddress::set_broadcast 0 1 15 264
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_broadcast
//       Access: Public
//  Description: Sets the address to the broadcast address.
////////////////////////////////////////////////////////////////////
41
bool NetAddress::set_broadcast(int port);

190 8 set_host 0 4 351 20 NetAddress::set_host 0 1 16 379
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_host
//       Access: Public
//  Description: Sets the address up to refer to a particular port
//               on a particular host.  Returns true if the hostname
//               is known, false otherwise.
////////////////////////////////////////////////////////////////////
74
bool NetAddress::set_host(basic_string< char > const &hostname, int port);

191 5 clear 0 4 351 17 NetAddress::clear 0 1 17 257
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::clear
//       Access: Public
//  Description: Resets the NetAddress to its initial state.
////////////////////////////////////////////////////////////////////
29
void NetAddress::clear(void);

192 8 get_port 0 4 351 20 NetAddress::get_port 0 1 18 270
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_port
//       Access: Public
//  Description: Returns the port number to which this address refers.
////////////////////////////////////////////////////////////////////
37
int NetAddress::get_port(void) const;

193 8 set_port 0 4 351 20 NetAddress::set_port 0 1 19 296
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_port
//       Access: Public
//  Description: Resets the port number without otherwise changing the
//               address.
////////////////////////////////////////////////////////////////////
36
void NetAddress::set_port(int port);

194 13 get_ip_string 0 4 351 25 NetAddress::get_ip_string 0 1 20 314
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip_string
//       Access: Public
//  Description: Returns the IP address to which this address refers,
//               formatted as a string.
////////////////////////////////////////////////////////////////////
59
basic_string< char > NetAddress::get_ip_string(void) const;

195 6 get_ip 0 4 351 18 NetAddress::get_ip 0 1 21 325
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip
//       Access: Public
//  Description: Returns the IP address to which this address refers,
//               as a 32-bit integer, in host byte order.
////////////////////////////////////////////////////////////////////
44
unsigned int NetAddress::get_ip(void) const;

196 16 get_ip_component 0 4 351 28 NetAddress::get_ip_component 0 1 22 471
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip_component
//       Access: Public
//  Description: Returns the nth 8-bit component of the IP address.
//               An IP address has four components; component 0 is the
//               first (leftmost), and component 3 is the last
//               (rightmost) in the dotted number convention.
////////////////////////////////////////////////////////////////////
56
unsigned char NetAddress::get_ip_component(int n) const;

197 8 get_addr 0 4 351 20 NetAddress::get_addr 0 1 23 261
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_addr
//       Access: Public
//  Description: Returns the Socket_Address for this address.
////////////////////////////////////////////////////////////////////
55
Socket_Address const &NetAddress::get_addr(void) const;

198 6 output 0 4 351 18 NetAddress::output 0 1 24 214
////////////////////////////////////////////////////////////////////
//     Function: NetAddress::output
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
44
void NetAddress::output(ostream &out) const;

199 11 ~NetAddress 0 4 351 23 NetAddress::~NetAddress 0 0 0
30
NetAddress::~NetAddress(void);

200 10 Connection 0 4 352 22 Connection::Connection 0 1 25 434
////////////////////////////////////////////////////////////////////
//     Function: Connection::Constructor
//       Access: Published
//  Description: Creates a connection.  Normally this constructor
//               should not be used directly by user code; use one of
//               the methods in ConnectionManager to make a new
//               connection.
////////////////////////////////////////////////////////////////////
70
Connection::Connection(ConnectionManager *manager, Socket_IP *socket);

201 11 get_address 0 4 352 23 Connection::get_address 0 1 26 312
////////////////////////////////////////////////////////////////////
//     Function: Connection::get_address
//       Access: Published
//  Description: Returns the address bound to this connection, if it
//               is a TCP connection.
////////////////////////////////////////////////////////////////////
47
NetAddress Connection::get_address(void) const;

202 11 get_manager 0 4 352 23 Connection::get_manager 0 1 27 318
////////////////////////////////////////////////////////////////////
//     Function: Connection::get_manager
//       Access: Published
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this connection.
////////////////////////////////////////////////////////////////////
55
ConnectionManager *Connection::get_manager(void) const;

203 10 get_socket 0 4 352 22 Connection::get_socket 0 1 28 298
////////////////////////////////////////////////////////////////////
//     Function: Connection::get_socket
//       Access: Published
//  Description: Returns the internal Socket_IP that defines the
//               connection.
////////////////////////////////////////////////////////////////////
46
Socket_IP *Connection::get_socket(void) const;

204 15 set_collect_tcp 0 4 352 27 Connection::set_collect_tcp 0 1 29 1146
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_collect_tcp
//       Access: Published
//  Description: Enables or disables "collect-tcp" mode.  In this
//               mode, individual TCP packets are not sent
//               immediately, but rather they are collected together
//               and accumulated to be sent periodically as one larger
//               TCP packet.  This cuts down on overhead from the
//               TCP/IP protocol, especially if many small packets
//               need to be sent on the same connection, but it
//               introduces additional latency (since packets must be
//               held before they can be sent).
//
//               See set_collect_tcp_interval() to specify the
//               interval of time for which to hold packets before
//               sending them.
//
//               If you enable this mode, you may also need to
//               periodically call consider_flush() to flush the queue
//               if no packets have been sent recently.
////////////////////////////////////////////////////////////////////
51
void Connection::set_collect_tcp(bool collect_tcp);

205 15 get_collect_tcp 0 4 352 27 Connection::get_collect_tcp 0 1 30 317
////////////////////////////////////////////////////////////////////
//     Function: Connection::get_collect_tcp
//       Access: Published
//  Description: Returns the current setting of "collect-tcp" mode.
//               See set_collect_tcp().
////////////////////////////////////////////////////////////////////
45
bool Connection::get_collect_tcp(void) const;

206 24 set_collect_tcp_interval 0 4 352 36 Connection::set_collect_tcp_interval 0 1 31 518
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_collect_tcp_interval
//       Access: Published
//  Description: Specifies the interval in time, in seconds, for which
//               to hold TCP packets before sending all of the
//               recently received packets at once.  This only has
//               meaning if "collect-tcp" mode is enabled; see
//               set_collect_tcp().
////////////////////////////////////////////////////////////////////
59
void Connection::set_collect_tcp_interval(double interval);

207 24 get_collect_tcp_interval 0 4 352 36 Connection::get_collect_tcp_interval 0 1 32 516
////////////////////////////////////////////////////////////////////
//     Function: Connection::get_collect_tcp_interval
//       Access: Published
//  Description: Returns the interval in time, in seconds, for which
//               to hold TCP packets before sending all of the
//               recently received packets at once.  This only has
//               meaning if "collect-tcp" mode is enabled; see
//               set_collect_tcp().
////////////////////////////////////////////////////////////////////
56
double Connection::get_collect_tcp_interval(void) const;

208 14 consider_flush 0 4 352 26 Connection::consider_flush 0 1 33 400
////////////////////////////////////////////////////////////////////
//     Function: Connection::consider_flush
//       Access: Published
//  Description: Sends the most recently queued TCP datagram(s) if
//               enough time has elapsed.  This only has meaning if
//               set_collect_tcp() has been set to true.
////////////////////////////////////////////////////////////////////
38
bool Connection::consider_flush(void);

209 5 flush 0 4 352 17 Connection::flush 0 1 34 367
////////////////////////////////////////////////////////////////////
//     Function: Connection::flush
//       Access: Published
//  Description: Sends the most recently queued TCP datagram(s) now.
//               This only has meaning if set_collect_tcp() has been
//               set to true.
////////////////////////////////////////////////////////////////////
29
bool Connection::flush(void);

210 10 set_linger 0 4 352 22 Connection::set_linger 0 1 35 785
// Socket options.
//  void set_nonblock(bool flag);

////////////////////////////////////////////////////////////////////
//     Function: Connection::set_linger
//       Access: Published
//  Description: Sets the time to linger on close if data is present.
//               If flag is false, when you close a socket with data
//               available the system attempts to deliver the data to
//               the peer (the default behavior).  If flag is false
//               but time is zero, the system discards any undelivered
//               data when you close the socket.  If flag is false but
//               time is nonzero, the system waits up to time seconds
//               to deliver the data.
////////////////////////////////////////////////////////////////////
52
void Connection::set_linger(bool flag, double time);

211 14 set_reuse_addr 0 4 352 26 Connection::set_reuse_addr 0 1 36 324
// Socket options.
//  void set_nonblock(bool flag);

////////////////////////////////////////////////////////////////////
//     Function: Connection::set_reuse_addr
//       Access: Published
//  Description: Sets whether local address reuse is allowed.
////////////////////////////////////////////////////////////////////
43
void Connection::set_reuse_addr(bool flag);

212 14 set_keep_alive 0 4 352 26 Connection::set_keep_alive 0 1 37 322
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_keep_alive
//       Access: Published
//  Description: Sets whether the connection is periodically tested to
//               see if it is still alive.
////////////////////////////////////////////////////////////////////
43
void Connection::set_keep_alive(bool flag);

213 20 set_recv_buffer_size 0 4 352 32 Connection::set_recv_buffer_size 0 1 38 278
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_recv_buffer_size
//       Access: Published
//  Description: Sets the size of the receive buffer, in bytes.
////////////////////////////////////////////////////////////////////
48
void Connection::set_recv_buffer_size(int size);

214 20 set_send_buffer_size 0 4 352 32 Connection::set_send_buffer_size 0 1 39 275
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_send_buffer_size
//       Access: Published
//  Description: Sets the size of the send buffer, in bytes.
////////////////////////////////////////////////////////////////////
48
void Connection::set_send_buffer_size(int size);

215 19 set_ip_time_to_live 0 4 352 31 Connection::set_ip_time_to_live 0 1 40 252
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_ip_time_to_live
//       Access: Published
//  Description: Sets IP time-to-live.
////////////////////////////////////////////////////////////////////
46
void Connection::set_ip_time_to_live(int ttl);

216 22 set_ip_type_of_service 0 4 352 34 Connection::set_ip_type_of_service 0 1 41 273
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_ip_type_of_service
//       Access: Published
//  Description: Sets IP type-of-service and precedence.
////////////////////////////////////////////////////////////////////
49
void Connection::set_ip_type_of_service(int tos);

217 12 set_no_delay 0 4 352 24 Connection::set_no_delay 0 1 42 343
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_no_delay
//       Access: Published
//  Description: If flag is true, this disables the Nagle algorithm,
//               and prevents delaying of send to coalesce packets.
////////////////////////////////////////////////////////////////////
41
void Connection::set_no_delay(bool flag);

218 15 set_max_segment 0 4 352 27 Connection::set_max_segment 0 1 43 257
////////////////////////////////////////////////////////////////////
//     Function: Connection::set_max_segment
//       Access: Published
//  Description: Sets the maximum segment size.
////////////////////////////////////////////////////////////////////
43
void Connection::set_max_segment(int size);

219 17 ~ConnectionReader 0 6 354 35 ConnectionReader::~ConnectionReader 0 0 236
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
50
virtual ConnectionReader::~ConnectionReader(void);

220 14 add_connection 0 4 354 32 ConnectionReader::add_connection 0 1 44 875
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::add_connection
//       Access: Published
//  Description: Adds a new socket to the list of sockets the
//               ConnectionReader will monitor.  A datagram that comes
//               in on any of the monitored sockets will be reported.
//               In the case of a ConnectionListener, this adds a new
//               rendezvous socket; any activity on any of the
//               monitored sockets will cause a connection to be
//               accepted.
//
//               The return value is true if the connection was added,
//               false if it was already there.
//
//               add_connection() is thread-safe, and may be called at
//               will by any thread.
////////////////////////////////////////////////////////////////////
62
bool ConnectionReader::add_connection(Connection *connection);

221 17 remove_connection 0 4 354 35 ConnectionReader::remove_connection 0 1 45 561
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::remove_connection
//       Access: Published
//  Description: Removes a socket from the list of sockets being
//               monitored.  Returns true if the socket was correctly
//               removed, false if it was not on the list in the first
//               place.
//
//               remove_connection() is thread-safe, and may be called
//               at will by any thread.
////////////////////////////////////////////////////////////////////
65
bool ConnectionReader::remove_connection(Connection *connection);

222 16 is_connection_ok 0 4 354 34 ConnectionReader::is_connection_ok 0 1 46 658
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::is_connection_ok
//       Access: Published
//  Description: Returns true if the indicated connection has been
//               added to the ConnectionReader and is being monitored
//               properly, false if it is not known, or if there was
//               some error condition detected on the connection.  (If
//               there was an error condition, normally the
//               ConnectionManager would have been informed and closed
//               the connection.)
////////////////////////////////////////////////////////////////////
64
bool ConnectionReader::is_connection_ok(Connection *connection);

223 4 poll 0 4 354 22 ConnectionReader::poll 0 1 47 628
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::poll
//       Access: Published
//  Description: Explicitly polls the available sockets to see if any
//               of them have any noise.  This function does nothing
//               unless this is a polling-type ConnectionReader,
//               i.e. it was created with zero threads (and
//               is_polling() will return true).
//
//               It is not necessary to call this explicitly for a
//               QueuedConnectionReader.
////////////////////////////////////////////////////////////////////
34
void ConnectionReader::poll(void);

224 11 get_manager 0 4 354 29 ConnectionReader::get_manager 0 1 48 330
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_manager
//       Access: Published
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this ConnectionReader.
////////////////////////////////////////////////////////////////////
61
ConnectionManager *ConnectionReader::get_manager(void) const;

225 10 is_polling 0 4 354 28 ConnectionReader::is_polling 0 1 49 808
// Filename: connectionReader.I
// Created by:  drose (15Feb09)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::is_polling
//       Access: Published
//  Description: Returns true if the reader is a polling reader,
//               i.e. it has no threads.
////////////////////////////////////////////////////////////////////
53
inline bool ConnectionReader::is_polling(void) const;

226 15 get_num_threads 0 4 354 33 ConnectionReader::get_num_threads 0 1 50 323
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_num_threads
//       Access: Published
//  Description: Returns the number of threads the ConnectionReader
//               has been created with.
////////////////////////////////////////////////////////////////////
50
int ConnectionReader::get_num_threads(void) const;

227 12 set_raw_mode 0 4 354 30 ConnectionReader::set_raw_mode 0 1 51 606
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::set_raw_mode
//       Access: Published
//  Description: Sets the ConnectionReader into raw mode (or turns off
//               raw mode).  In raw mode, datagram headers are not
//               expected; instead, all the data available on the pipe
//               is treated as a single datagram.
//
//               This is similar to set_tcp_header_size(0), except that it
//               also turns off headers for UDP packets.
////////////////////////////////////////////////////////////////////
47
void ConnectionReader::set_raw_mode(bool mode);

228 12 get_raw_mode 0 4 354 30 ConnectionReader::get_raw_mode 0 1 52 316
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_raw_mode
//       Access: Published
//  Description: Returns the current setting of the raw mode flag.
//               See set_raw_mode().
////////////////////////////////////////////////////////////////////
48
bool ConnectionReader::get_raw_mode(void) const;

229 19 set_tcp_header_size 0 4 354 37 ConnectionReader::set_tcp_header_size 0 1 53 555
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::set_tcp_header_size
//       Access: Published
//  Description: Sets the header size of TCP packets.  At the present,
//               legal values for this are 0, 2, or 4; this specifies
//               the number of bytes to use encode the datagram length
//               at the start of each TCP datagram.  Sender and
//               receiver must independently agree on this.
////////////////////////////////////////////////////////////////////
64
void ConnectionReader::set_tcp_header_size(int tcp_header_size);

230 19 get_tcp_header_size 0 4 354 37 ConnectionReader::get_tcp_header_size 0 1 54 328
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_tcp_header_size
//       Access: Published
//  Description: Returns the current setting of TCP header size.
//               See set_tcp_header_size().
////////////////////////////////////////////////////////////////////
54
int ConnectionReader::get_tcp_header_size(void) const;

231 8 shutdown 0 4 354 26 ConnectionReader::shutdown 0 1 55 392
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::shutdown
//       Access: Published
//  Description: Terminates all threads cleanly.  Normally this is
//               only called by the destructor, but it may be called
//               explicitly before destruction.
////////////////////////////////////////////////////////////////////
38
void ConnectionReader::shutdown(void);

232 19 ~ConnectionListener 0 4 355 39 ConnectionListener::~ConnectionListener 0 0 0
46
ConnectionListener::~ConnectionListener(void);

233 11 NetDatagram 0 4 356 24 NetDatagram::NetDatagram 0 3 56 57 58 980
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Constructor
//       Access: Public
//  Description: Constructs an empty datagram.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Constructor
//       Access: Public
//  Description: Constructs a datagram from an existing block of data.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
193
NetDatagram::NetDatagram(void);
NetDatagram::NetDatagram(void const *data, unsigned int size);
NetDatagram::NetDatagram(Datagram const &copy);
NetDatagram::NetDatagram(NetDatagram const &copy);

234 10 operator = 0 4 356 23 NetDatagram::operator = 0 2 59 60 468
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Assignment Operator
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Assignment Operator
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
106
void NetDatagram::operator =(Datagram const &copy);
void NetDatagram::operator =(NetDatagram const &copy);

235 14 set_connection 0 4 356 27 NetDatagram::set_connection 0 1 61 302
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_connection
//       Access: Public
//  Description: Specifies the socket to which the datagram should be
//               written.
////////////////////////////////////////////////////////////////////
76
void NetDatagram::set_connection(PointerTo< Connection > const &connection);

236 14 get_connection 0 4 356 27 NetDatagram::get_connection 0 1 62 338
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_connection
//       Access: Public
//  Description: Retrieves the socket from which the datagram was
//               read, or to which it is scheduled to be written.
////////////////////////////////////////////////////////////////////
64
PointerTo< Connection > NetDatagram::get_connection(void) const;

237 11 set_address 0 4 356 24 NetDatagram::set_address 0 1 63 294
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_address
//       Access: Public
//  Description: Specifies the host to which the datagram should be
//               sent.
////////////////////////////////////////////////////////////////////
57
void NetDatagram::set_address(NetAddress const &address);

238 11 get_address 0 4 356 24 NetDatagram::get_address 0 1 64 330
////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_address
//       Access: Public
//  Description: Retrieves the host from which the datagram was
//               read, or to which it is scheduled to be sent.
////////////////////////////////////////////////////////////////////
55
NetAddress const &NetDatagram::get_address(void) const;

239 14 get_class_type 0 4 356 27 NetDatagram::get_class_type 0 1 65 0
52
static TypeHandle NetDatagram::get_class_type(void);

240 12 ~NetDatagram 0 4 356 25 NetDatagram::~NetDatagram 0 0 0
32
NetDatagram::~NetDatagram(void);

241 17 ConnectionManager 0 4 358 36 ConnectionManager::ConnectionManager 0 1 66 229
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
43
ConnectionManager::ConnectionManager(void);

242 18 ~ConnectionManager 0 6 358 37 ConnectionManager::~ConnectionManager 0 0 237
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
52
virtual ConnectionManager::~ConnectionManager(void);

243 19 open_UDP_connection 0 4 358 38 ConnectionManager::open_UDP_connection 0 4 67 68 69 70 1756
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               This variant accepts both a hostname and port to
//               listen on a particular interface; if the hostname is
//               empty, all interfaces will be available.
//
//               If for_broadcast is true, this UDP connection will be
//               configured to send and/or receive messages on the
//               broadcast address (255.255.255.255); otherwise, these
//               messages may be automatically filtered by the OS.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
////////////////////////////////////////////////////////////////////
217
PointerTo< Connection > ConnectionManager::open_UDP_connection(int port = (0));
PointerTo< Connection > ConnectionManager::open_UDP_connection(basic_string< char > const &hostname, int port, bool for_broadcast = (0));

244 26 open_TCP_server_rendezvous 0 4 358 45 ConnectionManager::open_TCP_server_rendezvous 0 3 71 72 73 2577
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a single port,
//               and will listen to that port on all available
//               interfaces.
//
//               backlog is the maximum length of the queue of pending
//               connections.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a "hostname",
//               which is usually just an IP address in dotted
//               notation, and a port number.  It will listen on the
//               interface indicated by the IP address.  If the IP
//               address is empty string, it will listen on all
//               interfaces.
//
//               backlog is the maximum length of the queue of pending
//               connections.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a NetAddress,
//               which allows you to specify a specific interface to
//               listen to.
//
//               backlog is the maximum length of the queue of pending
//               connections.
////////////////////////////////////////////////////////////////////
336
PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(int port, int backlog);
PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(basic_string< char > const &hostname, int port, int backlog);
PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(NetAddress const &address, int backlog);

245 26 open_TCP_client_connection 0 4 358 45 ConnectionManager::open_TCP_client_connection 0 2 74 75 867
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_client_connection
//       Access: Published
//  Description: Attempts to establish a TCP client connection to a
//               server at the indicated address.  If the connection
//               is not established within timeout_ms milliseconds, a
//               null connection is returned.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_client_connection
//       Access: Published
//  Description: This is a shorthand version of the function to
//               directly establish communications to a named host and
//               port.
////////////////////////////////////////////////////////////////////
248
PointerTo< Connection > ConnectionManager::open_TCP_client_connection(NetAddress const &address, int timeout_ms);
PointerTo< Connection > ConnectionManager::open_TCP_client_connection(basic_string< char > const &hostname, int port, int timeout_ms);

246 16 close_connection 0 4 358 35 ConnectionManager::close_connection 0 1 76 1093
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::close_connection
//       Access: Published
//  Description: Terminates a UDP or TCP socket previously opened.
//               This also removes it from any associated
//               ConnectionReader or ConnectionListeners.
//
//               The socket itself may not be immediately closed--it
//               will not be closed until all outstanding pointers to
//               it are cleared, including any pointers remaining in
//               NetDatagrams recently received from the socket.
//
//               The return value is true if the connection was marked
//               to be closed, or false if close_connection() had
//               already been called (or the connection did not belong
//               to this ConnectionManager).  In neither case can you
//               infer anything about whether the connection has
//               *actually* been closed yet based on the return value.
////////////////////////////////////////////////////////////////////
84
bool ConnectionManager::close_connection(PointerTo< Connection > const &connection);

247 16 wait_for_readers 0 4 358 35 ConnectionManager::wait_for_readers 0 1 77 1081
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::wait_for_readers
//       Access: Published
//  Description: Blocks the process for timeout number of seconds, or
//               until any data is available on any of the
//               non-threaded ConnectionReaders or
//               ConnectionListeners, whichever comes first.  The
//               return value is true if there is data available (but
//               you have to iterate through all readers to find it),
//               or false if the timeout occurred without any data.
//
//               If the timeout value is negative, this will block
//               forever or until data is available.
//
//               This only works if all ConnectionReaders and
//               ConnectionListeners are non-threaded.  If any
//               threaded ConnectionReaders are part of the
//               ConnectionManager, the timeout value is implicitly
//               treated as 0.
////////////////////////////////////////////////////////////////////
57
bool ConnectionManager::wait_for_readers(double timeout);

248 13 get_host_name 0 4 358 32 ConnectionManager::get_host_name 0 1 78 405
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_host_name
//       Access: Published, Static
//  Description: Returns the name of this particular machine on the
//               network, if available, or the empty string if the
//               hostname cannot be determined.
////////////////////////////////////////////////////////////////////
67
static basic_string< char > ConnectionManager::get_host_name(void);

249 8 get_name 0 4 359 38 ConnectionManager::Interface::get_name 0 1 82 0
79
basic_string< char > const &ConnectionManager::Interface::get_name(void) const;

250 15 get_mac_address 0 4 359 45 ConnectionManager::Interface::get_mac_address 0 1 83 0
86
basic_string< char > const &ConnectionManager::Interface::get_mac_address(void) const;

251 6 has_ip 0 4 359 36 ConnectionManager::Interface::has_ip 0 1 84 0
54
bool ConnectionManager::Interface::has_ip(void) const;

252 6 get_ip 0 4 359 36 ConnectionManager::Interface::get_ip 0 1 85 0
67
NetAddress const &ConnectionManager::Interface::get_ip(void) const;

253 11 has_netmask 0 4 359 41 ConnectionManager::Interface::has_netmask 0 1 86 0
59
bool ConnectionManager::Interface::has_netmask(void) const;

254 11 get_netmask 0 4 359 41 ConnectionManager::Interface::get_netmask 0 1 87 0
72
NetAddress const &ConnectionManager::Interface::get_netmask(void) const;

255 13 has_broadcast 0 4 359 43 ConnectionManager::Interface::has_broadcast 0 1 88 0
61
bool ConnectionManager::Interface::has_broadcast(void) const;

256 13 get_broadcast 0 4 359 43 ConnectionManager::Interface::get_broadcast 0 1 89 0
74
NetAddress const &ConnectionManager::Interface::get_broadcast(void) const;

257 7 has_p2p 0 4 359 37 ConnectionManager::Interface::has_p2p 0 1 90 0
55
bool ConnectionManager::Interface::has_p2p(void) const;

258 7 get_p2p 0 4 359 37 ConnectionManager::Interface::get_p2p 0 1 91 0
68
NetAddress const &ConnectionManager::Interface::get_p2p(void) const;

259 6 output 0 4 359 36 ConnectionManager::Interface::output 0 1 92 236
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::Interface::Output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
62
void ConnectionManager::Interface::output(ostream &out) const;

260 10 ~Interface 0 4 359 40 ConnectionManager::Interface::~Interface 0 0 0
47
ConnectionManager::Interface::~Interface(void);

261 15 scan_interfaces 0 4 358 34 ConnectionManager::scan_interfaces 0 1 79 540
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::scan_interfaces
//       Access: Published
//  Description: Repopulates the list reported by
//               get_num_interface()/get_interface().  It is not
//               necessary to call this explicitly, unless you want to
//               re-determine the connected interfaces (for instance,
//               if you suspect the hardware has recently changed).
////////////////////////////////////////////////////////////////////
46
void ConnectionManager::scan_interfaces(void);

262 18 get_num_interfaces 0 4 358 37 ConnectionManager::get_num_interfaces 0 1 80 463
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_num_interfaces
//       Access: Published
//  Description: This returns the number of usable network interfaces
//               detected on this machine.  (Currently, only IPv4
//               interfaces are reported.)  See scan_interfaces() to
//               repopulate this list.
////////////////////////////////////////////////////////////////////
48
int ConnectionManager::get_num_interfaces(void);

263 13 get_interface 0 4 358 32 ConnectionManager::get_interface 0 1 81 446
////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_interface
//       Access: Published
//  Description: Returns the nth usable network interface detected on
//               this machine.  (Currently, only IPv4 interfaces are
//               reported.)  See scan_interfaces() to repopulate this
//               list.
////////////////////////////////////////////////////////////////////
76
ConnectionManager::Interface const &ConnectionManager::get_interface(int n);

264 16 ConnectionWriter 0 4 360 34 ConnectionWriter::ConnectionWriter 0 2 93 94 498
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::Constructor
//       Access: Public
//  Description: Creates a new ConnectionWriter with the indicated
//               number of threads to handle output.
//
//               If num_threads is 0, all datagrams will be sent
//               immediately instead of queueing for later
//               transmission by a thread.
////////////////////////////////////////////////////////////////////
136
ConnectionWriter::ConnectionWriter(ConnectionManager *manager, int num_threads, basic_string< char > const &thread_name = ((string())));

265 17 ~ConnectionWriter 0 4 360 35 ConnectionWriter::~ConnectionWriter 0 0 224
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
42
ConnectionWriter::~ConnectionWriter(void);

266 18 set_max_queue_size 0 4 360 36 ConnectionWriter::set_max_queue_size 0 1 95 460
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_max_queue_size
//       Access: Public
//  Description: Limits the number of packets that may be pending on
//               the outbound queue.  This only has an effect when
//               using threads; if num_threads is 0, then all packets
//               are sent immediately.
////////////////////////////////////////////////////////////////////
56
void ConnectionWriter::set_max_queue_size(int max_size);

267 18 get_max_queue_size 0 4 360 36 ConnectionWriter::get_max_queue_size 0 1 96 334
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_max_queue_size
//       Access: Public
//  Description: Returns the maximum size the queue is allowed to grow
//               to.  See set_max_queue_size().
////////////////////////////////////////////////////////////////////
53
int ConnectionWriter::get_max_queue_size(void) const;

268 22 get_current_queue_size 0 4 360 40 ConnectionWriter::get_current_queue_size 0 1 97 287
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_current_queue_size
//       Access: Public
//  Description: Returns the current number of things in the queue.
////////////////////////////////////////////////////////////////////
57
int ConnectionWriter::get_current_queue_size(void) const;

269 4 send 0 4 360 22 ConnectionWriter::send 0 4 98 99 100 101 2006
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  Since the host address is not specified with
//               this form, this function should only be used for
//               sending TCP packets.  Use the other send() method for
//               sending UDP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  This form of the function allows the
//               specification of a destination host address, and so
//               is appropriate for UDP packets.  Use the other send()
//               method for sending TCP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
////////////////////////////////////////////////////////////////////
258
bool ConnectionWriter::send(Datagram const &datagram, PointerTo< Connection > const &connection, bool block = (0));
bool ConnectionWriter::send(Datagram const &datagram, PointerTo< Connection > const &connection, NetAddress const &address, bool block = (0));

270 16 is_valid_for_udp 0 4 360 34 ConnectionWriter::is_valid_for_udp 0 1 102 339
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::is_valid_for_udp
//       Access: Public
//  Description: Returns true if the datagram is small enough to be
//               sent over a UDP packet, false otherwise.
////////////////////////////////////////////////////////////////////
72
bool ConnectionWriter::is_valid_for_udp(Datagram const &datagram) const;

271 11 get_manager 0 4 360 29 ConnectionWriter::get_manager 0 1 103 327
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_manager
//       Access: Public
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this ConnectionWriter.
////////////////////////////////////////////////////////////////////
61
ConnectionManager *ConnectionWriter::get_manager(void) const;

272 12 is_immediate 0 4 360 30 ConnectionWriter::is_immediate 0 1 104 318
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::is_immediate
//       Access: Public
//  Description: Returns true if the writer is an immediate writer,
//               i.e. it has no threads.
////////////////////////////////////////////////////////////////////
48
bool ConnectionWriter::is_immediate(void) const;

273 15 get_num_threads 0 4 360 33 ConnectionWriter::get_num_threads 0 1 105 320
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_num_threads
//       Access: Public
//  Description: Returns the number of threads the ConnectionWriter
//               has been created with.
////////////////////////////////////////////////////////////////////
50
int ConnectionWriter::get_num_threads(void) const;

274 12 set_raw_mode 0 4 360 30 ConnectionWriter::set_raw_mode 0 1 106 789
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_raw_mode
//       Access: Public
//  Description: Sets the ConnectionWriter into raw mode (or turns off
//               raw mode).  In raw mode, datagrams are not sent along
//               with their headers; the bytes in the datagram are
//               simply sent down the pipe.
//
//               Setting the ConnectionWriter to raw mode must be done
//               with care.  This can only be done when the matching
//               ConnectionReader is also set to raw mode, or when the
//               ConnectionWriter is communicating to a process that
//               does not expect datagrams.
////////////////////////////////////////////////////////////////////
47
void ConnectionWriter::set_raw_mode(bool mode);

275 12 get_raw_mode 0 4 360 30 ConnectionWriter::get_raw_mode 0 1 107 313
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_raw_mode
//       Access: Public
//  Description: Returns the current setting of the raw mode flag.
//               See set_raw_mode().
////////////////////////////////////////////////////////////////////
48
bool ConnectionWriter::get_raw_mode(void) const;

276 19 set_tcp_header_size 0 4 360 37 ConnectionWriter::set_tcp_header_size 0 1 108 552
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_tcp_header_size
//       Access: Public
//  Description: Sets the header size of TCP packets.  At the present,
//               legal values for this are 0, 2, or 4; this specifies
//               the number of bytes to use encode the datagram length
//               at the start of each TCP datagram.  Sender and
//               receiver must independently agree on this.
////////////////////////////////////////////////////////////////////
64
void ConnectionWriter::set_tcp_header_size(int tcp_header_size);

277 19 get_tcp_header_size 0 4 360 37 ConnectionWriter::get_tcp_header_size 0 1 109 325
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_tcp_header_size
//       Access: Public
//  Description: Returns the current setting of TCP header size.
//               See set_tcp_header_size().
////////////////////////////////////////////////////////////////////
54
int ConnectionWriter::get_tcp_header_size(void) const;

278 8 shutdown 0 4 360 26 ConnectionWriter::shutdown 0 1 110 402
////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::shutdown
//       Access: Published
//  Description: Stops all the threads and cleans them up.  This is
//               called automatically by the destructor, but it may be
//               called explicitly before destruction.
////////////////////////////////////////////////////////////////////
38
void ConnectionWriter::shutdown(void);

279 27 upcast_to_DatagramGenerator 0 12 361 49 DatagramGeneratorNet::upcast_to_DatagramGenerator 0 1 115 53
upcast from DatagramGeneratorNet to DatagramGenerator
75
DatagramGenerator *DatagramGeneratorNet::upcast_to_DatagramGenerator(void);

280 32 downcast_to_DatagramGeneratorNet 0 12 362 51 DatagramGenerator::downcast_to_DatagramGeneratorNet 0 1 116 55
downcast from DatagramGenerator to DatagramGeneratorNet
80
DatagramGeneratorNet *DatagramGenerator::downcast_to_DatagramGeneratorNet(void);

281 26 upcast_to_ConnectionReader 0 12 361 48 DatagramGeneratorNet::upcast_to_ConnectionReader 0 1 117 52
upcast from DatagramGeneratorNet to ConnectionReader
73
ConnectionReader *DatagramGeneratorNet::upcast_to_ConnectionReader(void);

282 32 downcast_to_DatagramGeneratorNet 0 12 354 50 ConnectionReader::downcast_to_DatagramGeneratorNet 0 1 118 54
downcast from ConnectionReader to DatagramGeneratorNet
79
DatagramGeneratorNet *ConnectionReader::downcast_to_DatagramGeneratorNet(void);

283 18 set_max_queue_size 0 4 363 44 QueuedReturn< Datagram >::set_max_queue_size 0 1 121 0
66
void ::QueuedReturn< Datagram >::set_max_queue_size(int max_size);

284 18 get_max_queue_size 0 4 363 44 QueuedReturn< Datagram >::get_max_queue_size 0 1 122 0
63
int ::QueuedReturn< Datagram >::get_max_queue_size(void) const;

285 22 get_current_queue_size 0 4 363 48 QueuedReturn< Datagram >::get_current_queue_size 0 1 123 0
67
int ::QueuedReturn< Datagram >::get_current_queue_size(void) const;

286 17 get_overflow_flag 0 4 363 43 QueuedReturn< Datagram >::get_overflow_flag 0 1 124 0
63
bool ::QueuedReturn< Datagram >::get_overflow_flag(void) const;

287 19 reset_overflow_flag 0 4 363 45 QueuedReturn< Datagram >::reset_overflow_flag 0 1 125 0
59
void ::QueuedReturn< Datagram >::reset_overflow_flag(void);

288 31 upcast_to_QueuedReturn_Datagram 0 12 361 53 DatagramGeneratorNet::upcast_to_QueuedReturn_Datagram 0 1 119 60
upcast from DatagramGeneratorNet to QueuedReturn< Datagram >
86
QueuedReturn< Datagram > *DatagramGeneratorNet::upcast_to_QueuedReturn_Datagram(void);

289 32 downcast_to_DatagramGeneratorNet 0 12 363 58 QueuedReturn< Datagram >::downcast_to_DatagramGeneratorNet 0 1 120 62
downcast from QueuedReturn< Datagram > to DatagramGeneratorNet
89
DatagramGeneratorNet *::QueuedReturn< Datagram >::downcast_to_DatagramGeneratorNet(void);

290 20 DatagramGeneratorNet 0 4 361 42 DatagramGeneratorNet::DatagramGeneratorNet 0 1 111 527
////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::Constructor
//       Access: Published
//  Description: Creates a new DatagramGeneratorNet with the indicated
//               number of threads to handle requests.  Normally
//               num_threads should be either 0 or 1 to guarantee that
//               datagrams are generated in the same order in which
//               they were received.
////////////////////////////////////////////////////////////////////
88
DatagramGeneratorNet::DatagramGeneratorNet(ConnectionManager *manager, int num_threads);

291 21 ~DatagramGeneratorNet 0 6 361 43 DatagramGeneratorNet::~DatagramGeneratorNet 0 0 241
////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::Destructor
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
58
virtual DatagramGeneratorNet::~DatagramGeneratorNet(void);

292 12 get_datagram 0 6 361 34 DatagramGeneratorNet::get_datagram 0 1 112 452
// Inherited from DatagramGenerator

////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::get_datagram
//       Access: Published, Virtual
//  Description: Reads the next datagram from the stream.  Blocks
//               until a datagram is available.  Returns true on
//               success, false on stream closed or error.
////////////////////////////////////////////////////////////////////
64
virtual bool DatagramGeneratorNet::get_datagram(Datagram &data);

293 6 is_eof 0 6 361 28 DatagramGeneratorNet::is_eof 0 1 113 430
// Inherited from DatagramGenerator

////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::is_eof
//       Access: Published, Virtual
//  Description: Returns true if the stream has been closed normally.
//               This test may only be made after a call to
//               get_datagram() has failed.
////////////////////////////////////////////////////////////////////
48
virtual bool DatagramGeneratorNet::is_eof(void);

294 8 is_error 0 6 361 30 DatagramGeneratorNet::is_error 0 1 114 289
////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::is_error
//       Access: Published, Virtual
//  Description: Returns true if the stream has an error condition.
////////////////////////////////////////////////////////////////////
50
virtual bool DatagramGeneratorNet::is_error(void);

295 22 upcast_to_DatagramSink 0 12 364 39 DatagramSinkNet::upcast_to_DatagramSink 0 1 132 43
upcast from DatagramSinkNet to DatagramSink
60
DatagramSink *DatagramSinkNet::upcast_to_DatagramSink(void);

296 27 downcast_to_DatagramSinkNet 0 12 365 41 DatagramSink::downcast_to_DatagramSinkNet 0 1 133 45
downcast from DatagramSink to DatagramSinkNet
65
DatagramSinkNet *DatagramSink::downcast_to_DatagramSinkNet(void);

297 26 upcast_to_ConnectionWriter 0 12 364 43 DatagramSinkNet::upcast_to_ConnectionWriter 0 1 134 47
upcast from DatagramSinkNet to ConnectionWriter
68
ConnectionWriter *DatagramSinkNet::upcast_to_ConnectionWriter(void);

298 27 downcast_to_DatagramSinkNet 0 12 360 45 ConnectionWriter::downcast_to_DatagramSinkNet 0 1 135 49
downcast from ConnectionWriter to DatagramSinkNet
69
DatagramSinkNet *ConnectionWriter::downcast_to_DatagramSinkNet(void);

299 15 DatagramSinkNet 0 4 364 32 DatagramSinkNet::DatagramSinkNet 0 1 126 512
////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::Constructor
//       Access: Published
//  Description: Creates a new DatagramSinkNet with the indicated
//               number of threads to handle writing.  Normally
//               num_threads should be either 0 or 1 to guarantee that
//               datagrams are delivered in the same order in which
//               they were sent.
////////////////////////////////////////////////////////////////////
78
DatagramSinkNet::DatagramSinkNet(ConnectionManager *manager, int num_threads);

300 10 set_target 0 4 364 27 DatagramSinkNet::set_target 0 1 127 804
// Filename: datagramSinkNet.I
// Created by:  drose (15Feb09)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::set_target
//       Access: Published
//  Description: Specifies the Connection that will receive all future
//               Datagrams sent.
////////////////////////////////////////////////////////////////////
64
inline void DatagramSinkNet::set_target(Connection *connection);

301 10 get_target 0 4 364 27 DatagramSinkNet::get_target 0 1 128 345
////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::get_target
//       Access: Published
//  Description: Returns the current target Connection, or NULL if the
//               target has not yet been set.  See set_target().
////////////////////////////////////////////////////////////////////
59
inline Connection *DatagramSinkNet::get_target(void) const;

302 12 put_datagram 0 6 364 29 DatagramSinkNet::put_datagram 0 1 129 445
// Inherited from DatagramSink

////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::put_datagram
//       Access: Published, Virtual
//  Description: Sends the given datagram to the target.  Returns true
//               on success, false if there is an error.  Blocks if
//               necessary until the target is ready.
////////////////////////////////////////////////////////////////////
65
virtual bool DatagramSinkNet::put_datagram(Datagram const &data);

303 8 is_error 0 6 364 25 DatagramSinkNet::is_error 0 1 130 379
// Inherited from DatagramSink

////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::is_error
//       Access: Published, Virtual
//  Description: Returns true if there is an error on the target
//               connection, or if the target has never been set.
////////////////////////////////////////////////////////////////////
45
virtual bool DatagramSinkNet::is_error(void);

304 5 flush 0 6 364 22 DatagramSinkNet::flush 0 1 131 321
////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::flush
//       Access: Public, Virtual
//  Description: Ensures that all datagrams previously written will be
//               visible on the stream.
////////////////////////////////////////////////////////////////////
42
virtual void DatagramSinkNet::flush(void);

305 16 ~DatagramSinkNet 0 4 364 33 DatagramSinkNet::~DatagramSinkNet 0 0 0
40
DatagramSinkNet::~DatagramSinkNet(void);

306 28 upcast_to_ConnectionListener 0 12 366 54 QueuedConnectionListener::upcast_to_ConnectionListener 0 1 140 58
upcast from QueuedConnectionListener to ConnectionListener
81
ConnectionListener *QueuedConnectionListener::upcast_to_ConnectionListener(void);

307 36 downcast_to_QueuedConnectionListener 0 12 355 56 ConnectionListener::downcast_to_QueuedConnectionListener 0 1 141 60
downcast from ConnectionListener to QueuedConnectionListener
89
QueuedConnectionListener *ConnectionListener::downcast_to_QueuedConnectionListener(void);

308 18 set_max_queue_size 0 4 367 58 QueuedReturn< ConnectionListenerData >::set_max_queue_size 0 1 144 0
80
void ::QueuedReturn< ConnectionListenerData >::set_max_queue_size(int max_size);

309 18 get_max_queue_size 0 4 367 58 QueuedReturn< ConnectionListenerData >::get_max_queue_size 0 1 145 0
77
int ::QueuedReturn< ConnectionListenerData >::get_max_queue_size(void) const;

310 22 get_current_queue_size 0 4 367 62 QueuedReturn< ConnectionListenerData >::get_current_queue_size 0 1 146 0
81
int ::QueuedReturn< ConnectionListenerData >::get_current_queue_size(void) const;

311 17 get_overflow_flag 0 4 367 57 QueuedReturn< ConnectionListenerData >::get_overflow_flag 0 1 147 0
77
bool ::QueuedReturn< ConnectionListenerData >::get_overflow_flag(void) const;

312 19 reset_overflow_flag 0 4 367 59 QueuedReturn< ConnectionListenerData >::reset_overflow_flag 0 1 148 0
73
void ::QueuedReturn< ConnectionListenerData >::reset_overflow_flag(void);

313 45 upcast_to_QueuedReturn_ConnectionListenerData 0 12 366 71 QueuedConnectionListener::upcast_to_QueuedReturn_ConnectionListenerData 0 1 142 78
upcast from QueuedConnectionListener to QueuedReturn< ConnectionListenerData >
118
QueuedReturn< ConnectionListenerData > *QueuedConnectionListener::upcast_to_QueuedReturn_ConnectionListenerData(void);

314 36 downcast_to_QueuedConnectionListener 0 12 367 76 QueuedReturn< ConnectionListenerData >::downcast_to_QueuedConnectionListener 0 1 143 80
downcast from QueuedReturn< ConnectionListenerData > to QueuedConnectionListener
111
QueuedConnectionListener *::QueuedReturn< ConnectionListenerData >::downcast_to_QueuedConnectionListener(void);

315 24 QueuedConnectionListener 0 4 366 50 QueuedConnectionListener::QueuedConnectionListener 0 1 136 233
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
96
QueuedConnectionListener::QueuedConnectionListener(ConnectionManager *manager, int num_threads);

316 25 ~QueuedConnectionListener 0 6 366 51 QueuedConnectionListener::~QueuedConnectionListener 0 0 241
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::Destructor
//       Access: Public, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
66
virtual QueuedConnectionListener::~QueuedConnectionListener(void);

317 24 new_connection_available 0 4 366 50 QueuedConnectionListener::new_connection_available 0 1 137 414
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::new_connection_available
//       Access: Public
//  Description: Returns true if a new connection was recently
//               established; the connection information may then be
//               retrieved via get_new_connection().
////////////////////////////////////////////////////////////////////
62
bool QueuedConnectionListener::new_connection_available(void);

318 18 get_new_connection 0 4 366 44 QueuedConnectionListener::get_new_connection 0 2 138 139 1651
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::get_new_connection
//       Access: Public
//  Description: If a previous call to new_connection_available()
//               returned true, this function will return information
//               about the newly established connection.
//
//               The rendezvous parameter is the particular rendezvous
//               socket this new connection originally communicated
//               with; it is provided in case the ConnectionListener
//               was monitorind more than one and you care which one
//               it was.  The address parameter is the net address of
//               the new client, and new_connection is the socket of
//               the newly established connection.
//
//               The return value is true if a connection was
//               successfully returned, or false if there was, in
//               fact, no new connection.  (This may happen if there
//               are multiple threads accessing the
//               QueuedConnectionListener).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::get_new_connection
//       Access: Public
//  Description: This flavor of get_new_connection() simply returns a
//               new connection, assuming the user doesn't care about
//               the rendezvous socket that originated it or the
//               address it came from.
////////////////////////////////////////////////////////////////////
241
bool QueuedConnectionListener::get_new_connection(PointerTo< Connection > &rendezvous, NetAddress &address, PointerTo< Connection > &new_connection);
bool QueuedConnectionListener::get_new_connection(PointerTo< Connection > &new_connection);

319 27 upcast_to_ConnectionManager 0 12 368 52 QueuedConnectionManager::upcast_to_ConnectionManager 0 1 152 56
upcast from QueuedConnectionManager to ConnectionManager
78
ConnectionManager *QueuedConnectionManager::upcast_to_ConnectionManager(void);

320 35 downcast_to_QueuedConnectionManager 0 12 358 54 ConnectionManager::downcast_to_QueuedConnectionManager 0 1 153 58
downcast from ConnectionManager to QueuedConnectionManager
86
QueuedConnectionManager *ConnectionManager::downcast_to_QueuedConnectionManager(void);

321 18 set_max_queue_size 0 4 369 59 QueuedReturn< PointerTo< Connection > >::set_max_queue_size 0 1 156 0
81
void ::QueuedReturn< PointerTo< Connection > >::set_max_queue_size(int max_size);

322 18 get_max_queue_size 0 4 369 59 QueuedReturn< PointerTo< Connection > >::get_max_queue_size 0 1 157 0
78
int ::QueuedReturn< PointerTo< Connection > >::get_max_queue_size(void) const;

323 22 get_current_queue_size 0 4 369 63 QueuedReturn< PointerTo< Connection > >::get_current_queue_size 0 1 158 0
82
int ::QueuedReturn< PointerTo< Connection > >::get_current_queue_size(void) const;

324 17 get_overflow_flag 0 4 369 58 QueuedReturn< PointerTo< Connection > >::get_overflow_flag 0 1 159 0
78
bool ::QueuedReturn< PointerTo< Connection > >::get_overflow_flag(void) const;

325 19 reset_overflow_flag 0 4 369 60 QueuedReturn< PointerTo< Connection > >::reset_overflow_flag 0 1 160 0
74
void ::QueuedReturn< PointerTo< Connection > >::reset_overflow_flag(void);

326 43 upcast_to_QueuedReturn_PointerTo_Connection 0 12 368 68 QueuedConnectionManager::upcast_to_QueuedReturn_PointerTo_Connection 0 1 154 78
upcast from QueuedConnectionManager to QueuedReturn< PointerTo< Connection > >
116
QueuedReturn< PointerTo< Connection > > *QueuedConnectionManager::upcast_to_QueuedReturn_PointerTo_Connection(void);

327 35 downcast_to_QueuedConnectionManager 0 12 369 76 QueuedReturn< PointerTo< Connection > >::downcast_to_QueuedConnectionManager 0 1 155 80
downcast from QueuedReturn< PointerTo< Connection > > to QueuedConnectionManager
110
QueuedConnectionManager *::QueuedReturn< PointerTo< Connection > >::downcast_to_QueuedConnectionManager(void);

328 23 QueuedConnectionManager 0 4 368 48 QueuedConnectionManager::QueuedConnectionManager 0 1 149 232
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
55
QueuedConnectionManager::QueuedConnectionManager(void);

329 24 ~QueuedConnectionManager 0 6 368 49 QueuedConnectionManager::~QueuedConnectionManager 0 0 240
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::Destructor
//       Access: Public, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
64
virtual QueuedConnectionManager::~QueuedConnectionManager(void);

330 26 reset_connection_available 0 4 368 51 QueuedConnectionManager::reset_connection_available 0 1 150 1031
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::reset_connection_available
//       Access: Public
//  Description: Returns true if one of the readers/writers/listeners
//               reported a connection reset recently.  If so, the
//               particular connection that has been reset can be
//               extracted via get_reset_connection().
//
//               Only connections which were externally reset are
//               certain to appear in this list.  Those which were
//               explicitly closed via a call to close_connection()
//               may or may not be reported.  Furthermore, it is the
//               responsibility of the caller to subsequently call
//               close_connection() with any connection reported reset
//               by this call.  (There is no harm in calling
//               close_connection() more than once on a given socket.)
////////////////////////////////////////////////////////////////////
69
bool QueuedConnectionManager::reset_connection_available(void) const;

331 20 get_reset_connection 0 4 368 45 QueuedConnectionManager::get_reset_connection 0 1 151 1253
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::get_reset_connection
//       Access: Public
//  Description: If a previous call to reset_connection_available()
//               returned true, this function will return information
//               about the newly reset connection.
//
//               Only connections which were externally reset are
//               certain to appear in this list.  Those which were
//               explicitly closed via a call to close_connection()
//               may or may not be reported.  Furthermore, it is the
//               responsibility of the caller to subsequently call
//               close_connection() with any connection reported reset
//               by this call.  (There is no harm in calling
//               close_connection() more than once on a given socket.)
//
//               The return value is true if a connection was
//               successfully returned, or false if there was, in
//               fact, no reset connection.  (This may happen if
//               there are multiple threads accessing the
//               QueuedConnectionManager).
////////////////////////////////////////////////////////////////////
88
bool QueuedConnectionManager::get_reset_connection(PointerTo< Connection > &connection);

332 26 upcast_to_ConnectionReader 0 12 370 50 QueuedConnectionReader::upcast_to_ConnectionReader 0 1 165 54
upcast from QueuedConnectionReader to ConnectionReader
75
ConnectionReader *QueuedConnectionReader::upcast_to_ConnectionReader(void);

333 34 downcast_to_QueuedConnectionReader 0 12 354 52 ConnectionReader::downcast_to_QueuedConnectionReader 0 1 166 56
downcast from ConnectionReader to QueuedConnectionReader
83
QueuedConnectionReader *ConnectionReader::downcast_to_QueuedConnectionReader(void);

334 18 set_max_queue_size 0 4 371 47 QueuedReturn< NetDatagram >::set_max_queue_size 0 1 169 0
69
void ::QueuedReturn< NetDatagram >::set_max_queue_size(int max_size);

335 18 get_max_queue_size 0 4 371 47 QueuedReturn< NetDatagram >::get_max_queue_size 0 1 170 0
66
int ::QueuedReturn< NetDatagram >::get_max_queue_size(void) const;

336 22 get_current_queue_size 0 4 371 51 QueuedReturn< NetDatagram >::get_current_queue_size 0 1 171 0
70
int ::QueuedReturn< NetDatagram >::get_current_queue_size(void) const;

337 17 get_overflow_flag 0 4 371 46 QueuedReturn< NetDatagram >::get_overflow_flag 0 1 172 0
66
bool ::QueuedReturn< NetDatagram >::get_overflow_flag(void) const;

338 19 reset_overflow_flag 0 4 371 48 QueuedReturn< NetDatagram >::reset_overflow_flag 0 1 173 0
62
void ::QueuedReturn< NetDatagram >::reset_overflow_flag(void);

339 34 upcast_to_QueuedReturn_NetDatagram 0 12 370 58 QueuedConnectionReader::upcast_to_QueuedReturn_NetDatagram 0 1 167 65
upcast from QueuedConnectionReader to QueuedReturn< NetDatagram >
94
QueuedReturn< NetDatagram > *QueuedConnectionReader::upcast_to_QueuedReturn_NetDatagram(void);

340 34 downcast_to_QueuedConnectionReader 0 12 371 63 QueuedReturn< NetDatagram >::downcast_to_QueuedConnectionReader 0 1 168 67
downcast from QueuedReturn< NetDatagram > to QueuedConnectionReader
96
QueuedConnectionReader *::QueuedReturn< NetDatagram >::downcast_to_QueuedConnectionReader(void);

341 22 QueuedConnectionReader 0 4 370 46 QueuedConnectionReader::QueuedConnectionReader 0 1 161 234
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
92
QueuedConnectionReader::QueuedConnectionReader(ConnectionManager *manager, int num_threads);

342 23 ~QueuedConnectionReader 0 6 370 47 QueuedConnectionReader::~QueuedConnectionReader 0 0 242
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
62
virtual QueuedConnectionReader::~QueuedConnectionReader(void);

343 14 data_available 0 4 370 38 QueuedConnectionReader::data_available 0 1 162 349
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::data_available
//       Access: Published
//  Description: Returns true if a datagram is available on the queue;
//               call get_data() to extract the datagram.
////////////////////////////////////////////////////////////////////
50
bool QueuedConnectionReader::data_available(void);

344 8 get_data 0 4 370 32 QueuedConnectionReader::get_data 0 2 163 164 1276
////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::get_data
//       Access: Published
//  Description: If a previous call to data_available() returned
//               true, this function will return the datagram that has
//               become available.
//
//               The return value is true if a datagram was
//               successfully returned, or false if there was, in
//               fact, no datagram available.  (This may happen if
//               there are multiple threads accessing the
//               QueuedConnectionReader).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::get_data
//       Access: Published
//  Description: This flavor of QueuedConnectionReader::get_data(),
//               works like the other, except that it only fills a
//               Datagram object, not a NetDatagram object.  This
//               means that the Datagram cannot be queried for its
//               source Connection and/or NetAddress, but it is useful
//               in all other respects.
////////////////////////////////////////////////////////////////////
116
bool QueuedConnectionReader::get_data(NetDatagram &result);
bool QueuedConnectionReader::get_data(Datagram &result);

345 22 RecentConnectionReader 0 4 372 46 RecentConnectionReader::RecentConnectionReader 0 1 174 231
////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
75
RecentConnectionReader::RecentConnectionReader(ConnectionManager *manager);

346 14 data_available 0 4 372 38 RecentConnectionReader::data_available 0 1 175 346
////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::data_available
//       Access: Public
//  Description: Returns true if a datagram is available on the queue;
//               call get_data() to extract the datagram.
////////////////////////////////////////////////////////////////////
50
bool RecentConnectionReader::data_available(void);

347 8 get_data 0 4 372 32 RecentConnectionReader::get_data 0 2 176 177 1270
////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::get_data
//       Access: Public
//  Description: If a previous call to data_available() returned
//               true, this function will return the datagram that has
//               become available.
//
//               The return value is true if a datagram was
//               successfully returned, or false if there was, in
//               fact, no datagram available.  (This may happen if
//               there are multiple threads accessing the
//               RecentConnectionReader).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::get_data
//       Access: Public
//  Description: This flavor of RecentConnectionReader::get_data(),
//               works like the other, except that it only fills a
//               Datagram object, not a NetDatagram object.  This
//               means that the Datagram cannot be queried for its
//               source Connection and/or NetAddress, but it is useful
//               in all other respects.
////////////////////////////////////////////////////////////////////
116
bool RecentConnectionReader::get_data(NetDatagram &result);
bool RecentConnectionReader::get_data(Datagram &result);

177
1 14 Dtool_7xrjJLs6 0 7 6 374 181 14 Dtool_7xrjJLs6 0 1 3 ptr 1 373  
2 14 Dtool_7xrj_abX 0 7 6 374 181 14 Dtool_7xrj_abX 0 0 
3 14 Dtool_7xrjZI1Q 0 7 6 374 181 14 Dtool_7xrjZI1Q 0 1 4 copy 1 373  
4 14 Dtool_7xrjHt8x 0 7 8 373 0 14 Dtool_7xrjHt8x 663 // When downcasting to a derived class from a PointerTo<BaseClass>,
// C++ would normally require you to cast twice: once to an actual
// BaseClass pointer, and then again to your desired pointer.  You
// can use the handy function p() to avoid this first cast and make
// your code look a bit cleaner.
// e.g. instead of (MyType *)(BaseClass *)ptr, use (MyType *)ptr.p()
// If your base class is a derivative of TypedObject, you might want
// to use the DCAST macro defined in typedObject.h instead,
// e.g. DCAST(MyType, ptr).  This provides a clean downcast that
// doesn't require .p() or any double-casting, and it can be
// run-time checked for correctness. 1 4 this 3 375  
5 14 Dtool_7xrjKFDQ 0 6 9 374 0 14 Dtool_7xrjKFDQ 0 2 4 this 3 374  3 ptr 1 373  
6 14 Dtool_7xrjvpYV 0 6 9 374 0 14 Dtool_7xrjvpYV 0 2 4 this 3 374  4 copy 1 373  
7 14 Dtool_7xrjiZMY 0 6 10 377 0 14 Dtool_7xrjiZMY 259 // These functions normally wouldn't need to be redefined here, but
// we do so anyway just to help out interrogate (which doesn't seem
// to want to automatically export the PointerToBase class).  When
// this works again in interrogate, we can remove these. 1 4 this 3 375  
8 14 Dtool_7xrjY1xp 0 4 11 378 0 14 Dtool_7xrjY1xp 259 // These functions normally wouldn't need to be redefined here, but
// we do so anyway just to help out interrogate (which doesn't seem
// to want to automatically export the PointerToBase class).  When
// this works again in interrogate, we can remove these. 1 4 this 3 374  
9 14 Dtool_7xrjXxN0 0 4 4 378 0 14 Dtool_7xrjXxN0 0 1 4 this 3 379  
10 14 Dtool_7xrjqs2I 0 4 5 378 0 14 Dtool_7xrjqs2I 0 2 4 this 3 380  3 out 1 382  
11 14 Dtool_7xrj_XOH 0 7 13 384 199 14 Dtool_7xrj_XOH 254 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::Constructor
//       Access: Public
//  Description: Constructs an unspecified address.
//////////////////////////////////////////////////////////////////// 0 
12 14 Dtool_7xrjAM4t 0 7 13 384 199 14 Dtool_7xrjAM4t 477 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::Constructor
//       Access: Public
//  Description: Constructs an address from a given Socket_Address.
//               Normally, this constructor should not be used by user
//               code; instead, create a default NetAddress and use
//               one of the set_*() functions to set up an address.
//////////////////////////////////////////////////////////////////// 1 4 addr 1 385  
13 14 Dtool_7xrjDqM_ 0 6 14 377 0 14 Dtool_7xrjDqM_ 429 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_any
//       Access: Public
//  Description: Sets the address up to refer to a particular port,
//               but not to any particular IP.  Returns true if
//               successful, false otherwise (currently, this only
//               returns true).
//////////////////////////////////////////////////////////////////// 2 4 this 3 384  4 port 1 388  
14 14 Dtool_7xrjPoxe 0 6 15 377 0 14 Dtool_7xrjPoxe 303 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_localhost
//       Access: Public
//  Description: Sets the address up to refer to a particular port,
//               on this host.
//////////////////////////////////////////////////////////////////// 2 4 this 3 384  4 port 1 388  
15 14 Dtool_7xrjaUON 0 6 16 377 0 14 Dtool_7xrjaUON 264 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_broadcast
//       Access: Public
//  Description: Sets the address to the broadcast address.
//////////////////////////////////////////////////////////////////// 2 4 this 3 384  4 port 1 388  
16 14 Dtool_7xrjhU_T 0 6 17 377 0 14 Dtool_7xrjhU_T 379 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_host
//       Access: Public
//  Description: Sets the address up to refer to a particular port
//               on a particular host.  Returns true if the hostname
//               is known, false otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 384  8 hostname 1 389  4 port 1 388  
17 14 Dtool_7xrjCfpu 0 4 18 378 0 14 Dtool_7xrjCfpu 257 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::clear
//       Access: Public
//  Description: Resets the NetAddress to its initial state.
//////////////////////////////////////////////////////////////////// 1 4 this 3 384  
18 14 Dtool_7xrjhHNt 0 6 19 388 0 14 Dtool_7xrjhHNt 270 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_port
//       Access: Public
//  Description: Returns the port number to which this address refers.
//////////////////////////////////////////////////////////////////// 1 4 this 3 390  
19 14 Dtool_7xrjzG63 0 4 20 378 0 14 Dtool_7xrjzG63 296 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::set_port
//       Access: Public
//  Description: Resets the port number without otherwise changing the
//               address.
//////////////////////////////////////////////////////////////////// 2 4 this 3 384  4 port 1 388  
20 14 Dtool_7xrjM3mv 0 6 21 389 0 14 Dtool_7xrjM3mv 314 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip_string
//       Access: Public
//  Description: Returns the IP address to which this address refers,
//               formatted as a string.
//////////////////////////////////////////////////////////////////// 1 4 this 3 390  
21 14 Dtool_7xrjAxhR 0 6 22 392 0 14 Dtool_7xrjAxhR 325 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip
//       Access: Public
//  Description: Returns the IP address to which this address refers,
//               as a 32-bit integer, in host byte order.
//////////////////////////////////////////////////////////////////// 1 4 this 3 390  
22 14 Dtool_7xrjD_kR 0 6 23 393 0 14 Dtool_7xrjD_kR 471 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_ip_component
//       Access: Public
//  Description: Returns the nth 8-bit component of the IP address.
//               An IP address has four components; component 0 is the
//               first (leftmost), and component 3 is the last
//               (rightmost) in the dotted number convention.
//////////////////////////////////////////////////////////////////// 2 4 this 3 390  1 n 1 388  
23 14 Dtool_7xrjJjjL 0 6 24 385 0 14 Dtool_7xrjJjjL 261 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::get_addr
//       Access: Public
//  Description: Returns the Socket_Address for this address.
//////////////////////////////////////////////////////////////////// 1 4 this 3 390  
24 14 Dtool_7xrjBvAY 0 4 25 378 0 14 Dtool_7xrjBvAY 214 ////////////////////////////////////////////////////////////////////
//     Function: NetAddress::output
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 390  3 out 1 382  
25 14 Dtool_7xrjjl20 0 7 29 373 0 14 Dtool_7xrjjl20 434 ////////////////////////////////////////////////////////////////////
//     Function: Connection::Constructor
//       Access: Published
//  Description: Creates a connection.  Normally this constructor
//               should not be used directly by user code; use one of
//               the methods in ConnectionManager to make a new
//               connection.
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  6 socket 1 395  
26 14 Dtool_7xrjF__C 0 7 30 384 199 14 Dtool_7xrjF__C 312 ////////////////////////////////////////////////////////////////////
//     Function: Connection::get_address
//       Access: Published
//  Description: Returns the address bound to this connection, if it
//               is a TCP connection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 397  
27 14 Dtool_7xrj2GOO 0 6 31 394 0 14 Dtool_7xrj2GOO 318 ////////////////////////////////////////////////////////////////////
//     Function: Connection::get_manager
//       Access: Published
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this connection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 397  
28 14 Dtool_7xrj8tyZ 0 6 32 395 0 14 Dtool_7xrj8tyZ 298 ////////////////////////////////////////////////////////////////////
//     Function: Connection::get_socket
//       Access: Published
//  Description: Returns the internal Socket_IP that defines the
//               connection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 397  
29 14 Dtool_7xrjKoGo 0 4 33 378 0 14 Dtool_7xrjKoGo 1146 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_collect_tcp
//       Access: Published
//  Description: Enables or disables "collect-tcp" mode.  In this
//               mode, individual TCP packets are not sent
//               immediately, but rather they are collected together
//               and accumulated to be sent periodically as one larger
//               TCP packet.  This cuts down on overhead from the
//               TCP/IP protocol, especially if many small packets
//               need to be sent on the same connection, but it
//               introduces additional latency (since packets must be
//               held before they can be sent).
//
//               See set_collect_tcp_interval() to specify the
//               interval of time for which to hold packets before
//               sending them.
//
//               If you enable this mode, you may also need to
//               periodically call consider_flush() to flush the queue
//               if no packets have been sent recently.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  11 collect_tcp 1 377  
30 14 Dtool_7xrjTIEw 0 6 34 377 0 14 Dtool_7xrjTIEw 317 ////////////////////////////////////////////////////////////////////
//     Function: Connection::get_collect_tcp
//       Access: Published
//  Description: Returns the current setting of "collect-tcp" mode.
//               See set_collect_tcp().
//////////////////////////////////////////////////////////////////// 1 4 this 3 397  
31 14 Dtool_7xrjm8H_ 0 4 35 378 0 14 Dtool_7xrjm8H_ 518 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_collect_tcp_interval
//       Access: Published
//  Description: Specifies the interval in time, in seconds, for which
//               to hold TCP packets before sending all of the
//               recently received packets at once.  This only has
//               meaning if "collect-tcp" mode is enabled; see
//               set_collect_tcp().
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  8 interval 1 399  
32 14 Dtool_7xrjpu1t 0 6 36 399 0 14 Dtool_7xrjpu1t 516 ////////////////////////////////////////////////////////////////////
//     Function: Connection::get_collect_tcp_interval
//       Access: Published
//  Description: Returns the interval in time, in seconds, for which
//               to hold TCP packets before sending all of the
//               recently received packets at once.  This only has
//               meaning if "collect-tcp" mode is enabled; see
//               set_collect_tcp().
//////////////////////////////////////////////////////////////////// 1 4 this 3 397  
33 14 Dtool_7xrjyeve 0 6 37 377 0 14 Dtool_7xrjyeve 400 ////////////////////////////////////////////////////////////////////
//     Function: Connection::consider_flush
//       Access: Published
//  Description: Sends the most recently queued TCP datagram(s) if
//               enough time has elapsed.  This only has meaning if
//               set_collect_tcp() has been set to true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 373  
34 14 Dtool_7xrjQdru 0 6 38 377 0 14 Dtool_7xrjQdru 367 ////////////////////////////////////////////////////////////////////
//     Function: Connection::flush
//       Access: Published
//  Description: Sends the most recently queued TCP datagram(s) now.
//               This only has meaning if set_collect_tcp() has been
//               set to true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 373  
35 14 Dtool_7xrjyOTH 0 4 39 378 0 14 Dtool_7xrjyOTH 731 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_linger
//       Access: Published
//  Description: Sets the time to linger on close if data is present.
//               If flag is false, when you close a socket with data
//               available the system attempts to deliver the data to
//               the peer (the default behavior).  If flag is false
//               but time is zero, the system discards any undelivered
//               data when you close the socket.  If flag is false but
//               time is nonzero, the system waits up to time seconds
//               to deliver the data.
//////////////////////////////////////////////////////////////////// 3 4 this 3 373  4 flag 1 377  4 time 1 399  
36 14 Dtool_7xrj87ZK 0 4 40 378 0 14 Dtool_7xrj87ZK 270 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_reuse_addr
//       Access: Published
//  Description: Sets whether local address reuse is allowed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 flag 1 377  
37 14 Dtool_7xrjbmIV 0 4 41 378 0 14 Dtool_7xrjbmIV 322 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_keep_alive
//       Access: Published
//  Description: Sets whether the connection is periodically tested to
//               see if it is still alive.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 flag 1 377  
38 14 Dtool_7xrj_Glj 0 4 42 378 0 14 Dtool_7xrj_Glj 278 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_recv_buffer_size
//       Access: Published
//  Description: Sets the size of the receive buffer, in bytes.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 size 1 388  
39 14 Dtool_7xrjTxS1 0 4 43 378 0 14 Dtool_7xrjTxS1 275 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_send_buffer_size
//       Access: Published
//  Description: Sets the size of the send buffer, in bytes.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 size 1 388  
40 14 Dtool_7xrjQkWX 0 4 44 378 0 14 Dtool_7xrjQkWX 252 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_ip_time_to_live
//       Access: Published
//  Description: Sets IP time-to-live.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  3 ttl 1 388  
41 14 Dtool_7xrjCpUD 0 4 45 378 0 14 Dtool_7xrjCpUD 273 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_ip_type_of_service
//       Access: Published
//  Description: Sets IP type-of-service and precedence.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  3 tos 1 388  
42 14 Dtool_7xrjc5D7 0 4 46 378 0 14 Dtool_7xrjc5D7 343 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_no_delay
//       Access: Published
//  Description: If flag is true, this disables the Nagle algorithm,
//               and prevents delaying of send to coalesce packets.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 flag 1 377  
43 14 Dtool_7xrjdSC_ 0 4 47 378 0 14 Dtool_7xrjdSC_ 257 ////////////////////////////////////////////////////////////////////
//     Function: Connection::set_max_segment
//       Access: Published
//  Description: Sets the maximum segment size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 373  4 size 1 388  
44 14 Dtool_7xrjFjVV 0 6 50 377 0 14 Dtool_7xrjFjVV 875 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::add_connection
//       Access: Published
//  Description: Adds a new socket to the list of sockets the
//               ConnectionReader will monitor.  A datagram that comes
//               in on any of the monitored sockets will be reported.
//               In the case of a ConnectionListener, this adds a new
//               rendezvous socket; any activity on any of the
//               monitored sockets will cause a connection to be
//               accepted.
//
//               The return value is true if the connection was added,
//               false if it was already there.
//
//               add_connection() is thread-safe, and may be called at
//               will by any thread.
//////////////////////////////////////////////////////////////////// 2 4 this 3 400  10 connection 1 373  
45 14 Dtool_7xrjwDcJ 0 6 51 377 0 14 Dtool_7xrjwDcJ 561 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::remove_connection
//       Access: Published
//  Description: Removes a socket from the list of sockets being
//               monitored.  Returns true if the socket was correctly
//               removed, false if it was not on the list in the first
//               place.
//
//               remove_connection() is thread-safe, and may be called
//               at will by any thread.
//////////////////////////////////////////////////////////////////// 2 4 this 3 400  10 connection 1 373  
46 14 Dtool_7xrjJc6R 0 6 52 377 0 14 Dtool_7xrjJc6R 658 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::is_connection_ok
//       Access: Published
//  Description: Returns true if the indicated connection has been
//               added to the ConnectionReader and is being monitored
//               properly, false if it is not known, or if there was
//               some error condition detected on the connection.  (If
//               there was an error condition, normally the
//               ConnectionManager would have been informed and closed
//               the connection.)
//////////////////////////////////////////////////////////////////// 2 4 this 3 400  10 connection 1 373  
47 14 Dtool_7xrjWxFz 0 4 53 378 0 14 Dtool_7xrjWxFz 628 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::poll
//       Access: Published
//  Description: Explicitly polls the available sockets to see if any
//               of them have any noise.  This function does nothing
//               unless this is a polling-type ConnectionReader,
//               i.e. it was created with zero threads (and
//               is_polling() will return true).
//
//               It is not necessary to call this explicitly for a
//               QueuedConnectionReader.
//////////////////////////////////////////////////////////////////// 1 4 this 3 400  
48 14 Dtool_7xrjivcH 0 6 54 394 0 14 Dtool_7xrjivcH 330 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_manager
//       Access: Published
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this ConnectionReader.
//////////////////////////////////////////////////////////////////// 1 4 this 3 401  
49 14 Dtool_7xrjLEEA 0 6 55 377 0 14 Dtool_7xrjLEEA 808 // Filename: connectionReader.I
// Created by:  drose (15Feb09)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::is_polling
//       Access: Published
//  Description: Returns true if the reader is a polling reader,
//               i.e. it has no threads.
//////////////////////////////////////////////////////////////////// 1 4 this 3 401  
50 14 Dtool_7xrj2jeO 0 6 56 388 0 14 Dtool_7xrj2jeO 323 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_num_threads
//       Access: Published
//  Description: Returns the number of threads the ConnectionReader
//               has been created with.
//////////////////////////////////////////////////////////////////// 1 4 this 3 401  
51 14 Dtool_7xrj7duY 0 4 57 378 0 14 Dtool_7xrj7duY 606 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::set_raw_mode
//       Access: Published
//  Description: Sets the ConnectionReader into raw mode (or turns off
//               raw mode).  In raw mode, datagram headers are not
//               expected; instead, all the data available on the pipe
//               is treated as a single datagram.
//
//               This is similar to set_tcp_header_size(0), except that it
//               also turns off headers for UDP packets.
//////////////////////////////////////////////////////////////////// 2 4 this 3 400  4 mode 1 377  
52 14 Dtool_7xrjCWld 0 6 58 377 0 14 Dtool_7xrjCWld 316 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_raw_mode
//       Access: Published
//  Description: Returns the current setting of the raw mode flag.
//               See set_raw_mode().
//////////////////////////////////////////////////////////////////// 1 4 this 3 401  
53 14 Dtool_7xrjWNcl 0 4 59 378 0 14 Dtool_7xrjWNcl 555 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::set_tcp_header_size
//       Access: Published
//  Description: Sets the header size of TCP packets.  At the present,
//               legal values for this are 0, 2, or 4; this specifies
//               the number of bytes to use encode the datagram length
//               at the start of each TCP datagram.  Sender and
//               receiver must independently agree on this.
//////////////////////////////////////////////////////////////////// 2 4 this 3 400  15 tcp_header_size 1 388  
54 14 Dtool_7xrj9iEw 0 6 60 388 0 14 Dtool_7xrj9iEw 328 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::get_tcp_header_size
//       Access: Published
//  Description: Returns the current setting of TCP header size.
//               See set_tcp_header_size().
//////////////////////////////////////////////////////////////////// 1 4 this 3 401  
55 14 Dtool_7xrjE0it 0 4 61 378 0 14 Dtool_7xrjE0it 392 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionReader::shutdown
//       Access: Published
//  Description: Terminates all threads cleanly.  Normally this is
//               only called by the destructor, but it may be called
//               explicitly before destruction.
//////////////////////////////////////////////////////////////////// 1 4 this 3 400  
56 14 Dtool_7xrjFlXx 0 7 66 403 240 14 Dtool_7xrjFlXx 250 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Constructor
//       Access: Public
//  Description: Constructs an empty datagram.
//////////////////////////////////////////////////////////////////// 0 
57 14 Dtool_7xrjrT0b 0 7 66 403 240 14 Dtool_7xrjrT0b 225 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 404  
58 14 Dtool_7xrjVk0H 0 7 66 403 240 14 Dtool_7xrjVk0H 225 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 406  
59 14 Dtool_7xrjVtlI 0 6 67 403 0 14 Dtool_7xrjVtlI 233 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Assignment Operator
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 403  4 copy 1 404  
60 14 Dtool_7xrjlg9z 0 6 67 403 0 14 Dtool_7xrjlg9z 233 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::Copy Assignment Operator
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 403  4 copy 1 406  
61 14 Dtool_7xrj_JK9 0 4 68 378 0 14 Dtool_7xrj_JK9 302 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_connection
//       Access: Public
//  Description: Specifies the socket to which the datagram should be
//               written.
//////////////////////////////////////////////////////////////////// 2 4 this 3 403  10 connection 1 373  
62 14 Dtool_7xrjYxCi 0 7 69 373 0 14 Dtool_7xrjYxCi 338 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_connection
//       Access: Public
//  Description: Retrieves the socket from which the datagram was
//               read, or to which it is scheduled to be written.
//////////////////////////////////////////////////////////////////// 1 4 this 3 406  
63 14 Dtool_7xrjeaZL 0 4 70 378 0 14 Dtool_7xrjeaZL 294 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_address
//       Access: Public
//  Description: Specifies the host to which the datagram should be
//               sent.
//////////////////////////////////////////////////////////////////// 2 4 this 3 403  7 address 1 390  
64 14 Dtool_7xrjDIhL 0 6 71 390 0 14 Dtool_7xrjDIhL 330 ////////////////////////////////////////////////////////////////////
//     Function: NetDatagram::set_address
//       Access: Public
//  Description: Retrieves the host from which the datagram was
//               read, or to which it is scheduled to be sent.
//////////////////////////////////////////////////////////////////// 1 4 this 3 406  
65 14 Dtool_7xrjss1L 0 7 72 409 0 14 Dtool_7xrjss1L 0 0 
66 14 Dtool_7xrjf_YP 0 7 75 394 242 14 Dtool_7xrjf_YP 229 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
67 14 Dtool_7xrj4li3 0 7 77 373 0 14 Dtool_7xrj4li3 1115 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               This variant accepts both a hostname and port to
//               listen on a particular interface; if the hostname is
//               empty, all interfaces will be available.
//
//               If for_broadcast is true, this UDP connection will be
//               configured to send and/or receive messages on the
//               broadcast address (255.255.255.255); otherwise, these
//               messages may be automatically filtered by the OS.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
//////////////////////////////////////////////////////////////////// 4 4 this 3 394  8 hostname 1 389  4 port 1 388  13 for_broadcast 1 377  
68 14 Dtool_7xrjdWiI 0 7 77 373 0 14 Dtool_7xrjdWiI 1115 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               This variant accepts both a hostname and port to
//               listen on a particular interface; if the hostname is
//               empty, all interfaces will be available.
//
//               If for_broadcast is true, this UDP connection will be
//               configured to send and/or receive messages on the
//               broadcast address (255.255.255.255); otherwise, these
//               messages may be automatically filtered by the OS.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
//////////////////////////////////////////////////////////////////// 3 4 this 3 394  8 hostname 1 389  4 port 1 388  
69 14 Dtool_7xrjuiqs 0 7 77 373 0 14 Dtool_7xrjuiqs 639 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
//////////////////////////////////////////////////////////////////// 2 4 this 3 394  4 port 1 388  
70 14 Dtool_7xrjNLgh 0 7 77 373 0 14 Dtool_7xrjNLgh 639 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_UDP_connection
//       Access: Published
//  Description: Opens a socket for sending and/or receiving UDP
//               packets.  If the port number is greater than zero,
//               the UDP connection will be opened for listening on
//               the indicated port; otherwise, it will be useful only
//               for sending.
//
//               Use a ConnectionReader and ConnectionWriter to handle
//               the actual communication.
//////////////////////////////////////////////////////////////////// 1 4 this 3 394  
71 14 Dtool_7xrjqscj 0 7 78 373 0 14 Dtool_7xrjqscj 794 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a NetAddress,
//               which allows you to specify a specific interface to
//               listen to.
//
//               backlog is the maximum length of the queue of pending
//               connections.
//////////////////////////////////////////////////////////////////// 3 4 this 3 394  7 address 1 390  7 backlog 1 388  
72 14 Dtool_7xrj__6a 0 7 78 373 0 14 Dtool_7xrj__6a 989 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a "hostname",
//               which is usually just an IP address in dotted
//               notation, and a port number.  It will listen on the
//               interface indicated by the IP address.  If the IP
//               address is empty string, it will listen on all
//               interfaces.
//
//               backlog is the maximum length of the queue of pending
//               connections.
//////////////////////////////////////////////////////////////////// 4 4 this 3 394  8 hostname 1 389  4 port 1 388  7 backlog 1 388  
73 14 Dtool_7xrjgDIi 0 7 78 373 0 14 Dtool_7xrjgDIi 790 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_server_rendezvous
//       Access: Published
//  Description: Creates a socket to be used as a rendezvous socket
//               for a server to listen for TCP connections.  The
//               socket returned by this call should only be added to
//               a ConnectionListener (not to a generic
//               ConnectionReader).
//
//               This variant of this method accepts a single port,
//               and will listen to that port on all available
//               interfaces.
//
//               backlog is the maximum length of the queue of pending
//               connections.
//////////////////////////////////////////////////////////////////// 3 4 this 3 394  4 port 1 388  7 backlog 1 388  
74 14 Dtool_7xrjDKvU 0 7 79 373 0 14 Dtool_7xrjDKvU 480 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_client_connection
//       Access: Published
//  Description: Attempts to establish a TCP client connection to a
//               server at the indicated address.  If the connection
//               is not established within timeout_ms milliseconds, a
//               null connection is returned.
//////////////////////////////////////////////////////////////////// 3 4 this 3 394  7 address 1 390  10 timeout_ms 1 388  
75 14 Dtool_7xrjnsPM 0 7 79 373 0 14 Dtool_7xrjnsPM 385 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::open_TCP_client_connection
//       Access: Published
//  Description: This is a shorthand version of the function to
//               directly establish communications to a named host and
//               port.
//////////////////////////////////////////////////////////////////// 4 4 this 3 394  8 hostname 1 389  4 port 1 388  10 timeout_ms 1 388  
76 14 Dtool_7xrjigqc 0 6 80 377 0 14 Dtool_7xrjigqc 1093 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::close_connection
//       Access: Published
//  Description: Terminates a UDP or TCP socket previously opened.
//               This also removes it from any associated
//               ConnectionReader or ConnectionListeners.
//
//               The socket itself may not be immediately closed--it
//               will not be closed until all outstanding pointers to
//               it are cleared, including any pointers remaining in
//               NetDatagrams recently received from the socket.
//
//               The return value is true if the connection was marked
//               to be closed, or false if close_connection() had
//               already been called (or the connection did not belong
//               to this ConnectionManager).  In neither case can you
//               infer anything about whether the connection has
//               *actually* been closed yet based on the return value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 394  10 connection 1 373  
77 14 Dtool_7xrjiTZx 0 6 81 377 0 14 Dtool_7xrjiTZx 1081 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::wait_for_readers
//       Access: Published
//  Description: Blocks the process for timeout number of seconds, or
//               until any data is available on any of the
//               non-threaded ConnectionReaders or
//               ConnectionListeners, whichever comes first.  The
//               return value is true if there is data available (but
//               you have to iterate through all readers to find it),
//               or false if the timeout occurred without any data.
//
//               If the timeout value is negative, this will block
//               forever or until data is available.
//
//               This only works if all ConnectionReaders and
//               ConnectionListeners are non-threaded.  If any
//               threaded ConnectionReaders are part of the
//               ConnectionManager, the timeout value is implicitly
//               treated as 0.
//////////////////////////////////////////////////////////////////// 2 4 this 3 394  7 timeout 1 399  
78 14 Dtool_7xrjCjTl 0 6 82 389 0 14 Dtool_7xrjCjTl 405 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_host_name
//       Access: Published, Static
//  Description: Returns the name of this particular machine on the
//               network, if available, or the empty string if the
//               hostname cannot be determined.
//////////////////////////////////////////////////////////////////// 0 
79 14 Dtool_7xrjfIaT 0 4 96 378 0 14 Dtool_7xrjfIaT 540 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::scan_interfaces
//       Access: Published
//  Description: Repopulates the list reported by
//               get_num_interface()/get_interface().  It is not
//               necessary to call this explicitly, unless you want to
//               re-determine the connected interfaces (for instance,
//               if you suspect the hardware has recently changed).
//////////////////////////////////////////////////////////////////// 1 4 this 3 394  
80 14 Dtool_7xrjX_l0 0 6 97 388 0 14 Dtool_7xrjX_l0 463 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_num_interfaces
//       Access: Published
//  Description: This returns the number of usable network interfaces
//               detected on this machine.  (Currently, only IPv4
//               interfaces are reported.)  See scan_interfaces() to
//               repopulate this list.
//////////////////////////////////////////////////////////////////// 1 4 this 3 394  
81 14 Dtool_7xrjMmlp 0 6 98 410 0 14 Dtool_7xrjMmlp 446 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::get_interface
//       Access: Published
//  Description: Returns the nth usable network interface detected on
//               this machine.  (Currently, only IPv4 interfaces are
//               reported.)  See scan_interfaces() to repopulate this
//               list.
//////////////////////////////////////////////////////////////////// 2 4 this 3 394  1 n 1 388  
82 14 Dtool_7xrjj5Zv 0 6 84 389 0 14 Dtool_7xrjj5Zv 0 1 4 this 3 410  
83 14 Dtool_7xrjBqFG 0 6 85 389 0 14 Dtool_7xrjBqFG 0 1 4 this 3 410  
84 14 Dtool_7xrjCamE 0 6 86 377 0 14 Dtool_7xrjCamE 0 1 4 this 3 410  
85 14 Dtool_7xrjoeWB 0 6 87 390 0 14 Dtool_7xrjoeWB 0 1 4 this 3 410  
86 14 Dtool_7xrjMx5P 0 6 88 377 0 14 Dtool_7xrjMx5P 0 1 4 this 3 410  
87 14 Dtool_7xrjyupM 0 6 89 390 0 14 Dtool_7xrjyupM 0 1 4 this 3 410  
88 14 Dtool_7xrjq41R 0 6 90 377 0 14 Dtool_7xrjq41R 0 1 4 this 3 410  
89 14 Dtool_7xrjwHkO 0 6 91 390 0 14 Dtool_7xrjwHkO 0 1 4 this 3 410  
90 14 Dtool_7xrjfMAK 0 6 92 377 0 14 Dtool_7xrjfMAK 0 1 4 this 3 410  
91 14 Dtool_7xrjFTwG 0 6 93 390 0 14 Dtool_7xrjFTwG 0 1 4 this 3 410  
92 14 Dtool_7xrjlpaO 0 4 94 378 0 14 Dtool_7xrjlpaO 236 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionManager::Interface::Output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 410  3 out 1 382  
93 14 Dtool_7xrjw48M 0 7 100 412 265 14 Dtool_7xrjw48M 498 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::Constructor
//       Access: Public
//  Description: Creates a new ConnectionWriter with the indicated
//               number of threads to handle output.
//
//               If num_threads is 0, all datagrams will be sent
//               immediately instead of queueing for later
//               transmission by a thread.
//////////////////////////////////////////////////////////////////// 3 7 manager 1 394  11 num_threads 1 388  11 thread_name 1 389  
94 14 Dtool_7xrjwv9q 0 7 100 412 265 14 Dtool_7xrjwv9q 498 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::Constructor
//       Access: Public
//  Description: Creates a new ConnectionWriter with the indicated
//               number of threads to handle output.
//
//               If num_threads is 0, all datagrams will be sent
//               immediately instead of queueing for later
//               transmission by a thread.
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  11 num_threads 1 388  
95 14 Dtool_7xrjBBlV 0 4 102 378 0 14 Dtool_7xrjBBlV 460 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_max_queue_size
//       Access: Public
//  Description: Limits the number of packets that may be pending on
//               the outbound queue.  This only has an effect when
//               using threads; if num_threads is 0, then all packets
//               are sent immediately.
//////////////////////////////////////////////////////////////////// 2 4 this 3 412  8 max_size 1 388  
96 14 Dtool_7xrjQHha 0 6 103 388 0 14 Dtool_7xrjQHha 334 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_max_queue_size
//       Access: Public
//  Description: Returns the maximum size the queue is allowed to grow
//               to.  See set_max_queue_size().
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
97 14 Dtool_7xrjchwb 0 6 104 388 0 14 Dtool_7xrjchwb 287 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_current_queue_size
//       Access: Public
//  Description: Returns the current number of things in the queue.
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
98 14 Dtool_7xrj0RY7 0 6 105 377 0 14 Dtool_7xrj0RY7 1005 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  This form of the function allows the
//               specification of a destination host address, and so
//               is appropriate for UDP packets.  Use the other send()
//               method for sending TCP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
//////////////////////////////////////////////////////////////////// 5 4 this 3 412  8 datagram 1 404  10 connection 1 373  7 address 1 390  5 block 1 377  
99 14 Dtool_7xrj5Lcw 0 6 105 377 0 14 Dtool_7xrj5Lcw 1005 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  This form of the function allows the
//               specification of a destination host address, and so
//               is appropriate for UDP packets.  Use the other send()
//               method for sending TCP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
//////////////////////////////////////////////////////////////////// 4 4 this 3 412  8 datagram 1 404  10 connection 1 373  7 address 1 390  
100 14 Dtool_7xrjjvjZ 0 6 105 377 0 14 Dtool_7xrjjvjZ 999 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  Since the host address is not specified with
//               this form, this function should only be used for
//               sending TCP packets.  Use the other send() method for
//               sending UDP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
//////////////////////////////////////////////////////////////////// 4 4 this 3 412  8 datagram 1 404  10 connection 1 373  5 block 1 377  
101 14 Dtool_7xrj5_fV 0 6 105 377 0 14 Dtool_7xrj5_fV 999 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::send
//       Access: Public
//  Description: Enqueues a datagram for transmittal on the indicated
//               socket.  Since the host address is not specified with
//               this form, this function should only be used for
//               sending TCP packets.  Use the other send() method for
//               sending UDP packets.
//
//               Returns true if successful, false if there was an
//               error.  In the normal, threaded case, this function
//               only returns false if the send queue is filled; it's
//               impossible to detect a transmission error at this
//               point.
//
//               If block is true, this will not return false if the
//               send queue is filled; instead, it will wait until
//               there is space available.
//////////////////////////////////////////////////////////////////// 3 4 this 3 412  8 datagram 1 404  10 connection 1 373  
102 14 Dtool_7xrj1sIn 0 6 106 377 0 14 Dtool_7xrj1sIn 339 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::is_valid_for_udp
//       Access: Public
//  Description: Returns true if the datagram is small enough to be
//               sent over a UDP packet, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 413  8 datagram 1 404  
103 14 Dtool_7xrjTVbQ 0 6 107 394 0 14 Dtool_7xrjTVbQ 327 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_manager
//       Access: Public
//  Description: Returns a pointer to the ConnectionManager object
//               that serves this ConnectionWriter.
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
104 14 Dtool_7xrjK_Gm 0 6 108 377 0 14 Dtool_7xrjK_Gm 318 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::is_immediate
//       Access: Public
//  Description: Returns true if the writer is an immediate writer,
//               i.e. it has no threads.
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
105 14 Dtool_7xrjm3eX 0 6 109 388 0 14 Dtool_7xrjm3eX 320 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_num_threads
//       Access: Public
//  Description: Returns the number of threads the ConnectionWriter
//               has been created with.
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
106 14 Dtool_7xrj4nth 0 4 110 378 0 14 Dtool_7xrj4nth 789 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_raw_mode
//       Access: Public
//  Description: Sets the ConnectionWriter into raw mode (or turns off
//               raw mode).  In raw mode, datagrams are not sent along
//               with their headers; the bytes in the datagram are
//               simply sent down the pipe.
//
//               Setting the ConnectionWriter to raw mode must be done
//               with care.  This can only be done when the matching
//               ConnectionReader is also set to raw mode, or when the
//               ConnectionWriter is communicating to a process that
//               does not expect datagrams.
//////////////////////////////////////////////////////////////////// 2 4 this 3 412  4 mode 1 377  
107 14 Dtool_7xrj6jjm 0 6 111 377 0 14 Dtool_7xrj6jjm 313 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_raw_mode
//       Access: Public
//  Description: Returns the current setting of the raw mode flag.
//               See set_raw_mode().
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
108 14 Dtool_7xrjGRcu 0 4 112 378 0 14 Dtool_7xrjGRcu 552 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::set_tcp_header_size
//       Access: Public
//  Description: Sets the header size of TCP packets.  At the present,
//               legal values for this are 0, 2, or 4; this specifies
//               the number of bytes to use encode the datagram length
//               at the start of each TCP datagram.  Sender and
//               receiver must independently agree on this.
//////////////////////////////////////////////////////////////////// 2 4 this 3 412  15 tcp_header_size 1 388  
109 14 Dtool_7xrj64D5 0 6 113 388 0 14 Dtool_7xrj64D5 325 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::get_tcp_header_size
//       Access: Public
//  Description: Returns the current setting of TCP header size.
//               See set_tcp_header_size().
//////////////////////////////////////////////////////////////////// 1 4 this 3 413  
110 14 Dtool_7xrjrvh2 0 4 114 378 0 14 Dtool_7xrjrvh2 402 ////////////////////////////////////////////////////////////////////
//     Function: ConnectionWriter::shutdown
//       Access: Published
//  Description: Stops all the threads and cleans them up.  This is
//               called automatically by the destructor, but it may be
//               called explicitly before destruction.
//////////////////////////////////////////////////////////////////// 1 4 this 3 412  
111 14 Dtool_7xrjkHyf 0 7 129 415 291 14 Dtool_7xrjkHyf 527 ////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::Constructor
//       Access: Published
//  Description: Creates a new DatagramGeneratorNet with the indicated
//               number of threads to handle requests.  Normally
//               num_threads should be either 0 or 1 to guarantee that
//               datagrams are generated in the same order in which
//               they were received.
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  11 num_threads 1 388  
112 14 Dtool_7xrjAIYO 0 6 131 377 0 14 Dtool_7xrjAIYO 415 ////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::get_datagram
//       Access: Published, Virtual
//  Description: Reads the next datagram from the stream.  Blocks
//               until a datagram is available.  Returns true on
//               success, false on stream closed or error.
//////////////////////////////////////////////////////////////////// 2 4 this 3 415  4 data 1 416  
113 14 Dtool_7xrjqcvu 0 6 132 377 0 14 Dtool_7xrjqcvu 393 ////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::is_eof
//       Access: Published, Virtual
//  Description: Returns true if the stream has been closed normally.
//               This test may only be made after a call to
//               get_datagram() has failed.
//////////////////////////////////////////////////////////////////// 1 4 this 3 415  
114 14 Dtool_7xrjfNus 0 6 133 377 0 14 Dtool_7xrjfNus 289 ////////////////////////////////////////////////////////////////////
//     Function: DatagramGeneratorNet::is_error
//       Access: Published, Virtual
//  Description: Returns true if the stream has an error condition.
//////////////////////////////////////////////////////////////////// 1 4 this 3 415  
115 14 Dtool_7xrjn9Tm 0 6 117 417 0 14 Dtool_7xrjn9Tm 0 1 4 this 3 415  
116 14 Dtool_7xrjuiKx 0 6 118 415 0 14 Dtool_7xrjuiKx 0 1 4 this 3 417  
117 14 Dtool_7xrjBg_B 0 6 119 400 0 14 Dtool_7xrjBg_B 0 1 4 this 3 415  
118 14 Dtool_7xrjiEa8 0 6 120 415 0 14 Dtool_7xrjiEa8 0 1 4 this 3 400  
119 14 Dtool_7xrjgFc6 0 6 127 418 0 14 Dtool_7xrjgFc6 0 1 4 this 3 415  
120 14 Dtool_7xrjl8U5 0 6 128 415 0 14 Dtool_7xrjl8U5 0 1 4 this 3 418  
121 14 Dtool_7xrjHF15 0 4 122 378 0 14 Dtool_7xrjHF15 0 2 4 this 3 418  8 max_size 1 388  
122 14 Dtool_7xrjlTnN 0 6 123 388 0 14 Dtool_7xrjlTnN 0 1 4 this 3 419  
123 14 Dtool_7xrjisuS 0 6 124 388 0 14 Dtool_7xrjisuS 0 1 4 this 3 419  
124 14 Dtool_7xrjeg9U 0 6 125 377 0 14 Dtool_7xrjeg9U 0 1 4 this 3 419  
125 14 Dtool_7xrj8u8g 0 4 126 378 0 14 Dtool_7xrj8u8g 0 1 4 this 3 418  
126 14 Dtool_7xrja5Ym 0 7 140 421 305 14 Dtool_7xrja5Ym 512 ////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::Constructor
//       Access: Published
//  Description: Creates a new DatagramSinkNet with the indicated
//               number of threads to handle writing.  Normally
//               num_threads should be either 0 or 1 to guarantee that
//               datagrams are delivered in the same order in which
//               they were sent.
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  11 num_threads 1 388  
127 14 Dtool_7xrjWcqv 0 4 141 378 0 14 Dtool_7xrjWcqv 804 // Filename: datagramSinkNet.I
// Created by:  drose (15Feb09)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::set_target
//       Access: Published
//  Description: Specifies the Connection that will receive all future
//               Datagrams sent.
//////////////////////////////////////////////////////////////////// 2 4 this 3 421  10 connection 1 373  
128 14 Dtool_7xrji2Qd 0 7 142 373 0 14 Dtool_7xrji2Qd 345 ////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::get_target
//       Access: Published
//  Description: Returns the current target Connection, or NULL if the
//               target has not yet been set.  See set_target().
//////////////////////////////////////////////////////////////////// 1 4 this 3 422  
129 14 Dtool_7xrjn6vk 0 6 143 377 0 14 Dtool_7xrjn6vk 413 ////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::put_datagram
//       Access: Published, Virtual
//  Description: Sends the given datagram to the target.  Returns true
//               on success, false if there is an error.  Blocks if
//               necessary until the target is ready.
//////////////////////////////////////////////////////////////////// 2 4 this 3 421  4 data 1 404  
130 14 Dtool_7xrjdo5D 0 6 144 377 0 14 Dtool_7xrjdo5D 347 ////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::is_error
//       Access: Published, Virtual
//  Description: Returns true if there is an error on the target
//               connection, or if the target has never been set.
//////////////////////////////////////////////////////////////////// 1 4 this 3 421  
131 14 Dtool_7xrjXodB 0 4 145 378 0 14 Dtool_7xrjXodB 321 ////////////////////////////////////////////////////////////////////
//     Function: DatagramSinkNet::flush
//       Access: Public, Virtual
//  Description: Ensures that all datagrams previously written will be
//               visible on the stream.
//////////////////////////////////////////////////////////////////// 1 4 this 3 421  
132 14 Dtool_7xrjyzup 0 6 136 424 0 14 Dtool_7xrjyzup 0 1 4 this 3 421  
133 14 Dtool_7xrjyn83 0 6 137 421 0 14 Dtool_7xrjyn83 0 1 4 this 3 424  
134 14 Dtool_7xrjtQW_ 0 6 138 412 0 14 Dtool_7xrjtQW_ 0 1 4 this 3 421  
135 14 Dtool_7xrjh9i4 0 6 139 421 0 14 Dtool_7xrjh9i4 0 1 4 this 3 412  
136 14 Dtool_7xrjLgYr 0 7 158 425 316 14 Dtool_7xrjLgYr 233 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  11 num_threads 1 388  
137 14 Dtool_7xrjjF0a 0 6 160 377 0 14 Dtool_7xrjjF0a 414 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::new_connection_available
//       Access: Public
//  Description: Returns true if a new connection was recently
//               established; the connection information may then be
//               retrieved via get_new_connection().
//////////////////////////////////////////////////////////////////// 1 4 this 3 425  
138 14 Dtool_7xrjwbmC 0 6 161 377 0 14 Dtool_7xrjwbmC 467 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::get_new_connection
//       Access: Public
//  Description: This flavor of get_new_connection() simply returns a
//               new connection, assuming the user doesn't care about
//               the rendezvous socket that originated it or the
//               address it came from.
//////////////////////////////////////////////////////////////////// 2 4 this 3 425  14 new_connection 1 374  
139 14 Dtool_7xrjieyI 0 6 161 377 0 14 Dtool_7xrjieyI 1182 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionListener::get_new_connection
//       Access: Public
//  Description: If a previous call to new_connection_available()
//               returned true, this function will return information
//               about the newly established connection.
//
//               The rendezvous parameter is the particular rendezvous
//               socket this new connection originally communicated
//               with; it is provided in case the ConnectionListener
//               was monitorind more than one and you care which one
//               it was.  The address parameter is the net address of
//               the new client, and new_connection is the socket of
//               the newly established connection.
//
//               The return value is true if a connection was
//               successfully returned, or false if there was, in
//               fact, no new connection.  (This may happen if there
//               are multiple threads accessing the
//               QueuedConnectionListener).
//////////////////////////////////////////////////////////////////// 4 4 this 3 425  10 rendezvous 1 374  7 address 1 384  14 new_connection 1 374  
140 14 Dtool_7xrjGcvf 0 6 148 426 0 14 Dtool_7xrjGcvf 0 1 4 this 3 425  
141 14 Dtool_7xrjOFpL 0 6 149 425 0 14 Dtool_7xrjOFpL 0 1 4 this 3 426  
142 14 Dtool_7xrj_bnE 0 6 156 427 0 14 Dtool_7xrj_bnE 0 1 4 this 3 425  
143 14 Dtool_7xrjPSLm 0 6 157 425 0 14 Dtool_7xrjPSLm 0 1 4 this 3 427  
144 14 Dtool_7xrjRXgW 0 4 151 378 0 14 Dtool_7xrjRXgW 0 2 4 this 3 427  8 max_size 1 388  
145 14 Dtool_7xrj_qdb 0 6 152 388 0 14 Dtool_7xrj_qdb 0 1 4 this 3 428  
146 14 Dtool_7xrjzNtc 0 6 153 388 0 14 Dtool_7xrjzNtc 0 1 4 this 3 428  
147 14 Dtool_7xrjTAQd 0 6 154 377 0 14 Dtool_7xrjTAQd 0 1 4 this 3 428  
148 14 Dtool_7xrjZTRQ 0 4 155 378 0 14 Dtool_7xrjZTRQ 0 1 4 this 3 427  
149 14 Dtool_7xrj4UnC 0 7 173 430 329 14 Dtool_7xrj4UnC 232 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
150 14 Dtool_7xrj4mZr 0 6 175 377 0 14 Dtool_7xrj4mZr 1031 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::reset_connection_available
//       Access: Public
//  Description: Returns true if one of the readers/writers/listeners
//               reported a connection reset recently.  If so, the
//               particular connection that has been reset can be
//               extracted via get_reset_connection().
//
//               Only connections which were externally reset are
//               certain to appear in this list.  Those which were
//               explicitly closed via a call to close_connection()
//               may or may not be reported.  Furthermore, it is the
//               responsibility of the caller to subsequently call
//               close_connection() with any connection reported reset
//               by this call.  (There is no harm in calling
//               close_connection() more than once on a given socket.)
//////////////////////////////////////////////////////////////////// 1 4 this 3 431  
151 14 Dtool_7xrjiC0F 0 6 176 377 0 14 Dtool_7xrjiC0F 1253 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionManager::get_reset_connection
//       Access: Public
//  Description: If a previous call to reset_connection_available()
//               returned true, this function will return information
//               about the newly reset connection.
//
//               Only connections which were externally reset are
//               certain to appear in this list.  Those which were
//               explicitly closed via a call to close_connection()
//               may or may not be reported.  Furthermore, it is the
//               responsibility of the caller to subsequently call
//               close_connection() with any connection reported reset
//               by this call.  (There is no harm in calling
//               close_connection() more than once on a given socket.)
//
//               The return value is true if a connection was
//               successfully returned, or false if there was, in
//               fact, no reset connection.  (This may happen if
//               there are multiple threads accessing the
//               QueuedConnectionManager).
//////////////////////////////////////////////////////////////////// 2 4 this 3 430  10 connection 1 374  
152 14 Dtool_7xrjuw7p 0 6 163 394 0 14 Dtool_7xrjuw7p 0 1 4 this 3 430  
153 14 Dtool_7xrjO4Vo 0 6 164 430 0 14 Dtool_7xrjO4Vo 0 1 4 this 3 394  
154 14 Dtool_7xrjv2GO 0 6 171 433 0 14 Dtool_7xrjv2GO 0 1 4 this 3 430  
155 14 Dtool_7xrj9EdG 0 6 172 430 0 14 Dtool_7xrj9EdG 0 1 4 this 3 433  
156 14 Dtool_7xrjGHvr 0 4 166 378 0 14 Dtool_7xrjGHvr 0 2 4 this 3 433  8 max_size 1 388  
157 14 Dtool_7xrjCaPK 0 6 167 388 0 14 Dtool_7xrjCaPK 0 1 4 this 3 434  
158 14 Dtool_7xrjtwOz 0 6 168 388 0 14 Dtool_7xrjtwOz 0 1 4 this 3 434  
159 14 Dtool_7xrjhUKF 0 6 169 377 0 14 Dtool_7xrjhUKF 0 1 4 this 3 434  
160 14 Dtool_7xrjFx0k 0 4 170 378 0 14 Dtool_7xrjFx0k 0 1 4 this 3 433  
161 14 Dtool_7xrjg6wa 0 7 188 436 342 14 Dtool_7xrjg6wa 234 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 7 manager 1 394  11 num_threads 1 388  
162 14 Dtool_7xrj36NV 0 6 190 377 0 14 Dtool_7xrj36NV 349 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::data_available
//       Access: Published
//  Description: Returns true if a datagram is available on the queue;
//               call get_data() to extract the datagram.
//////////////////////////////////////////////////////////////////// 1 4 this 3 436  
163 14 Dtool_7xrj4yzz 0 6 191 377 0 14 Dtool_7xrj4yzz 593 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::get_data
//       Access: Published
//  Description: This flavor of QueuedConnectionReader::get_data(),
//               works like the other, except that it only fills a
//               Datagram object, not a NetDatagram object.  This
//               means that the Datagram cannot be queried for its
//               source Connection and/or NetAddress, but it is useful
//               in all other respects.
//////////////////////////////////////////////////////////////////// 2 4 this 3 436  6 result 1 416  
164 14 Dtool_7xrjX1An 0 6 191 377 0 14 Dtool_7xrjX1An 681 ////////////////////////////////////////////////////////////////////
//     Function: QueuedConnectionReader::get_data
//       Access: Published
//  Description: If a previous call to data_available() returned
//               true, this function will return the datagram that has
//               become available.
//
//               The return value is true if a datagram was
//               successfully returned, or false if there was, in
//               fact, no datagram available.  (This may happen if
//               there are multiple threads accessing the
//               QueuedConnectionReader).
//////////////////////////////////////////////////////////////////// 2 4 this 3 436  6 result 1 403  
165 14 Dtool_7xrjH9pb 0 6 178 400 0 14 Dtool_7xrjH9pb 0 1 4 this 3 436  
166 14 Dtool_7xrjHiXP 0 6 179 436 0 14 Dtool_7xrjHiXP 0 1 4 this 3 400  
167 14 Dtool_7xrjpv2h 0 6 186 437 0 14 Dtool_7xrjpv2h 0 1 4 this 3 436  
168 14 Dtool_7xrjAFb2 0 6 187 436 0 14 Dtool_7xrjAFb2 0 1 4 this 3 437  
169 14 Dtool_7xrjTCal 0 4 181 378 0 14 Dtool_7xrjTCal 0 2 4 this 3 437  8 max_size 1 388  
170 14 Dtool_7xrj2D9N 0 6 182 388 0 14 Dtool_7xrj2D9N 0 1 4 this 3 438  
171 14 Dtool_7xrjHDe3 0 6 183 388 0 14 Dtool_7xrjHDe3 0 1 4 this 3 438  
172 14 Dtool_7xrj3E__ 0 6 184 377 0 14 Dtool_7xrj3E__ 0 1 4 this 3 438  
173 14 Dtool_7xrjHK5i 0 4 185 378 0 14 Dtool_7xrjHK5i 0 1 4 this 3 437  
174 14 Dtool_7xrjA_Qe 0 7 193 440 219 14 Dtool_7xrjA_Qe 231 ////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 7 manager 1 394  
175 14 Dtool_7xrjmPBT 0 6 194 377 0 14 Dtool_7xrjmPBT 346 ////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::data_available
//       Access: Public
//  Description: Returns true if a datagram is available on the queue;
//               call get_data() to extract the datagram.
//////////////////////////////////////////////////////////////////// 1 4 this 3 440  
176 14 Dtool_7xrjgnmx 0 6 195 377 0 14 Dtool_7xrjgnmx 590 ////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::get_data
//       Access: Public
//  Description: This flavor of RecentConnectionReader::get_data(),
//               works like the other, except that it only fills a
//               Datagram object, not a NetDatagram object.  This
//               means that the Datagram cannot be queried for its
//               source Connection and/or NetAddress, but it is useful
//               in all other respects.
//////////////////////////////////////////////////////////////////// 2 4 this 3 440  6 result 1 416  
177 14 Dtool_7xrjdb0k 0 6 195 377 0 14 Dtool_7xrjdb0k 678 ////////////////////////////////////////////////////////////////////
//     Function: RecentConnectionReader::get_data
//       Access: Public
//  Description: If a previous call to data_available() returned
//               true, this function will return the datagram that has
//               become available.
//
//               The return value is true if a datagram was
//               successfully returned, or false if there was, in
//               fact, no datagram available.  (This may happen if
//               there are multiple threads accessing the
//               RecentConnectionReader).
//////////////////////////////////////////////////////////////////// 2 4 this 3 440  6 result 1 403  
93
348 23 PointerTo< Connection > 0 26625 23 PointerTo< Connection > 23 PointerTo< Connection > 0 0 0 1 180 181 0 4 182 183 184 185 0 0 1 0 349 0 0 0 0 0

349 27 PointerToBase< Connection > 0 43009 27 PointerToBase< Connection > 27 PointerToBase< Connection > 0 0 0 0 0 0 2 178 179 0 0 1 0 350 0 0 0 0 0

350 13 PointerToVoid 0 2049 13 PointerToVoid 13 PointerToVoid 0 0 0 0 0 0 0 0 0 0 0 0 635
////////////////////////////////////////////////////////////////////
//       Class : PointerToVoid
// Description : This is the non-template part of the base class for
//               PointerTo and ConstPointerTo.  It is necessary so we
//               can keep a pointer to a non-template class within the
//               ReferenceCount object, to implement weak reference
//               pointers--we need to have something to clean up when
//               the ReferenceCount object destructs.
//
//               This is the base class for PointerToBase<T>.
////////////////////////////////////////////////////////////////////

351 10 NetAddress 0 141313 10 NetAddress 10 NetAddress 0 0 0 1 186 199 0 12 187 188 189 190 191 192 193 194 195 196 197 198 0 0 0 0 0 0

352 10 Connection 0 75777 10 Connection 10 Connection 0 0 0 1 200 0 0 18 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 0 0 1 0 353 0 0 0 0 258
////////////////////////////////////////////////////////////////////
//       Class : Connection
// Description : Represents a single TCP or UDP socket for input or
//               output.
////////////////////////////////////////////////////////////////////

353 14 ReferenceCount 0 2049 14 ReferenceCount 14 ReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : ReferenceCount
// Description : A base class for all things that want to be
//               reference-counted.  ReferenceCount works in
//               conjunction with PointerTo to automatically delete
//               objects when the last pointer to them goes away.
////////////////////////////////////////////////////////////////////

354 16 ConnectionReader 0 26625 16 ConnectionReader 16 ConnectionReader 0 0 0 0 219 0 12 220 221 222 223 224 225 226 227 228 229 230 231 0 0 0 0 0 1261
////////////////////////////////////////////////////////////////////
//       Class : ConnectionReader
// Description : This is an abstract base class for a family of
//               classes that listen for activity on a socket and
//               respond to it, for instance by reading a datagram and
//               serving it (or queueing it up for later service).
//
//               A ConnectionReader may define an arbitrary number of
//               threads (at least one) to process datagrams coming in
//               from an arbitrary number of sockets that it is
//               monitoring.  The number of threads is specified at
//               construction time and cannot be changed, but the set
//               of sockets that is to be monitored may be constantly
//               modified at will.
//
//               This is an abstract class because it doesn't define
//               how to process each received datagram.  See
//               QueuedConnectionReader.  Also note that
//               ConnectionListener derives from this class, extending
//               it to accept connections on a rendezvous socket
//               rather than read datagrams.
////////////////////////////////////////////////////////////////////

355 18 ConnectionListener 0 141313 18 ConnectionListener 18 ConnectionListener 0 0 0 0 232 0 0 0 0 1 0 354 0 0 0 0 609
////////////////////////////////////////////////////////////////////
//       Class : ConnectionListener
// Description : This is a special kind of ConnectionReader that waits
//               for activity on a rendezvous port and accepts a TCP
//               connection (instead of attempting to read a datagram
//               from the rendezvous port).
//
//               It is itself an abstract class, as it doesn't define
//               what to do with the established connection.  See
//               QueuedConnectionListener.
////////////////////////////////////////////////////////////////////

356 11 NetDatagram 0 141313 11 NetDatagram 11 NetDatagram 0 0 0 1 233 240 0 6 234 235 236 237 238 239 0 0 1 0 357 0 0 0 0 437
////////////////////////////////////////////////////////////////////
//       Class : NetDatagram
// Description : A specific kind of Datagram, especially for sending
//               across or receiving from a network.  It's different
//               only in that it knows which Connection and/or
//               NetAddress it is to be sent to or was received from.
////////////////////////////////////////////////////////////////////

357 8 Datagram 0 2049 8 Datagram 8 Datagram 0 0 0 0 0 0 0 0 0 0 0 0 900
////////////////////////////////////////////////////////////////////
//       Class : Datagram
// Description : An ordered list of data elements, formatted in memory
//               for transmission over a socket or writing to a data
//               file.
//
//               Data elements should be added one at a time, in
//               order, to the Datagram.  The nature and contents of
//               the data elements are totally up to the user.  When a
//               Datagram has been transmitted and received, its data
//               elements may be extracted using a DatagramIterator;
//               it is up to the caller to know the correct type of
//               each data element in order.
//
//               A Datagram is itself headerless; it is simply a
//               collection of data elements.
////////////////////////////////////////////////////////////////////

358 17 ConnectionManager 0 26625 17 ConnectionManager 17 ConnectionManager 0 0 0 1 241 242 0 9 243 244 245 246 247 248 261 262 263 1 441 0 0 0 1 359 918
////////////////////////////////////////////////////////////////////
//       Class : ConnectionManager
// Description : The primary interface to the low-level networking
//               layer in this package.  A ConnectionManager is used
//               to establish and destroy TCP and UDP connections.
//               Communication on these connections, once established,
//               is handled via ConnectionReader, ConnectionWriter,
//               and ConnectionListener.
//
//               You may use this class directly if you don't care
//               about tracking which connections have been
//               unexpectedly closed; otherwise, you should use
//               QueuedConnectionManager to get reports about these
//               events (or derive your own class to handle these
//               events properly).
////////////////////////////////////////////////////////////////////

359 9 Interface 0 403457 28 ConnectionManager::Interface 28 ConnectionManager::Interface 358 0 0 0 260 0 11 249 250 251 252 253 254 255 256 257 258 259 0 0 0 0 0 0

360 16 ConnectionWriter 0 26625 16 ConnectionWriter 16 ConnectionWriter 0 0 0 1 264 265 0 13 266 267 268 269 270 271 272 273 274 275 276 277 278 0 0 0 0 0 545
////////////////////////////////////////////////////////////////////
//       Class : ConnectionWriter
// Description : This class handles threaded delivery of datagrams to
//               various TCP or UDP sockets.
//
//               A ConnectionWriter may define an arbitrary number of
//               threads (0 or more) to write its datagrams to
//               sockets.  The number of threads is specified at
//               construction time and cannot be changed.
////////////////////////////////////////////////////////////////////

361 20 DatagramGeneratorNet 0 26625 20 DatagramGeneratorNet 20 DatagramGeneratorNet 0 0 0 1 290 291 0 3 292 293 294 0 0 3 3 362 279 280 3 354 281 282 3 363 288 289 0 0 413
////////////////////////////////////////////////////////////////////
//       Class : DatagramGeneratorNet
// Description : This class provides datagrams one-at-a-time as read
//               directly from the net, via a TCP connection.  If a
//               datagram is not available, get_datagram() will block
//               until one is.
////////////////////////////////////////////////////////////////////

362 17 DatagramGenerator 0 2049 17 DatagramGenerator 17 DatagramGenerator 0 0 0 0 0 0 0 0 0 0 0 0 335
////////////////////////////////////////////////////////////////////
//       Class : DatagramGenerator
// Description : This class defines the abstract interace to any
//               source of datagrams, whether it be from a file or
//               from the net.
////////////////////////////////////////////////////////////////////

363 24 QueuedReturn< Datagram > 0 43009 24 QueuedReturn< Datagram > 24 QueuedReturn< Datagram > 0 0 0 0 0 0 5 283 284 285 286 287 0 0 0 0 0 0

364 15 DatagramSinkNet 0 141313 15 DatagramSinkNet 15 DatagramSinkNet 0 0 0 1 299 305 0 5 300 301 302 303 304 0 0 2 3 365 295 296 3 360 297 298 0 0 298
////////////////////////////////////////////////////////////////////
//       Class : DatagramSinkNet
// Description : This class accepts datagrams one-at-a-time and sends
//               them over the net, via a TCP connection.
////////////////////////////////////////////////////////////////////

365 12 DatagramSink 0 2049 12 DatagramSink 12 DatagramSink 0 0 0 0 0 0 0 0 0 0 0 0 340
////////////////////////////////////////////////////////////////////
//       Class : DatagramSink
// Description : This class defines the abstract interface to sending
//               datagrams to any target, whether it be into a file
//               or across the net
////////////////////////////////////////////////////////////////////

366 24 QueuedConnectionListener 0 26625 24 QueuedConnectionListener 24 QueuedConnectionListener 0 0 0 1 315 316 0 2 317 318 0 0 2 3 355 306 307 3 367 313 314 0 0 360
////////////////////////////////////////////////////////////////////
//       Class : QueuedConnectionListener
// Description : This flavor of ConnectionListener will queue up all
//               of the TCP connections it established for later
//               detection by the client code.
////////////////////////////////////////////////////////////////////

367 38 QueuedReturn< ConnectionListenerData > 0 43009 38 QueuedReturn< ConnectionListenerData > 38 QueuedReturn< ConnectionListenerData > 0 0 0 0 0 0 5 308 309 310 311 312 0 0 0 0 0 0

368 23 QueuedConnectionManager 0 26625 23 QueuedConnectionManager 23 QueuedConnectionManager 0 0 0 1 328 329 0 2 330 331 0 0 2 3 358 319 320 3 369 326 327 0 0 726
////////////////////////////////////////////////////////////////////
//       Class : QueuedConnectionManager
// Description : This flavor of ConnectionManager will queue up all of
//               the reset-connection messages from the
//               ConnectionReaders and ConnectionWriters and report
//               them to the client on demand.
//
//               When a reset connection has been discovered via
//               reset_connection_available()/get_reset_connection(),
//               it is still the responsibility of the client to call
//               close_connection() on that connection to free up its
//               resources.
////////////////////////////////////////////////////////////////////

369 39 QueuedReturn< PointerTo< Connection > > 0 43009 39 QueuedReturn< PointerTo< Connection > > 39 QueuedReturn< PointerTo< Connection > > 0 0 0 0 0 0 5 321 322 323 324 325 0 0 0 0 0 0

370 22 QueuedConnectionReader 0 26625 22 QueuedConnectionReader 22 QueuedConnectionReader 0 0 0 1 341 342 0 2 343 344 0 0 2 3 354 332 333 3 371 339 340 0 0 551
////////////////////////////////////////////////////////////////////
//       Class : QueuedConnectionReader
// Description : This flavor of ConnectionReader will read from its
//               sockets and queue up all of the datagrams read for
//               later receipt by the client code.  This class is
//               useful for client code that doesn't want to deal with
//               threading and is willing to poll for datagrams at its
//               convenience.
////////////////////////////////////////////////////////////////////

371 27 QueuedReturn< NetDatagram > 0 43009 27 QueuedReturn< NetDatagram > 27 QueuedReturn< NetDatagram > 0 0 0 0 0 0 5 334 335 336 337 338 0 0 0 0 0 0

372 22 RecentConnectionReader 0 75777 22 RecentConnectionReader 22 RecentConnectionReader 0 0 0 1 345 219 0 2 346 347 0 0 1 0 354 0 0 0 0 718
////////////////////////////////////////////////////////////////////
//       Class : RecentConnectionReader
// Description : This flavor of ConnectionReader will read from its
//               sockets and retain only the single most recent
//               datagram for inspection by client code.  It's useful
//               particularly for reading telemetry-type data from UDP
//               sockets where you don't care about getting every last
//               socket, and in fact if the sockets are coming too
//               fast you'd prefer to skip some of them.
//
//               This class will always create one thread for itself.
////////////////////////////////////////////////////////////////////

373 12 Connection * 0 8576 12 Connection * 12 Connection * 0 0 352 0 0 0 0 0 0 0 0 0 0

374 25 PointerTo< Connection > * 0 8576 25 PointerTo< Connection > * 25 PointerTo< Connection > * 0 0 348 0 0 0 0 0 0 0 0 0 0

375 31 PointerTo< Connection > const * 0 8576 31 PointerTo< Connection > const * 31 PointerTo< Connection > const * 0 0 376 0 0 0 0 0 0 0 0 0 0

376 29 PointerTo< Connection > const 0 8832 29 PointerTo< Connection > const 29 PointerTo< Connection > const 0 0 348 0 0 0 0 0 0 0 0 0 0

377 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

378 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

379 29 PointerToBase< Connection > * 0 8576 29 PointerToBase< Connection > * 29 PointerToBase< Connection > * 0 0 349 0 0 0 0 0 0 0 0 0 0

380 35 PointerToBase< Connection > const * 0 8576 35 PointerToBase< Connection > const * 35 PointerToBase< Connection > const * 0 0 381 0 0 0 0 0 0 0 0 0 0

381 33 PointerToBase< Connection > const 0 8832 33 PointerToBase< Connection > const 33 PointerToBase< Connection > const 0 0 349 0 0 0 0 0 0 0 0 0 0

382 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 383 0 0 0 0 0 0 0 0 0 0

383 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

384 12 NetAddress * 0 8576 12 NetAddress * 12 NetAddress * 0 0 351 0 0 0 0 0 0 0 0 0 0

385 22 Socket_Address const * 0 8576 22 Socket_Address const * 22 Socket_Address const * 0 0 386 0 0 0 0 0 0 0 0 0 0

386 20 Socket_Address const 0 8832 20 Socket_Address const 20 Socket_Address const 0 0 387 0 0 0 0 0 0 0 0 0 0

387 14 Socket_Address 0 2048 14 Socket_Address 14 Socket_Address 0 0 0 0 0 0 0 0 0 0 0 0 0

388 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

389 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

390 18 NetAddress const * 0 8576 18 NetAddress const * 18 NetAddress const * 0 0 391 0 0 0 0 0 0 0 0 0 0

391 16 NetAddress const 0 8832 16 NetAddress const 16 NetAddress const 0 0 351 0 0 0 0 0 0 0 0 0 0

392 12 unsigned int 0 8198 12 unsigned int 12 unsigned int 0 1 0 0 0 0 0 0 0 0 0 0 0

393 13 unsigned char 0 8198 13 unsigned char 13 unsigned char 0 5 0 0 0 0 0 0 0 0 0 0 0

394 19 ConnectionManager * 0 8576 19 ConnectionManager * 19 ConnectionManager * 0 0 358 0 0 0 0 0 0 0 0 0 0

395 11 Socket_IP * 0 8576 11 Socket_IP * 11 Socket_IP * 0 0 396 0 0 0 0 0 0 0 0 0 0

396 9 Socket_IP 0 2048 9 Socket_IP 9 Socket_IP 0 0 0 0 0 0 0 0 0 0 0 0 676
/////////////////////////////////////////////////////////////////////
// Class : Socket_IP
//
// Description : Base functionality for a INET domain Socket
//     this call should be the starting point for all other
//     unix domain sockets
//
//
//                                       SocketIP
//                                          |
//       -------------------------------------------------------------------
//       |             |                       |                           |
//     SocketTCP     SocketTCP_Listen    SocketUDP_Incoming   SocketUDP_OutBound
//
//
//
// socket_fdset
//
/////////////////////////////////////////////////////////////////////

397 18 Connection const * 0 8576 18 Connection const * 18 Connection const * 0 0 398 0 0 0 0 0 0 0 0 0 0

398 16 Connection const 0 8832 16 Connection const 16 Connection const 0 0 352 0 0 0 0 0 0 0 0 0 0

399 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0

400 18 ConnectionReader * 0 8576 18 ConnectionReader * 18 ConnectionReader * 0 0 354 0 0 0 0 0 0 0 0 0 0

401 24 ConnectionReader const * 0 8576 24 ConnectionReader const * 24 ConnectionReader const * 0 0 402 0 0 0 0 0 0 0 0 0 0

402 22 ConnectionReader const 0 8832 22 ConnectionReader const 22 ConnectionReader const 0 0 354 0 0 0 0 0 0 0 0 0 0

403 13 NetDatagram * 0 8576 13 NetDatagram * 13 NetDatagram * 0 0 356 0 0 0 0 0 0 0 0 0 0

404 16 Datagram const * 0 8576 16 Datagram const * 16 Datagram const * 0 0 405 0 0 0 0 0 0 0 0 0 0

405 14 Datagram const 0 8832 14 Datagram const 14 Datagram const 0 0 357 0 0 0 0 0 0 0 0 0 0

406 19 NetDatagram const * 0 8576 19 NetDatagram const * 19 NetDatagram const * 0 0 407 0 0 0 0 0 0 0 0 0 0

407 17 NetDatagram const 0 8832 17 NetDatagram const 17 NetDatagram const 0 0 356 0 0 0 0 0 0 0 0 0 0

408 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

409 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 408 0 0 0 0 0 0 0 0 0 0

410 17 Interface const * 0 8576 36 ConnectionManager::Interface const * 36 ConnectionManager::Interface const * 0 0 411 0 0 0 0 0 0 0 0 0 0

411 15 Interface const 0 8832 34 ConnectionManager::Interface const 34 ConnectionManager::Interface const 0 0 359 0 0 0 0 0 0 0 0 0 0

412 18 ConnectionWriter * 0 8576 18 ConnectionWriter * 18 ConnectionWriter * 0 0 360 0 0 0 0 0 0 0 0 0 0

413 24 ConnectionWriter const * 0 8576 24 ConnectionWriter const * 24 ConnectionWriter const * 0 0 414 0 0 0 0 0 0 0 0 0 0

414 22 ConnectionWriter const 0 8832 22 ConnectionWriter const 22 ConnectionWriter const 0 0 360 0 0 0 0 0 0 0 0 0 0

415 22 DatagramGeneratorNet * 0 8576 22 DatagramGeneratorNet * 22 DatagramGeneratorNet * 0 0 361 0 0 0 0 0 0 0 0 0 0

416 10 Datagram * 0 8576 10 Datagram * 10 Datagram * 0 0 357 0 0 0 0 0 0 0 0 0 0

417 19 DatagramGenerator * 0 8576 19 DatagramGenerator * 19 DatagramGenerator * 0 0 362 0 0 0 0 0 0 0 0 0 0

418 26 QueuedReturn< Datagram > * 0 8576 26 QueuedReturn< Datagram > * 26 QueuedReturn< Datagram > * 0 0 363 0 0 0 0 0 0 0 0 0 0

419 32 QueuedReturn< Datagram > const * 0 8576 32 QueuedReturn< Datagram > const * 32 QueuedReturn< Datagram > const * 0 0 420 0 0 0 0 0 0 0 0 0 0

420 30 QueuedReturn< Datagram > const 0 8832 30 QueuedReturn< Datagram > const 30 QueuedReturn< Datagram > const 0 0 363 0 0 0 0 0 0 0 0 0 0

421 17 DatagramSinkNet * 0 8576 17 DatagramSinkNet * 17 DatagramSinkNet * 0 0 364 0 0 0 0 0 0 0 0 0 0

422 23 DatagramSinkNet const * 0 8576 23 DatagramSinkNet const * 23 DatagramSinkNet const * 0 0 423 0 0 0 0 0 0 0 0 0 0

423 21 DatagramSinkNet const 0 8832 21 DatagramSinkNet const 21 DatagramSinkNet const 0 0 364 0 0 0 0 0 0 0 0 0 0

424 14 DatagramSink * 0 8576 14 DatagramSink * 14 DatagramSink * 0 0 365 0 0 0 0 0 0 0 0 0 0

425 26 QueuedConnectionListener * 0 8576 26 QueuedConnectionListener * 26 QueuedConnectionListener * 0 0 366 0 0 0 0 0 0 0 0 0 0

426 20 ConnectionListener * 0 8576 20 ConnectionListener * 20 ConnectionListener * 0 0 355 0 0 0 0 0 0 0 0 0 0

427 40 QueuedReturn< ConnectionListenerData > * 0 8576 40 QueuedReturn< ConnectionListenerData > * 40 QueuedReturn< ConnectionListenerData > * 0 0 367 0 0 0 0 0 0 0 0 0 0

428 46 QueuedReturn< ConnectionListenerData > const * 0 8576 46 QueuedReturn< ConnectionListenerData > const * 46 QueuedReturn< ConnectionListenerData > const * 0 0 429 0 0 0 0 0 0 0 0 0 0

429 44 QueuedReturn< ConnectionListenerData > const 0 8832 44 QueuedReturn< ConnectionListenerData > const 44 QueuedReturn< ConnectionListenerData > const 0 0 367 0 0 0 0 0 0 0 0 0 0

430 25 QueuedConnectionManager * 0 8576 25 QueuedConnectionManager * 25 QueuedConnectionManager * 0 0 368 0 0 0 0 0 0 0 0 0 0

431 31 QueuedConnectionManager const * 0 8576 31 QueuedConnectionManager const * 31 QueuedConnectionManager const * 0 0 432 0 0 0 0 0 0 0 0 0 0

432 29 QueuedConnectionManager const 0 8832 29 QueuedConnectionManager const 29 QueuedConnectionManager const 0 0 368 0 0 0 0 0 0 0 0 0 0

433 41 QueuedReturn< PointerTo< Connection > > * 0 8576 41 QueuedReturn< PointerTo< Connection > > * 41 QueuedReturn< PointerTo< Connection > > * 0 0 369 0 0 0 0 0 0 0 0 0 0

434 47 QueuedReturn< PointerTo< Connection > > const * 0 8576 47 QueuedReturn< PointerTo< Connection > > const * 47 QueuedReturn< PointerTo< Connection > > const * 0 0 435 0 0 0 0 0 0 0 0 0 0

435 45 QueuedReturn< PointerTo< Connection > > const 0 8832 45 QueuedReturn< PointerTo< Connection > > const 45 QueuedReturn< PointerTo< Connection > > const 0 0 369 0 0 0 0 0 0 0 0 0 0

436 24 QueuedConnectionReader * 0 8576 24 QueuedConnectionReader * 24 QueuedConnectionReader * 0 0 370 0 0 0 0 0 0 0 0 0 0

437 29 QueuedReturn< NetDatagram > * 0 8576 29 QueuedReturn< NetDatagram > * 29 QueuedReturn< NetDatagram > * 0 0 371 0 0 0 0 0 0 0 0 0 0

438 35 QueuedReturn< NetDatagram > const * 0 8576 35 QueuedReturn< NetDatagram > const * 35 QueuedReturn< NetDatagram > const * 0 0 439 0 0 0 0 0 0 0 0 0 0

439 33 QueuedReturn< NetDatagram > const 0 8832 33 QueuedReturn< NetDatagram > const 33 QueuedReturn< NetDatagram > const 0 0 371 0 0 0 0 0 0 0 0 0 0

440 24 RecentConnectionReader * 0 8576 24 RecentConnectionReader * 24 RecentConnectionReader * 0 0 372 0 0 0 0 0 0 0 0 0 0

0
0
1
441 0 0 74 14 get_interfaces 18 get_num_interfaces 13 get_interface 
