mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-26 05:02:31 -06:00
3248 lines
173 KiB
Text
Executable file
3248 lines
173 KiB
Text
Executable file
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 ©);
|
|
|
|
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 ©);
|
|
|
|
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 ©);
|
|
NetDatagram::NetDatagram(NetDatagram const ©);
|
|
|
|
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 ©);
|
|
void NetDatagram::operator =(NetDatagram const ©);
|
|
|
|
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
|