Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-26 13:12:30 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/panda/pandac/input/libp3net.in

3249 lines
173 KiB
Text
Raw Normal View History

Initial commit
2015-03-03 16:10:12 -06:00
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
Reference in a new issue Copy permalink