1565844124 3 3 8 libp3net 4 7xrj 12 panda3d.core 176 169 5 clear 0 4 346 34 PointerToBase< Connection >::clear 0 1 10 0 53 inline void PointerToBase< Connection >::clear(void); 170 6 output 0 4 346 35 PointerToBase< Connection >::output 0 1 11 0 66 void PointerToBase< Connection >::output(std::ostream &out) const; 171 9 PointerTo 0 4 345 34 PointerTo< Connection >::PointerTo 0 4 1 2 3 4 0 317 inline constexpr PointerTo< Connection >::PointerTo(void) noexcept = default; inline explicit constexpr PointerTo< Connection >::PointerTo(decltype(nullptr) ) noexcept; inline PointerTo< Connection >::PointerTo(Connection *ptr) noexcept; inline PointerTo< Connection >::PointerTo(PointerTo< Connection > const ©); 172 1 p 0 4 345 26 PointerTo< Connection >::p 0 1 5 289 // 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. 70 constexpr Connection *PointerTo< Connection >::p(void) const noexcept; 173 10 operator = 0 4 345 35 PointerTo< Connection >::operator = 0 2 6 7 0 151 inline void PointerTo< Connection >::operator =(Connection *ptr); inline void PointerTo< Connection >::operator =(PointerTo< Connection > const ©); 174 7 is_null 0 4 345 32 PointerTo< Connection >::is_null 0 1 8 0 57 inline bool PointerTo< Connection >::is_null(void) const; 175 5 clear 0 4 345 30 PointerTo< Connection >::clear 0 1 9 0 49 inline void PointerTo< Connection >::clear(void); 176 10 ~PointerTo 0 4 345 35 PointerTo< Connection >::~PointerTo 0 0 0 42 PointerTo< Connection >::~PointerTo(void); 177 10 NetAddress 0 4 348 22 NetAddress::NetAddress 0 3 12 13 14 271 /** * Constructs an unspecified address. */ /** * 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. */ 142 NetAddress::NetAddress(void); NetAddress::NetAddress(Socket_Address const &addr); inline NetAddress::NetAddress(NetAddress const &) = default; 178 7 set_any 0 4 348 19 NetAddress::set_any 0 1 15 179 /** * 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); 179 13 set_localhost 0 4 348 25 NetAddress::set_localhost 0 1 16 75 /** * Sets the address up to refer to a particular port, on this host. */ 41 bool NetAddress::set_localhost(int port); 180 13 set_broadcast 0 4 348 25 NetAddress::set_broadcast 0 1 17 53 /** * Sets the address to the broadcast address. */ 41 bool NetAddress::set_broadcast(int port); 181 8 set_host 0 4 348 20 NetAddress::set_host 0 1 18 141 /** * Sets the address up to refer to a particular port on a particular host. * Returns true if the hostname is known, false otherwise. */ 65 bool NetAddress::set_host(std::string const &hostname, int port); 182 5 clear 0 4 348 17 NetAddress::clear 0 1 19 54 /** * Resets the NetAddress to its initial state. */ 29 void NetAddress::clear(void); 183 8 get_port 0 4 348 20 NetAddress::get_port 0 1 20 64 /** * Returns the port number to which this address refers. */ 37 int NetAddress::get_port(void) const; 184 8 set_port 0 4 348 20 NetAddress::set_port 0 1 21 73 /** * Resets the port number without otherwise changing the address. */ 36 void NetAddress::set_port(int port); 185 13 get_ip_string 0 4 348 25 NetAddress::get_ip_string 0 1 22 86 /** * Returns the IP address to which this address refers, formatted as a string. */ 50 std::string NetAddress::get_ip_string(void) const; 186 6 is_any 0 4 348 18 NetAddress::is_any 0 1 23 58 /** * Returns true if the IP address has only zeroes. */ 36 bool NetAddress::is_any(void) const; 187 6 get_ip 0 4 348 18 NetAddress::get_ip 0 1 24 158 /** * Returns the IP address to which this address refers, as a 32-bit integer, * in host byte order. * @deprecated Does not work with IPv6 addresses. */ 40 uint32_t NetAddress::get_ip(void) const; 188 16 get_ip_component 0 4 348 28 NetAddress::get_ip_component 0 1 25 213 /** * 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. */ 50 uint8_t NetAddress::get_ip_component(int n) const; 189 8 get_addr 0 4 348 20 NetAddress::get_addr 0 1 26 55 /** * Returns the Socket_Address for this address. */ 55 Socket_Address const &NetAddress::get_addr(void) const; 190 6 output 0 4 348 18 NetAddress::output 0 1 27 10 /** * */ 49 void NetAddress::output(std::ostream &out) const; 191 8 get_hash 0 4 348 20 NetAddress::get_hash 0 1 28 10 /** * */ 45 std::size_t NetAddress::get_hash(void) const; 192 11 operator == 0 4 348 23 NetAddress::operator == 0 1 29 0 60 bool NetAddress::operator ==(NetAddress const &other) const; 193 11 operator != 0 4 348 23 NetAddress::operator != 0 1 30 0 60 bool NetAddress::operator !=(NetAddress const &other) const; 194 11 ~NetAddress 0 4 348 23 NetAddress::~NetAddress 0 0 0 30 NetAddress::~NetAddress(void); 195 10 Connection 0 4 349 22 Connection::Connection 0 1 31 177 /** * 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. */ 79 explicit Connection::Connection(ConnectionManager *manager, Socket_IP *socket); 196 11 get_address 0 4 349 23 Connection::get_address 0 1 32 83 /** * Returns the address bound to this connection, if it is a TCP connection. */ 47 NetAddress Connection::get_address(void) const; 197 11 get_manager 0 4 349 23 Connection::get_manager 0 1 33 92 /** * Returns a pointer to the ConnectionManager object that serves this * connection. */ 55 ConnectionManager *Connection::get_manager(void) const; 198 10 get_socket 0 4 349 22 Connection::get_socket 0 1 34 70 /** * Returns the internal Socket_IP that defines the connection. */ 46 Socket_IP *Connection::get_socket(void) const; 199 15 set_collect_tcp 0 4 349 27 Connection::set_collect_tcp 0 1 35 719 /** * 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); 200 15 get_collect_tcp 0 4 349 27 Connection::get_collect_tcp 0 1 36 85 /** * Returns the current setting of "collect-tcp" mode. See set_collect_tcp(). */ 45 bool Connection::get_collect_tcp(void) const; 201 24 set_collect_tcp_interval 0 4 349 36 Connection::set_collect_tcp_interval 0 1 37 231 /** * 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); 202 24 get_collect_tcp_interval 0 4 349 36 Connection::get_collect_tcp_interval 0 1 38 229 /** * 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; 203 14 consider_flush 0 4 349 26 Connection::consider_flush 0 1 39 153 /** * 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); 204 5 flush 0 4 349 17 Connection::flush 0 1 40 131 /** * 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); 205 10 set_linger 0 4 349 22 Connection::set_linger 0 1 41 467 // Socket options. void set_nonblock(bool flag); /** * 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); 206 14 set_reuse_addr 0 4 349 26 Connection::set_reuse_addr 0 1 42 55 /** * Sets whether local address reuse is allowed. */ 43 void Connection::set_reuse_addr(bool flag); 207 14 set_keep_alive 0 4 349 26 Connection::set_keep_alive 0 1 43 93 /** * Sets whether the connection is periodically tested to see if it is still * alive. */ 43 void Connection::set_keep_alive(bool flag); 208 20 set_recv_buffer_size 0 4 349 32 Connection::set_recv_buffer_size 0 1 44 57 /** * Sets the size of the receive buffer, in bytes. */ 48 void Connection::set_recv_buffer_size(int size); 209 20 set_send_buffer_size 0 4 349 32 Connection::set_send_buffer_size 0 1 45 54 /** * Sets the size of the send buffer, in bytes. */ 48 void Connection::set_send_buffer_size(int size); 210 19 set_ip_time_to_live 0 4 349 31 Connection::set_ip_time_to_live 0 1 46 32 /** * Sets IP time-to-live. */ 46 void Connection::set_ip_time_to_live(int ttl); 211 22 set_ip_type_of_service 0 4 349 34 Connection::set_ip_type_of_service 0 1 47 50 /** * Sets IP type-of-service and precedence. */ 49 void Connection::set_ip_type_of_service(int tos); 212 12 set_no_delay 0 4 349 24 Connection::set_no_delay 0 1 48 116 /** * 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); 213 15 set_max_segment 0 4 349 27 Connection::set_max_segment 0 1 49 41 /** * Sets the maximum segment size. */ 43 void Connection::set_max_segment(int size); 214 17 ~ConnectionReader 0 6 351 35 ConnectionReader::~ConnectionReader 0 0 10 /** * */ 50 virtual ConnectionReader::~ConnectionReader(void); 215 14 add_connection 0 4 351 32 ConnectionReader::add_connection 0 1 50 504 /** * 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); 216 17 remove_connection 0 4 351 35 ConnectionReader::remove_connection 0 1 51 264 /** * 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); 217 16 is_connection_ok 0 4 351 34 ConnectionReader::is_connection_ok 0 1 52 345 /** * 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); 218 4 poll 0 4 351 22 ConnectionReader::poll 0 1 53 328 /** * 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); 219 11 get_manager 0 4 351 29 ConnectionReader::get_manager 0 1 54 98 /** * Returns a pointer to the ConnectionManager object that serves this * ConnectionReader. */ 61 ConnectionManager *ConnectionReader::get_manager(void) const; 220 10 is_polling 0 4 351 28 ConnectionReader::is_polling 0 1 55 83 /** * Returns true if the reader is a polling reader, i.e. it has no threads. */ 53 inline bool ConnectionReader::is_polling(void) const; 221 15 get_num_threads 0 4 351 33 ConnectionReader::get_num_threads 0 1 56 84 /** * Returns the number of threads the ConnectionReader has been created with. */ 50 int ConnectionReader::get_num_threads(void) const; 222 12 set_raw_mode 0 4 351 30 ConnectionReader::set_raw_mode 0 1 57 314 /** * 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); 223 12 get_raw_mode 0 4 351 30 ConnectionReader::get_raw_mode 0 1 58 81 /** * Returns the current setting of the raw mode flag. See set_raw_mode(). */ 48 bool ConnectionReader::get_raw_mode(void) const; 224 19 set_tcp_header_size 0 4 351 37 ConnectionReader::set_tcp_header_size 0 1 59 270 /** * 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); 225 19 get_tcp_header_size 0 4 351 37 ConnectionReader::get_tcp_header_size 0 1 60 86 /** * Returns the current setting of TCP header size. See set_tcp_header_size(). */ 54 int ConnectionReader::get_tcp_header_size(void) const; 226 8 shutdown 0 4 351 26 ConnectionReader::shutdown 0 1 61 146 /** * 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); 227 19 ~ConnectionListener 0 4 352 39 ConnectionListener::~ConnectionListener 0 0 0 46 ConnectionListener::~ConnectionListener(void); 228 11 NetDatagram 0 4 353 24 NetDatagram::NetDatagram 0 3 62 63 64 130 /** * Constructs an empty datagram. */ /** * Constructs a datagram from an existing block of data. */ /** * */ /** * */ 192 NetDatagram::NetDatagram(void); NetDatagram::NetDatagram(void const *data, std::size_t size); NetDatagram::NetDatagram(Datagram const ©); NetDatagram::NetDatagram(NetDatagram const ©); 229 10 operator = 0 4 353 23 NetDatagram::operator = 0 2 65 66 0 106 void NetDatagram::operator =(Datagram const ©); void NetDatagram::operator =(NetDatagram const ©); 230 14 set_connection 0 4 353 27 NetDatagram::set_connection 0 1 67 72 /** * Specifies the socket to which the datagram should be written. */ 76 void NetDatagram::set_connection(PointerTo< Connection > const &connection); 231 14 get_connection 0 4 353 27 NetDatagram::get_connection 0 1 68 111 /** * 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; 232 11 set_address 0 4 353 24 NetDatagram::set_address 0 1 69 67 /** * Specifies the host to which the datagram should be sent. */ 57 void NetDatagram::set_address(NetAddress const &address); 233 11 get_address 0 4 353 24 NetDatagram::get_address 0 1 70 106 /** * 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; 234 14 get_class_type 0 4 353 27 NetDatagram::get_class_type 0 1 71 0 52 static TypeHandle NetDatagram::get_class_type(void); 235 12 ~NetDatagram 0 4 353 25 NetDatagram::~NetDatagram 0 0 0 32 NetDatagram::~NetDatagram(void); 236 17 ConnectionManager 0 4 355 36 ConnectionManager::ConnectionManager 0 1 72 10 /** * */ 43 ConnectionManager::ConnectionManager(void); 237 18 ~ConnectionManager 0 6 355 37 ConnectionManager::~ConnectionManager 0 0 10 /** * */ 52 virtual ConnectionManager::~ConnectionManager(void); 238 19 open_UDP_connection 0 4 355 38 ConnectionManager::open_UDP_connection 0 2 73 74 1047 /** * 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. */ /** * 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, * both IPv4 and IPv6. * * 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. */ 218 PointerTo< Connection > ConnectionManager::open_UDP_connection(uint16_t port = 0); PointerTo< Connection > ConnectionManager::open_UDP_connection(std::string const &hostname, uint16_t port, bool for_broadcast = false); 239 26 open_TCP_server_rendezvous 0 4 355 45 ConnectionManager::open_TCP_server_rendezvous 0 3 75 76 77 1436 /** * 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, both IPv4 and IPv6. * * backlog is the maximum length of the queue of pending connections. */ /** * 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. */ /** * 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. */ 337 PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(uint16_t port, int backlog); PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(std::string const &hostname, uint16_t port, int backlog); PointerTo< Connection > ConnectionManager::open_TCP_server_rendezvous(NetAddress const &address, int backlog); 240 26 open_TCP_client_connection 0 4 355 45 ConnectionManager::open_TCP_client_connection 0 2 78 79 323 /** * 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. */ /** * This is a shorthand version of the function to directly establish * communications to a named host and port. */ 244 PointerTo< Connection > ConnectionManager::open_TCP_client_connection(NetAddress const &address, int timeout_ms); PointerTo< Connection > ConnectionManager::open_TCP_client_connection(std::string const &hostname, uint16_t port, int timeout_ms); 241 16 close_connection 0 4 355 35 ConnectionManager::close_connection 0 1 80 693 /** * 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); 242 16 wait_for_readers 0 4 355 35 ConnectionManager::wait_for_readers 0 1 81 664 /** * 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); 243 13 get_host_name 0 4 355 32 ConnectionManager::get_host_name 0 1 82 145 /** * Returns the name of this particular machine on the network, if available, * or the empty string if the hostname cannot be determined. */ 58 static std::string ConnectionManager::get_host_name(void); 244 8 get_name 0 4 356 38 ConnectionManager::Interface::get_name 0 1 87 0 70 std::string const &ConnectionManager::Interface::get_name(void) const; 245 15 get_mac_address 0 4 356 45 ConnectionManager::Interface::get_mac_address 0 1 88 0 77 std::string const &ConnectionManager::Interface::get_mac_address(void) const; 246 6 has_ip 0 4 356 36 ConnectionManager::Interface::has_ip 0 1 89 0 54 bool ConnectionManager::Interface::has_ip(void) const; 247 6 get_ip 0 4 356 36 ConnectionManager::Interface::get_ip 0 1 90 0 67 NetAddress const &ConnectionManager::Interface::get_ip(void) const; 248 11 has_netmask 0 4 356 41 ConnectionManager::Interface::has_netmask 0 1 91 0 59 bool ConnectionManager::Interface::has_netmask(void) const; 249 11 get_netmask 0 4 356 41 ConnectionManager::Interface::get_netmask 0 1 92 0 72 NetAddress const &ConnectionManager::Interface::get_netmask(void) const; 250 13 has_broadcast 0 4 356 43 ConnectionManager::Interface::has_broadcast 0 1 93 0 61 bool ConnectionManager::Interface::has_broadcast(void) const; 251 13 get_broadcast 0 4 356 43 ConnectionManager::Interface::get_broadcast 0 1 94 0 74 NetAddress const &ConnectionManager::Interface::get_broadcast(void) const; 252 7 has_p2p 0 4 356 37 ConnectionManager::Interface::has_p2p 0 1 95 0 55 bool ConnectionManager::Interface::has_p2p(void) const; 253 7 get_p2p 0 4 356 37 ConnectionManager::Interface::get_p2p 0 1 96 0 68 NetAddress const &ConnectionManager::Interface::get_p2p(void) const; 254 6 output 0 4 356 36 ConnectionManager::Interface::output 0 1 97 10 /** * */ 67 void ConnectionManager::Interface::output(std::ostream &out) const; 255 9 Interface 0 4 356 39 ConnectionManager::Interface::Interface 0 1 86 0 95 inline ConnectionManager::Interface::Interface(ConnectionManager::Interface const &) = default; 256 10 ~Interface 0 4 356 40 ConnectionManager::Interface::~Interface 0 0 0 47 ConnectionManager::Interface::~Interface(void); 257 15 scan_interfaces 0 4 355 34 ConnectionManager::scan_interfaces 0 1 83 258 /** * 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); 258 18 get_num_interfaces 0 4 355 37 ConnectionManager::get_num_interfaces 0 1 84 140 /** * This returns the number of usable network interfaces detected on this * machine. See scan_interfaces() to repopulate this list. */ 56 std::size_t ConnectionManager::get_num_interfaces(void); 259 13 get_interface 0 4 355 32 ConnectionManager::get_interface 0 1 85 127 /** * Returns the nth usable network interface detected on this machine. * See scan_interfaces() to repopulate this list. */ 84 ConnectionManager::Interface const &ConnectionManager::get_interface(std::size_t n); 260 0 0 0 0 0 0 0 0 0 261 16 ConnectionWriter 0 4 360 34 ConnectionWriter::ConnectionWriter 0 1 98 224 /** * 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. */ 132 explicit ConnectionWriter::ConnectionWriter(ConnectionManager *manager, int num_threads, std::string const &thread_name = string()); 262 17 ~ConnectionWriter 0 4 360 35 ConnectionWriter::~ConnectionWriter 0 0 10 /** * */ 42 ConnectionWriter::~ConnectionWriter(void); 263 18 set_max_queue_size 0 4 360 36 ConnectionWriter::set_max_queue_size 0 1 99 192 /** * 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); 264 18 get_max_queue_size 0 4 360 36 ConnectionWriter::get_max_queue_size 0 1 100 98 /** * 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; 265 22 get_current_queue_size 0 4 360 40 ConnectionWriter::get_current_queue_size 0 1 101 61 /** * Returns the current number of things in the queue. */ 57 int ConnectionWriter::get_current_queue_size(void) const; 266 4 send 0 4 360 22 ConnectionWriter::send 0 2 102 103 1230 /** * 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. */ /** * 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. */ 262 bool ConnectionWriter::send(Datagram const &datagram, PointerTo< Connection > const &connection, bool block = false); bool ConnectionWriter::send(Datagram const &datagram, PointerTo< Connection > const &connection, NetAddress const &address, bool block = false); 267 16 is_valid_for_udp 0 4 360 34 ConnectionWriter::is_valid_for_udp 0 1 104 105 /** * 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; 268 11 get_manager 0 4 360 29 ConnectionWriter::get_manager 0 1 105 98 /** * Returns a pointer to the ConnectionManager object that serves this * ConnectionWriter. */ 61 ConnectionManager *ConnectionWriter::get_manager(void) const; 269 12 is_immediate 0 4 360 30 ConnectionWriter::is_immediate 0 1 106 86 /** * Returns true if the writer is an immediate writer, i.e. it has no threads. */ 48 bool ConnectionWriter::is_immediate(void) const; 270 15 get_num_threads 0 4 360 33 ConnectionWriter::get_num_threads 0 1 107 84 /** * Returns the number of threads the ConnectionWriter has been created with. */ 50 int ConnectionWriter::get_num_threads(void) const; 271 12 set_raw_mode 0 4 360 30 ConnectionWriter::set_raw_mode 0 1 108 455 /** * 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); 272 12 get_raw_mode 0 4 360 30 ConnectionWriter::get_raw_mode 0 1 109 81 /** * Returns the current setting of the raw mode flag. See set_raw_mode(). */ 48 bool ConnectionWriter::get_raw_mode(void) const; 273 19 set_tcp_header_size 0 4 360 37 ConnectionWriter::set_tcp_header_size 0 1 110 270 /** * 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); 274 19 get_tcp_header_size 0 4 360 37 ConnectionWriter::get_tcp_header_size 0 1 111 86 /** * Returns the current setting of TCP header size. See set_tcp_header_size(). */ 54 int ConnectionWriter::get_tcp_header_size(void) const; 275 8 shutdown 0 4 360 26 ConnectionWriter::shutdown 0 1 112 156 /** * 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); 276 27 upcast_to_DatagramGenerator 0 12 361 49 DatagramGeneratorNet::upcast_to_DatagramGenerator 0 1 117 53 upcast from DatagramGeneratorNet to DatagramGenerator 75 DatagramGenerator *DatagramGeneratorNet::upcast_to_DatagramGenerator(void); 277 32 downcast_to_DatagramGeneratorNet 0 12 362 51 DatagramGenerator::downcast_to_DatagramGeneratorNet 0 0 55 downcast from DatagramGenerator to DatagramGeneratorNet 80 DatagramGeneratorNet *DatagramGenerator::downcast_to_DatagramGeneratorNet(void); 278 26 upcast_to_ConnectionReader 0 12 361 48 DatagramGeneratorNet::upcast_to_ConnectionReader 0 1 118 52 upcast from DatagramGeneratorNet to ConnectionReader 73 ConnectionReader *DatagramGeneratorNet::upcast_to_ConnectionReader(void); 279 32 downcast_to_DatagramGeneratorNet 0 12 351 50 ConnectionReader::downcast_to_DatagramGeneratorNet 0 0 54 downcast from ConnectionReader to DatagramGeneratorNet 79 DatagramGeneratorNet *ConnectionReader::downcast_to_DatagramGeneratorNet(void); 280 18 set_max_queue_size 0 4 363 44 QueuedReturn< Datagram >::set_max_queue_size 0 1 120 0 64 void QueuedReturn< Datagram >::set_max_queue_size(int max_size); 281 18 get_max_queue_size 0 4 363 44 QueuedReturn< Datagram >::get_max_queue_size 0 1 121 0 61 int QueuedReturn< Datagram >::get_max_queue_size(void) const; 282 22 get_current_queue_size 0 4 363 48 QueuedReturn< Datagram >::get_current_queue_size 0 1 122 0 65 int QueuedReturn< Datagram >::get_current_queue_size(void) const; 283 17 get_overflow_flag 0 4 363 43 QueuedReturn< Datagram >::get_overflow_flag 0 1 123 0 61 bool QueuedReturn< Datagram >::get_overflow_flag(void) const; 284 19 reset_overflow_flag 0 4 363 45 QueuedReturn< Datagram >::reset_overflow_flag 0 1 124 0 57 void QueuedReturn< Datagram >::reset_overflow_flag(void); 285 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); 286 32 downcast_to_DatagramGeneratorNet 0 12 363 58 QueuedReturn< Datagram >::downcast_to_DatagramGeneratorNet 0 0 62 downcast from QueuedReturn< Datagram > to DatagramGeneratorNet 87 DatagramGeneratorNet *QueuedReturn< Datagram >::downcast_to_DatagramGeneratorNet(void); 287 20 DatagramGeneratorNet 0 4 361 42 DatagramGeneratorNet::DatagramGeneratorNet 0 1 113 243 /** * 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. */ 97 explicit DatagramGeneratorNet::DatagramGeneratorNet(ConnectionManager *manager, int num_threads); 288 21 ~DatagramGeneratorNet 0 6 361 43 DatagramGeneratorNet::~DatagramGeneratorNet 0 0 10 /** * */ 58 virtual DatagramGeneratorNet::~DatagramGeneratorNet(void); 289 12 get_datagram 0 6 361 34 DatagramGeneratorNet::get_datagram 0 1 114 189 // Inherited from DatagramGenerator /** * 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); 290 6 is_eof 0 6 361 28 DatagramGeneratorNet::is_eof 0 1 115 137 /** * 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); 291 8 is_error 0 6 361 30 DatagramGeneratorNet::is_error 0 1 116 61 /** * Returns true if the stream has an error condition. */ 50 virtual bool DatagramGeneratorNet::is_error(void); 292 22 upcast_to_DatagramSink 0 12 364 39 DatagramSinkNet::upcast_to_DatagramSink 0 1 131 43 upcast from DatagramSinkNet to DatagramSink 60 DatagramSink *DatagramSinkNet::upcast_to_DatagramSink(void); 293 27 downcast_to_DatagramSinkNet 0 12 365 41 DatagramSink::downcast_to_DatagramSinkNet 0 0 45 downcast from DatagramSink to DatagramSinkNet 65 DatagramSinkNet *DatagramSink::downcast_to_DatagramSinkNet(void); 294 26 upcast_to_ConnectionWriter 0 12 364 43 DatagramSinkNet::upcast_to_ConnectionWriter 0 1 132 47 upcast from DatagramSinkNet to ConnectionWriter 68 ConnectionWriter *DatagramSinkNet::upcast_to_ConnectionWriter(void); 295 27 downcast_to_DatagramSinkNet 0 12 360 45 ConnectionWriter::downcast_to_DatagramSinkNet 0 0 49 downcast from ConnectionWriter to DatagramSinkNet 69 DatagramSinkNet *ConnectionWriter::downcast_to_DatagramSinkNet(void); 296 15 DatagramSinkNet 0 4 364 32 DatagramSinkNet::DatagramSinkNet 0 1 125 233 /** * 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. */ 87 explicit DatagramSinkNet::DatagramSinkNet(ConnectionManager *manager, int num_threads); 297 10 set_target 0 4 364 27 DatagramSinkNet::set_target 0 1 126 80 /** * Specifies the Connection that will receive all future Datagrams sent. */ 64 inline void DatagramSinkNet::set_target(Connection *connection); 298 10 get_target 0 4 364 27 DatagramSinkNet::get_target 0 1 127 115 /** * 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; 299 12 put_datagram 0 6 364 29 DatagramSinkNet::put_datagram 0 1 128 187 // Inherited from DatagramSink /** * 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); 300 8 is_error 0 6 364 25 DatagramSinkNet::is_error 0 1 129 110 /** * 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); 301 5 flush 0 6 364 22 DatagramSinkNet::flush 0 1 130 90 /** * Ensures that all datagrams previously written will be visible on the * stream. */ 42 virtual void DatagramSinkNet::flush(void); 302 16 ~DatagramSinkNet 0 4 364 33 DatagramSinkNet::~DatagramSinkNet 0 0 0 40 DatagramSinkNet::~DatagramSinkNet(void); 303 28 upcast_to_ConnectionListener 0 12 366 54 QueuedConnectionListener::upcast_to_ConnectionListener 0 1 137 58 upcast from QueuedConnectionListener to ConnectionListener 81 ConnectionListener *QueuedConnectionListener::upcast_to_ConnectionListener(void); 304 36 downcast_to_QueuedConnectionListener 0 12 352 56 ConnectionListener::downcast_to_QueuedConnectionListener 0 0 60 downcast from ConnectionListener to QueuedConnectionListener 89 QueuedConnectionListener *ConnectionListener::downcast_to_QueuedConnectionListener(void); 305 18 set_max_queue_size 0 4 367 58 QueuedReturn< ConnectionListenerData >::set_max_queue_size 0 1 139 0 78 void QueuedReturn< ConnectionListenerData >::set_max_queue_size(int max_size); 306 18 get_max_queue_size 0 4 367 58 QueuedReturn< ConnectionListenerData >::get_max_queue_size 0 1 140 0 75 int QueuedReturn< ConnectionListenerData >::get_max_queue_size(void) const; 307 22 get_current_queue_size 0 4 367 62 QueuedReturn< ConnectionListenerData >::get_current_queue_size 0 1 141 0 79 int QueuedReturn< ConnectionListenerData >::get_current_queue_size(void) const; 308 17 get_overflow_flag 0 4 367 57 QueuedReturn< ConnectionListenerData >::get_overflow_flag 0 1 142 0 75 bool QueuedReturn< ConnectionListenerData >::get_overflow_flag(void) const; 309 19 reset_overflow_flag 0 4 367 59 QueuedReturn< ConnectionListenerData >::reset_overflow_flag 0 1 143 0 71 void QueuedReturn< ConnectionListenerData >::reset_overflow_flag(void); 310 45 upcast_to_QueuedReturn_ConnectionListenerData 0 12 366 71 QueuedConnectionListener::upcast_to_QueuedReturn_ConnectionListenerData 0 1 138 78 upcast from QueuedConnectionListener to QueuedReturn< ConnectionListenerData > 118 QueuedReturn< ConnectionListenerData > *QueuedConnectionListener::upcast_to_QueuedReturn_ConnectionListenerData(void); 311 36 downcast_to_QueuedConnectionListener 0 12 367 76 QueuedReturn< ConnectionListenerData >::downcast_to_QueuedConnectionListener 0 0 80 downcast from QueuedReturn< ConnectionListenerData > to QueuedConnectionListener 109 QueuedConnectionListener *QueuedReturn< ConnectionListenerData >::downcast_to_QueuedConnectionListener(void); 312 24 QueuedConnectionListener 0 4 366 50 QueuedConnectionListener::QueuedConnectionListener 0 1 133 10 /** * */ 105 explicit QueuedConnectionListener::QueuedConnectionListener(ConnectionManager *manager, int num_threads); 313 25 ~QueuedConnectionListener 0 6 366 51 QueuedConnectionListener::~QueuedConnectionListener 0 0 10 /** * */ 66 virtual QueuedConnectionListener::~QueuedConnectionListener(void); 314 24 new_connection_available 0 4 366 50 QueuedConnectionListener::new_connection_available 0 1 134 147 /** * 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); 315 18 get_new_connection 0 4 366 44 QueuedConnectionListener::get_new_connection 0 2 135 136 935 /** * 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). */ /** * 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); 316 27 upcast_to_ConnectionManager 0 12 368 52 QueuedConnectionManager::upcast_to_ConnectionManager 0 1 147 56 upcast from QueuedConnectionManager to ConnectionManager 78 ConnectionManager *QueuedConnectionManager::upcast_to_ConnectionManager(void); 317 35 downcast_to_QueuedConnectionManager 0 12 355 54 ConnectionManager::downcast_to_QueuedConnectionManager 0 0 58 downcast from ConnectionManager to QueuedConnectionManager 86 QueuedConnectionManager *ConnectionManager::downcast_to_QueuedConnectionManager(void); 318 18 set_max_queue_size 0 4 369 59 QueuedReturn< PointerTo< Connection > >::set_max_queue_size 0 1 149 0 79 void QueuedReturn< PointerTo< Connection > >::set_max_queue_size(int max_size); 319 18 get_max_queue_size 0 4 369 59 QueuedReturn< PointerTo< Connection > >::get_max_queue_size 0 1 150 0 76 int QueuedReturn< PointerTo< Connection > >::get_max_queue_size(void) const; 320 22 get_current_queue_size 0 4 369 63 QueuedReturn< PointerTo< Connection > >::get_current_queue_size 0 1 151 0 80 int QueuedReturn< PointerTo< Connection > >::get_current_queue_size(void) const; 321 17 get_overflow_flag 0 4 369 58 QueuedReturn< PointerTo< Connection > >::get_overflow_flag 0 1 152 0 76 bool QueuedReturn< PointerTo< Connection > >::get_overflow_flag(void) const; 322 19 reset_overflow_flag 0 4 369 60 QueuedReturn< PointerTo< Connection > >::reset_overflow_flag 0 1 153 0 72 void QueuedReturn< PointerTo< Connection > >::reset_overflow_flag(void); 323 43 upcast_to_QueuedReturn_PointerTo_Connection 0 12 368 68 QueuedConnectionManager::upcast_to_QueuedReturn_PointerTo_Connection 0 1 148 78 upcast from QueuedConnectionManager to QueuedReturn< PointerTo< Connection > > 116 QueuedReturn< PointerTo< Connection > > *QueuedConnectionManager::upcast_to_QueuedReturn_PointerTo_Connection(void); 324 35 downcast_to_QueuedConnectionManager 0 12 369 76 QueuedReturn< PointerTo< Connection > >::downcast_to_QueuedConnectionManager 0 0 80 downcast from QueuedReturn< PointerTo< Connection > > to QueuedConnectionManager 108 QueuedConnectionManager *QueuedReturn< PointerTo< Connection > >::downcast_to_QueuedConnectionManager(void); 325 23 QueuedConnectionManager 0 4 368 48 QueuedConnectionManager::QueuedConnectionManager 0 1 144 10 /** * */ 55 QueuedConnectionManager::QueuedConnectionManager(void); 326 24 ~QueuedConnectionManager 0 6 368 49 QueuedConnectionManager::~QueuedConnectionManager 0 0 10 /** * */ 64 virtual QueuedConnectionManager::~QueuedConnectionManager(void); 327 26 reset_connection_available 0 4 368 51 QueuedConnectionManager::reset_connection_available 0 1 145 631 /** * 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; 328 20 get_reset_connection 0 4 368 45 QueuedConnectionManager::get_reset_connection 0 1 146 797 /** * 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); 329 26 upcast_to_ConnectionReader 0 12 370 50 QueuedConnectionReader::upcast_to_ConnectionReader 0 1 158 54 upcast from QueuedConnectionReader to ConnectionReader 75 ConnectionReader *QueuedConnectionReader::upcast_to_ConnectionReader(void); 330 34 downcast_to_QueuedConnectionReader 0 12 351 52 ConnectionReader::downcast_to_QueuedConnectionReader 0 0 56 downcast from ConnectionReader to QueuedConnectionReader 83 QueuedConnectionReader *ConnectionReader::downcast_to_QueuedConnectionReader(void); 331 18 set_max_queue_size 0 4 371 47 QueuedReturn< NetDatagram >::set_max_queue_size 0 1 160 0 67 void QueuedReturn< NetDatagram >::set_max_queue_size(int max_size); 332 18 get_max_queue_size 0 4 371 47 QueuedReturn< NetDatagram >::get_max_queue_size 0 1 161 0 64 int QueuedReturn< NetDatagram >::get_max_queue_size(void) const; 333 22 get_current_queue_size 0 4 371 51 QueuedReturn< NetDatagram >::get_current_queue_size 0 1 162 0 68 int QueuedReturn< NetDatagram >::get_current_queue_size(void) const; 334 17 get_overflow_flag 0 4 371 46 QueuedReturn< NetDatagram >::get_overflow_flag 0 1 163 0 64 bool QueuedReturn< NetDatagram >::get_overflow_flag(void) const; 335 19 reset_overflow_flag 0 4 371 48 QueuedReturn< NetDatagram >::reset_overflow_flag 0 1 164 0 60 void QueuedReturn< NetDatagram >::reset_overflow_flag(void); 336 34 upcast_to_QueuedReturn_NetDatagram 0 12 370 58 QueuedConnectionReader::upcast_to_QueuedReturn_NetDatagram 0 1 159 65 upcast from QueuedConnectionReader to QueuedReturn< NetDatagram > 94 QueuedReturn< NetDatagram > *QueuedConnectionReader::upcast_to_QueuedReturn_NetDatagram(void); 337 34 downcast_to_QueuedConnectionReader 0 12 371 63 QueuedReturn< NetDatagram >::downcast_to_QueuedConnectionReader 0 0 67 downcast from QueuedReturn< NetDatagram > to QueuedConnectionReader 94 QueuedConnectionReader *QueuedReturn< NetDatagram >::downcast_to_QueuedConnectionReader(void); 338 22 QueuedConnectionReader 0 4 370 46 QueuedConnectionReader::QueuedConnectionReader 0 1 154 10 /** * */ 101 explicit QueuedConnectionReader::QueuedConnectionReader(ConnectionManager *manager, int num_threads); 339 23 ~QueuedConnectionReader 0 6 370 47 QueuedConnectionReader::~QueuedConnectionReader 0 0 10 /** * */ 62 virtual QueuedConnectionReader::~QueuedConnectionReader(void); 340 14 data_available 0 4 370 38 QueuedConnectionReader::data_available 0 1 155 108 /** * Returns true if a datagram is available on the queue; call get_data() to * extract the datagram. */ 50 bool QueuedConnectionReader::data_available(void); 341 8 get_data 0 4 370 32 QueuedConnectionReader::get_data 0 2 156 157 650 /** * 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). */ /** * 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); 342 22 RecentConnectionReader 0 4 372 46 RecentConnectionReader::RecentConnectionReader 0 1 165 10 /** * */ 84 explicit RecentConnectionReader::RecentConnectionReader(ConnectionManager *manager); 343 14 data_available 0 4 372 38 RecentConnectionReader::data_available 0 1 166 108 /** * Returns true if a datagram is available on the queue; call get_data() to * extract the datagram. */ 50 bool RecentConnectionReader::data_available(void); 344 8 get_data 0 4 372 32 RecentConnectionReader::get_data 0 2 167 168 650 /** * 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). */ /** * 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); 168 1 0 0 7 6 373 176 0 0 0 2 0 0 7 6 373 176 0 0 1 3 ptr 1 374 3 0 0 7 6 373 176 0 0 1 4 copy 1 374 4 0 0 7 6 373 176 0 0 1 6 param0 0 375 5 0 0 7 7 374 0 0 289 // 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 376 6 0 0 6 8 373 0 0 0 2 4 this 3 373 3 ptr 1 374 7 0 0 6 8 373 0 0 0 2 4 this 3 373 4 copy 1 374 8 0 0 6 9 378 0 0 0 1 4 this 3 376 9 0 0 4 10 379 0 0 0 1 4 this 3 373 10 0 0 4 4 379 0 0 0 1 4 this 3 380 11 0 0 4 5 379 0 0 0 2 4 this 3 381 3 out 1 383 12 0 0 7 13 385 194 0 45 /** * Constructs an unspecified address. */ 0 13 0 0 7 13 385 194 0 0 1 6 param0 0 386 14 0 0 7 13 385 194 0 224 /** * 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 388 15 0 0 6 14 378 0 0 179 /** * 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 385 4 port 1 391 16 0 0 6 15 378 0 0 75 /** * Sets the address up to refer to a particular port, on this host. */ 2 4 this 3 385 4 port 1 391 17 0 0 6 16 378 0 0 53 /** * Sets the address to the broadcast address. */ 2 4 this 3 385 4 port 1 391 18 0 0 6 17 378 0 0 141 /** * 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 385 8 hostname 1 392 4 port 1 391 19 0 0 4 18 379 0 0 54 /** * Resets the NetAddress to its initial state. */ 1 4 this 3 385 20 0 0 6 19 391 0 0 64 /** * Returns the port number to which this address refers. */ 1 4 this 3 386 21 0 0 4 20 379 0 0 73 /** * Resets the port number without otherwise changing the address. */ 2 4 this 3 385 4 port 1 391 22 0 0 6 21 392 0 0 86 /** * Returns the IP address to which this address refers, formatted as a string. */ 1 4 this 3 386 23 0 0 6 22 378 0 0 58 /** * Returns true if the IP address has only zeroes. */ 1 4 this 3 386 24 0 0 6 23 393 0 0 158 /** * Returns the IP address to which this address refers, as a 32-bit integer, * in host byte order. * @deprecated Does not work with IPv6 addresses. */ 1 4 this 3 386 25 0 0 6 24 395 0 0 213 /** * 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 386 1 n 1 391 26 0 0 6 25 388 0 0 55 /** * Returns the Socket_Address for this address. */ 1 4 this 3 386 27 0 0 4 26 379 0 0 10 /** * */ 2 4 this 3 386 3 out 1 383 28 0 0 6 27 397 0 0 10 /** * */ 1 4 this 3 386 29 0 0 6 28 378 0 0 0 2 4 this 3 386 5 other 1 386 30 0 0 6 29 378 0 0 0 2 4 this 3 386 5 other 1 386 31 0 0 7 33 374 0 0 177 /** * 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 399 6 socket 1 400 32 0 0 7 34 385 194 0 83 /** * Returns the address bound to this connection, if it is a TCP connection. */ 1 4 this 3 402 33 0 0 6 35 399 0 0 92 /** * Returns a pointer to the ConnectionManager object that serves this * connection. */ 1 4 this 3 402 34 0 0 6 36 400 0 0 70 /** * Returns the internal Socket_IP that defines the connection. */ 1 4 this 3 402 35 0 0 4 37 379 0 0 719 /** * 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 374 11 collect_tcp 1 378 36 0 0 6 38 378 0 0 85 /** * Returns the current setting of "collect-tcp" mode. See set_collect_tcp(). */ 1 4 this 3 402 37 0 0 4 39 379 0 0 231 /** * 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 374 8 interval 1 404 38 0 0 6 40 404 0 0 229 /** * 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 402 39 0 0 6 41 378 0 0 153 /** * 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 374 40 0 0 6 42 378 0 0 131 /** * 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 374 41 0 0 4 43 379 0 0 416 /** * 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 374 4 flag 1 378 4 time 1 404 42 0 0 4 44 379 0 0 55 /** * Sets whether local address reuse is allowed. */ 2 4 this 3 374 4 flag 1 378 43 0 0 4 45 379 0 0 93 /** * Sets whether the connection is periodically tested to see if it is still * alive. */ 2 4 this 3 374 4 flag 1 378 44 0 0 4 46 379 0 0 57 /** * Sets the size of the receive buffer, in bytes. */ 2 4 this 3 374 4 size 1 391 45 0 0 4 47 379 0 0 54 /** * Sets the size of the send buffer, in bytes. */ 2 4 this 3 374 4 size 1 391 46 0 0 4 48 379 0 0 32 /** * Sets IP time-to-live. */ 2 4 this 3 374 3 ttl 1 391 47 0 0 4 49 379 0 0 50 /** * Sets IP type-of-service and precedence. */ 2 4 this 3 374 3 tos 1 391 48 0 0 4 50 379 0 0 116 /** * If flag is true, this disables the Nagle algorithm, and prevents delaying * of send to coalesce packets. */ 2 4 this 3 374 4 flag 1 378 49 0 0 4 51 379 0 0 41 /** * Sets the maximum segment size. */ 2 4 this 3 374 4 size 1 391 50 0 0 6 54 378 0 0 504 /** * 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 405 10 connection 1 374 51 0 0 6 55 378 0 0 264 /** * 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 405 10 connection 1 374 52 0 0 6 56 378 0 0 345 /** * 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 405 10 connection 1 374 53 0 0 4 57 379 0 0 328 /** * 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 405 54 0 0 6 58 399 0 0 98 /** * Returns a pointer to the ConnectionManager object that serves this * ConnectionReader. */ 1 4 this 3 406 55 0 0 6 59 378 0 0 83 /** * Returns true if the reader is a polling reader, i.e. it has no threads. */ 1 4 this 3 406 56 0 0 6 60 391 0 0 84 /** * Returns the number of threads the ConnectionReader has been created with. */ 1 4 this 3 406 57 0 0 4 61 379 0 0 314 /** * 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 405 4 mode 1 378 58 0 0 6 62 378 0 0 81 /** * Returns the current setting of the raw mode flag. See set_raw_mode(). */ 1 4 this 3 406 59 0 0 4 63 379 0 0 270 /** * 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 405 15 tcp_header_size 1 391 60 0 0 6 64 391 0 0 86 /** * Returns the current setting of TCP header size. See set_tcp_header_size(). */ 1 4 this 3 406 61 0 0 4 65 379 0 0 146 /** * Terminates all threads cleanly. Normally this is only called by the * destructor, but it may be called explicitly before destruction. */ 1 4 this 3 405 62 0 0 7 70 408 235 0 40 /** * Constructs an empty datagram. */ 0 63 0 0 7 70 408 235 0 10 /** * */ 1 4 copy 1 409 64 0 0 7 70 408 235 0 10 /** * */ 1 4 copy 1 411 65 0 0 6 71 408 0 0 0 2 4 this 3 408 4 copy 1 409 66 0 0 6 71 408 0 0 0 2 4 this 3 408 4 copy 1 411 67 0 0 4 72 379 0 0 72 /** * Specifies the socket to which the datagram should be written. */ 2 4 this 3 408 10 connection 1 374 68 0 0 7 73 374 0 0 111 /** * Retrieves the socket from which the datagram was read, or to which it is * scheduled to be written. */ 1 4 this 3 411 69 0 0 4 74 379 0 0 67 /** * Specifies the host to which the datagram should be sent. */ 2 4 this 3 408 7 address 1 386 70 0 0 6 75 386 0 0 106 /** * Retrieves the host from which the datagram was read, or to which it is * scheduled to be sent. */ 1 4 this 3 411 71 0 0 7 76 414 0 0 0 0 72 0 0 7 79 399 237 0 10 /** * */ 0 73 0 0 7 81 374 0 0 720 /** * 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, * both IPv4 and IPv6. * * 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 399 8 hostname 1 392 4 port 1 415 13 for_broadcast 1 378 74 0 0 7 81 374 0 0 325 /** * 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 399 4 port 1 415 75 0 0 7 82 374 0 0 422 /** * 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 399 7 address 1 386 7 backlog 1 391 76 0 0 7 82 374 0 0 572 /** * 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 399 8 hostname 1 392 4 port 1 415 7 backlog 1 391 77 0 0 7 82 374 0 0 438 /** * 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, both IPv4 and IPv6. * * backlog is the maximum length of the queue of pending connections. */ 3 4 this 3 399 4 port 1 415 7 backlog 1 391 78 0 0 7 83 374 0 0 201 /** * 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 399 7 address 1 386 10 timeout_ms 1 391 79 0 0 7 83 374 0 0 120 /** * This is a shorthand version of the function to directly establish * communications to a named host and port. */ 4 4 this 3 399 8 hostname 1 392 4 port 1 415 10 timeout_ms 1 391 80 0 0 6 84 378 0 0 693 /** * 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 399 10 connection 1 374 81 0 0 6 85 378 0 0 664 /** * 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 399 7 timeout 1 404 82 0 0 6 86 392 0 0 145 /** * Returns the name of this particular machine on the network, if available, * or the empty string if the hostname cannot be determined. */ 0 83 0 0 4 101 379 0 0 258 /** * 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 399 84 0 0 6 102 397 0 0 140 /** * This returns the number of usable network interfaces detected on this * machine. See scan_interfaces() to repopulate this list. */ 1 4 this 3 399 85 0 0 6 103 417 0 0 127 /** * Returns the nth usable network interface detected on this machine. * See scan_interfaces() to repopulate this list. */ 2 4 this 3 399 1 n 1 397 86 0 0 7 99 418 256 0 0 1 6 param0 0 417 87 0 0 6 88 392 0 0 0 1 4 this 3 417 88 0 0 6 89 392 0 0 0 1 4 this 3 417 89 0 0 6 90 378 0 0 0 1 4 this 3 417 90 0 0 6 91 386 0 0 0 1 4 this 3 417 91 0 0 6 92 378 0 0 0 1 4 this 3 417 92 0 0 6 93 386 0 0 0 1 4 this 3 417 93 0 0 6 94 378 0 0 0 1 4 this 3 417 94 0 0 6 95 386 0 0 0 1 4 this 3 417 95 0 0 6 96 378 0 0 0 1 4 this 3 417 96 0 0 6 97 386 0 0 0 1 4 this 3 417 97 0 0 4 98 379 0 0 10 /** * */ 2 4 this 3 417 3 out 1 383 98 0 0 7 112 419 262 0 224 /** * 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 399 11 num_threads 1 391 11 thread_name 1 392 99 0 0 4 114 379 0 0 192 /** * 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 419 8 max_size 1 391 100 0 0 6 115 391 0 0 98 /** * Returns the maximum size the queue is allowed to grow to. See * set_max_queue_size(). */ 1 4 this 3 420 101 0 0 6 116 391 0 0 61 /** * Returns the current number of things in the queue. */ 1 4 this 3 420 102 0 0 6 117 378 0 0 617 /** * 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 419 8 datagram 1 409 10 connection 1 374 7 address 1 386 5 block 1 378 103 0 0 6 117 378 0 0 611 /** * 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 419 8 datagram 1 409 10 connection 1 374 5 block 1 378 104 0 0 6 118 378 0 0 105 /** * Returns true if the datagram is small enough to be sent over a UDP packet, * false otherwise. */ 2 4 this 3 420 8 datagram 1 409 105 0 0 6 119 399 0 0 98 /** * Returns a pointer to the ConnectionManager object that serves this * ConnectionWriter. */ 1 4 this 3 420 106 0 0 6 120 378 0 0 86 /** * Returns true if the writer is an immediate writer, i.e. it has no threads. */ 1 4 this 3 420 107 0 0 6 121 391 0 0 84 /** * Returns the number of threads the ConnectionWriter has been created with. */ 1 4 this 3 420 108 0 0 4 122 379 0 0 455 /** * 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 419 4 mode 1 378 109 0 0 6 123 378 0 0 81 /** * Returns the current setting of the raw mode flag. See set_raw_mode(). */ 1 4 this 3 420 110 0 0 4 124 379 0 0 270 /** * 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 419 15 tcp_header_size 1 391 111 0 0 6 125 391 0 0 86 /** * Returns the current setting of TCP header size. See set_tcp_header_size(). */ 1 4 this 3 420 112 0 0 4 126 379 0 0 156 /** * 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 419 113 0 0 7 141 422 288 0 243 /** * 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 399 11 num_threads 1 391 114 0 0 6 143 378 0 0 152 /** * 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 422 4 data 1 423 115 0 0 6 144 378 0 0 137 /** * 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 422 116 0 0 6 145 378 0 0 61 /** * Returns true if the stream has an error condition. */ 1 4 this 3 422 117 0 0 6 129 424 0 0 0 1 4 this 3 422 118 0 0 6 131 405 0 0 0 1 4 this 3 422 119 0 0 6 139 425 0 0 0 1 4 this 3 422 120 0 0 4 134 379 0 0 0 2 4 this 3 425 8 max_size 1 391 121 0 0 6 135 391 0 0 0 1 4 this 3 426 122 0 0 6 136 391 0 0 0 1 4 this 3 426 123 0 0 6 137 378 0 0 0 1 4 this 3 426 124 0 0 4 138 379 0 0 0 1 4 this 3 425 125 0 0 7 152 428 302 0 233 /** * 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 399 11 num_threads 1 391 126 0 0 4 153 379 0 0 80 /** * Specifies the Connection that will receive all future Datagrams sent. */ 2 4 this 3 428 10 connection 1 374 127 0 0 7 154 374 0 0 115 /** * Returns the current target Connection, or NULL if the target has not yet * been set. See set_target(). */ 1 4 this 3 429 128 0 0 6 155 378 0 0 155 /** * 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 428 4 data 1 409 129 0 0 6 156 378 0 0 110 /** * Returns true if there is an error on the target connection, or if the * target has never been set. */ 1 4 this 3 428 130 0 0 4 157 379 0 0 90 /** * Ensures that all datagrams previously written will be visible on the * stream. */ 1 4 this 3 428 131 0 0 6 148 431 0 0 0 1 4 this 3 428 132 0 0 6 150 419 0 0 0 1 4 this 3 428 133 0 0 7 170 432 313 0 10 /** * */ 2 7 manager 1 399 11 num_threads 1 391 134 0 0 6 172 378 0 0 147 /** * Returns true if a new connection was recently established; the connection * information may then be retrieved via get_new_connection(). */ 1 4 this 3 432 135 0 0 6 173 378 0 0 192 /** * 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 432 14 new_connection 1 373 136 0 0 6 173 378 0 0 741 /** * 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 432 10 rendezvous 1 373 7 address 1 385 14 new_connection 1 373 137 0 0 6 160 433 0 0 0 1 4 this 3 432 138 0 0 6 168 434 0 0 0 1 4 this 3 432 139 0 0 4 163 379 0 0 0 2 4 this 3 434 8 max_size 1 391 140 0 0 6 164 391 0 0 0 1 4 this 3 435 141 0 0 6 165 391 0 0 0 1 4 this 3 435 142 0 0 6 166 378 0 0 0 1 4 this 3 435 143 0 0 4 167 379 0 0 0 1 4 this 3 434 144 0 0 7 185 437 326 0 10 /** * */ 0 145 0 0 6 187 378 0 0 631 /** * 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 438 146 0 0 6 188 378 0 0 797 /** * 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 437 10 connection 1 373 147 0 0 6 175 399 0 0 0 1 4 this 3 437 148 0 0 6 183 440 0 0 0 1 4 this 3 437 149 0 0 4 178 379 0 0 0 2 4 this 3 440 8 max_size 1 391 150 0 0 6 179 391 0 0 0 1 4 this 3 441 151 0 0 6 180 391 0 0 0 1 4 this 3 441 152 0 0 6 181 378 0 0 0 1 4 this 3 441 153 0 0 4 182 379 0 0 0 1 4 this 3 440 154 0 0 7 200 443 339 0 10 /** * */ 2 7 manager 1 399 11 num_threads 1 391 155 0 0 6 202 378 0 0 108 /** * Returns true if a datagram is available on the queue; call get_data() to * extract the datagram. */ 1 4 this 3 443 156 0 0 6 203 378 0 0 295 /** * 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 443 6 result 1 423 157 0 0 6 203 378 0 0 353 /** * 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 443 6 result 1 408 158 0 0 6 190 405 0 0 0 1 4 this 3 443 159 0 0 6 198 444 0 0 0 1 4 this 3 443 160 0 0 4 193 379 0 0 0 2 4 this 3 444 8 max_size 1 391 161 0 0 6 194 391 0 0 0 1 4 this 3 445 162 0 0 6 195 391 0 0 0 1 4 this 3 445 163 0 0 6 196 378 0 0 0 1 4 this 3 445 164 0 0 4 197 379 0 0 0 1 4 this 3 444 165 0 0 7 205 447 214 0 10 /** * */ 1 7 manager 1 399 166 0 0 6 206 378 0 0 108 /** * Returns true if a datagram is available on the queue; call get_data() to * extract the datagram. */ 1 4 this 3 447 167 0 0 6 207 378 0 0 295 /** * 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 447 6 result 1 423 168 0 0 6 207 378 0 0 353 /** * 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 447 6 result 1 408 103 345 23 PointerTo< Connection > 0 141313 23 PointerTo< Connection > 23 PointerTo< Connection > 0 0 0 1 171 176 0 4 172 173 174 175 0 0 1 0 346 0 0 0 0 0 346 27 PointerToBase< Connection > 0 43009 27 PointerToBase< Connection > 27 PointerToBase< Connection > 0 0 0 0 0 0 2 169 170 0 0 1 0 347 0 0 0 0 0 347 13 PointerToVoid 0 2048 13 PointerToVoid 13 PointerToVoid 0 0 0 0 0 0 0 0 0 0 0 0 373 /** * 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. */ 348 10 NetAddress 0 141313 10 NetAddress 10 NetAddress 0 0 0 1 177 194 0 16 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 0 0 0 0 0 114 /** * Represents a network address to which UDP packets may be sent or to which a * TCP socket may be bound. */ 349 10 Connection 0 75777 10 Connection 10 Connection 0 0 0 1 195 0 0 18 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 0 0 1 0 350 0 0 0 0 69 /** * Represents a single TCP or UDP socket for input or output. */ 350 14 ReferenceCount 0 2048 14 ReferenceCount 14 ReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 203 /** * 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. */ 351 16 ConnectionReader 0 26625 16 ConnectionReader 16 ConnectionReader 0 0 0 0 214 0 12 215 216 217 218 219 220 221 222 223 224 225 226 0 0 0 0 0 844 /** * 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. */ 352 18 ConnectionListener 0 141313 18 ConnectionListener 18 ConnectionListener 0 0 0 0 227 0 0 0 0 1 0 351 0 0 0 0 339 /** * 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. */ 353 11 NetDatagram 0 141313 11 NetDatagram 11 NetDatagram 0 0 0 1 228 235 0 6 229 230 231 232 233 234 0 0 1 0 354 0 0 0 0 219 /** * 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. */ 354 8 Datagram 0 2048 8 Datagram 8 Datagram 0 0 0 0 0 0 0 0 0 0 0 0 565 /** * 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. */ 355 17 ConnectionManager 0 26625 17 ConnectionManager 17 ConnectionManager 0 0 0 1 236 237 2 448 449 9 238 239 240 241 242 243 257 258 259 1 450 0 0 0 1 356 573 /** * 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). */ 356 9 Interface 0 403457 28 ConnectionManager::Interface 28 ConnectionManager::Interface 355 0 0 1 255 256 0 11 244 245 246 247 248 249 250 251 252 253 254 0 0 0 0 0 0 357 6 string 0 2105344 11 std::string 11 std::string 0 0 358 0 0 0 0 0 0 0 0 0 0 358 20 basic_string< char > 0 2048 25 std::basic_string< char > 25 std::basic_string< char > 0 0 0 0 0 0 0 0 0 0 0 0 0 359 15 Interface const 0 8832 34 ConnectionManager::Interface const 34 ConnectionManager::Interface const 0 0 356 0 0 0 0 0 0 0 0 0 0 360 16 ConnectionWriter 0 26625 16 ConnectionWriter 16 ConnectionWriter 0 0 0 1 261 262 0 13 263 264 265 266 267 268 269 270 271 272 273 274 275 0 0 0 0 0 294 /** * 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 287 288 0 3 289 290 291 0 0 3 3 362 276 277 3 351 278 279 3 363 285 286 0 0 186 /** * 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 2048 17 DatagramGenerator 17 DatagramGenerator 0 0 0 0 0 0 0 0 0 0 0 0 125 /** * 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 280 281 282 283 284 0 0 0 0 0 0 364 15 DatagramSinkNet 0 141313 15 DatagramSinkNet 15 DatagramSinkNet 0 0 0 1 296 302 0 5 297 298 299 300 301 0 0 2 3 365 292 293 3 360 294 295 0 0 107 /** * This class accepts datagrams one-at-a-time and sends them over the net, via * a TCP connection. */ 365 12 DatagramSink 0 2048 12 DatagramSink 12 DatagramSink 0 0 0 0 0 0 0 0 0 0 0 0 135 /** * 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 312 313 0 2 314 315 0 0 2 3 352 303 304 3 367 310 311 0 0 143 /** * 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 305 306 307 308 309 0 0 0 0 0 0 368 23 QueuedConnectionManager 0 26625 23 QueuedConnectionManager 23 QueuedConnectionManager 0 0 0 1 325 326 0 2 327 328 0 0 2 3 355 316 317 3 369 323 324 0 0 423 /** * 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 318 319 320 321 322 0 0 0 0 0 0 370 22 QueuedConnectionReader 0 26625 22 QueuedConnectionReader 22 QueuedConnectionReader 0 0 0 1 338 339 0 2 340 341 0 0 2 3 351 329 330 3 371 336 337 0 0 291 /** * 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 331 332 333 334 335 0 0 0 0 0 0 372 22 RecentConnectionReader 0 75777 22 RecentConnectionReader 22 RecentConnectionReader 0 0 0 1 342 214 0 2 343 344 0 0 1 0 351 0 0 0 0 430 /** * 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 25 PointerTo< Connection > * 0 8576 25 PointerTo< Connection > * 25 PointerTo< Connection > * 0 0 345 0 0 0 0 0 0 0 0 0 0 374 12 Connection * 0 8576 12 Connection * 12 Connection * 0 0 349 0 0 0 0 0 0 0 0 0 0 375 17 decltype(nullptr) 0 8194 17 decltype(nullptr) 17 decltype(nullptr) 0 9 0 0 0 0 0 0 0 0 0 0 0 376 31 PointerTo< Connection > const * 0 8576 31 PointerTo< Connection > const * 31 PointerTo< Connection > const * 0 0 377 0 0 0 0 0 0 0 0 0 0 377 29 PointerTo< Connection > const 0 8832 29 PointerTo< Connection > const 29 PointerTo< Connection > const 0 0 345 0 0 0 0 0 0 0 0 0 0 378 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0 379 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0 380 29 PointerToBase< Connection > * 0 8576 29 PointerToBase< Connection > * 29 PointerToBase< Connection > * 0 0 346 0 0 0 0 0 0 0 0 0 0 381 35 PointerToBase< Connection > const * 0 8576 35 PointerToBase< Connection > const * 35 PointerToBase< Connection > const * 0 0 382 0 0 0 0 0 0 0 0 0 0 382 33 PointerToBase< Connection > const 0 8832 33 PointerToBase< Connection > const 33 PointerToBase< Connection > const 0 0 346 0 0 0 0 0 0 0 0 0 0 383 9 ostream * 0 8576 14 std::ostream * 14 std::ostream * 0 0 384 0 0 0 0 0 0 0 0 0 0 384 7 ostream 0 2048 12 std::ostream 12 std::ostream 0 0 0 0 0 0 0 0 0 0 0 0 0 385 12 NetAddress * 0 8576 12 NetAddress * 12 NetAddress * 0 0 348 0 0 0 0 0 0 0 0 0 0 386 18 NetAddress const * 0 8576 18 NetAddress const * 18 NetAddress const * 0 0 387 0 0 0 0 0 0 0 0 0 0 387 16 NetAddress const 0 8832 16 NetAddress const 16 NetAddress const 0 0 348 0 0 0 0 0 0 0 0 0 0 388 22 Socket_Address const * 0 8576 22 Socket_Address const * 22 Socket_Address const * 0 0 389 0 0 0 0 0 0 0 0 0 0 389 20 Socket_Address const 0 8832 20 Socket_Address const 20 Socket_Address const 0 0 390 0 0 0 0 0 0 0 0 0 0 390 14 Socket_Address 0 2048 14 Socket_Address 14 Socket_Address 0 0 0 0 0 0 0 0 0 0 0 0 97 /** * A simple place to store and manipulate tcp and port address for * communication layer */ 391 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0 392 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0 393 8 uint32_t 0 2105344 8 uint32_t 8 uint32_t 0 0 394 0 0 0 0 0 0 0 0 0 0 394 12 unsigned int 0 8198 12 unsigned int 12 unsigned int 0 1 0 0 0 0 0 0 0 0 0 0 0 395 7 uint8_t 0 2105344 7 uint8_t 7 uint8_t 0 0 396 0 0 0 0 0 0 0 0 0 0 396 13 unsigned char 0 8198 13 unsigned char 13 unsigned char 0 5 0 0 0 0 0 0 0 0 0 0 0 397 6 size_t 0 2105344 11 std::size_t 11 std::size_t 0 0 398 0 0 0 0 0 0 0 0 0 0 398 22 unsigned long long int 0 8230 22 unsigned long long int 22 unsigned long long int 0 8 0 0 0 0 0 0 0 0 0 0 0 399 19 ConnectionManager * 0 8576 19 ConnectionManager * 19 ConnectionManager * 0 0 355 0 0 0 0 0 0 0 0 0 0 400 11 Socket_IP * 0 8576 11 Socket_IP * 11 Socket_IP * 0 0 401 0 0 0 0 0 0 0 0 0 0 401 9 Socket_IP 0 2048 9 Socket_IP 9 Socket_IP 0 0 0 0 0 0 0 0 0 0 0 0 354 /** * 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 * */ 402 18 Connection const * 0 8576 18 Connection const * 18 Connection const * 0 0 403 0 0 0 0 0 0 0 0 0 0 403 16 Connection const 0 8832 16 Connection const 16 Connection const 0 0 349 0 0 0 0 0 0 0 0 0 0 404 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0 405 18 ConnectionReader * 0 8576 18 ConnectionReader * 18 ConnectionReader * 0 0 351 0 0 0 0 0 0 0 0 0 0 406 24 ConnectionReader const * 0 8576 24 ConnectionReader const * 24 ConnectionReader const * 0 0 407 0 0 0 0 0 0 0 0 0 0 407 22 ConnectionReader const 0 8832 22 ConnectionReader const 22 ConnectionReader const 0 0 351 0 0 0 0 0 0 0 0 0 0 408 13 NetDatagram * 0 8576 13 NetDatagram * 13 NetDatagram * 0 0 353 0 0 0 0 0 0 0 0 0 0 409 16 Datagram const * 0 8576 16 Datagram const * 16 Datagram const * 0 0 410 0 0 0 0 0 0 0 0 0 0 410 14 Datagram const 0 8832 14 Datagram const 14 Datagram const 0 0 354 0 0 0 0 0 0 0 0 0 0 411 19 NetDatagram const * 0 8576 19 NetDatagram const * 19 NetDatagram const * 0 0 412 0 0 0 0 0 0 0 0 0 0 412 17 NetDatagram const 0 8832 17 NetDatagram const 17 NetDatagram const 0 0 353 0 0 0 0 0 0 0 0 0 0 413 10 TypeHandle 0 16779264 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 732 /** * 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. */ 414 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 413 0 0 0 0 0 0 0 0 0 0 415 8 uint16_t 0 2105344 8 uint16_t 8 uint16_t 0 0 416 0 0 0 0 0 0 0 0 0 0 416 18 unsigned short int 0 8262 18 unsigned short int 18 unsigned short int 0 1 0 0 0 0 0 0 0 0 0 0 0 417 17 Interface const * 0 8576 36 ConnectionManager::Interface const * 36 ConnectionManager::Interface const * 0 0 359 0 0 0 0 0 0 0 0 0 0 418 11 Interface * 0 8576 30 ConnectionManager::Interface * 30 ConnectionManager::Interface * 0 0 356 0 0 0 0 0 0 0 0 0 0 419 18 ConnectionWriter * 0 8576 18 ConnectionWriter * 18 ConnectionWriter * 0 0 360 0 0 0 0 0 0 0 0 0 0 420 24 ConnectionWriter const * 0 8576 24 ConnectionWriter const * 24 ConnectionWriter const * 0 0 421 0 0 0 0 0 0 0 0 0 0 421 22 ConnectionWriter const 0 8832 22 ConnectionWriter const 22 ConnectionWriter const 0 0 360 0 0 0 0 0 0 0 0 0 0 422 22 DatagramGeneratorNet * 0 8576 22 DatagramGeneratorNet * 22 DatagramGeneratorNet * 0 0 361 0 0 0 0 0 0 0 0 0 0 423 10 Datagram * 0 8576 10 Datagram * 10 Datagram * 0 0 354 0 0 0 0 0 0 0 0 0 0 424 19 DatagramGenerator * 0 8576 19 DatagramGenerator * 19 DatagramGenerator * 0 0 362 0 0 0 0 0 0 0 0 0 0 425 26 QueuedReturn< Datagram > * 0 8576 26 QueuedReturn< Datagram > * 26 QueuedReturn< Datagram > * 0 0 363 0 0 0 0 0 0 0 0 0 0 426 32 QueuedReturn< Datagram > const * 0 8576 32 QueuedReturn< Datagram > const * 32 QueuedReturn< Datagram > const * 0 0 427 0 0 0 0 0 0 0 0 0 0 427 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 428 17 DatagramSinkNet * 0 8576 17 DatagramSinkNet * 17 DatagramSinkNet * 0 0 364 0 0 0 0 0 0 0 0 0 0 429 23 DatagramSinkNet const * 0 8576 23 DatagramSinkNet const * 23 DatagramSinkNet const * 0 0 430 0 0 0 0 0 0 0 0 0 0 430 21 DatagramSinkNet const 0 8832 21 DatagramSinkNet const 21 DatagramSinkNet const 0 0 364 0 0 0 0 0 0 0 0 0 0 431 14 DatagramSink * 0 8576 14 DatagramSink * 14 DatagramSink * 0 0 365 0 0 0 0 0 0 0 0 0 0 432 26 QueuedConnectionListener * 0 8576 26 QueuedConnectionListener * 26 QueuedConnectionListener * 0 0 366 0 0 0 0 0 0 0 0 0 0 433 20 ConnectionListener * 0 8576 20 ConnectionListener * 20 ConnectionListener * 0 0 352 0 0 0 0 0 0 0 0 0 0 434 40 QueuedReturn< ConnectionListenerData > * 0 8576 40 QueuedReturn< ConnectionListenerData > * 40 QueuedReturn< ConnectionListenerData > * 0 0 367 0 0 0 0 0 0 0 0 0 0 435 46 QueuedReturn< ConnectionListenerData > const * 0 8576 46 QueuedReturn< ConnectionListenerData > const * 46 QueuedReturn< ConnectionListenerData > const * 0 0 436 0 0 0 0 0 0 0 0 0 0 436 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 437 25 QueuedConnectionManager * 0 8576 25 QueuedConnectionManager * 25 QueuedConnectionManager * 0 0 368 0 0 0 0 0 0 0 0 0 0 438 31 QueuedConnectionManager const * 0 8576 31 QueuedConnectionManager const * 31 QueuedConnectionManager const * 0 0 439 0 0 0 0 0 0 0 0 0 0 439 29 QueuedConnectionManager const 0 8832 29 QueuedConnectionManager const 29 QueuedConnectionManager const 0 0 368 0 0 0 0 0 0 0 0 0 0 440 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 441 47 QueuedReturn< PointerTo< Connection > > const * 0 8576 47 QueuedReturn< PointerTo< Connection > > const * 47 QueuedReturn< PointerTo< Connection > > const * 0 0 442 0 0 0 0 0 0 0 0 0 0 442 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 443 24 QueuedConnectionReader * 0 8576 24 QueuedConnectionReader * 24 QueuedConnectionReader * 0 0 370 0 0 0 0 0 0 0 0 0 0 444 29 QueuedReturn< NetDatagram > * 0 8576 29 QueuedReturn< NetDatagram > * 29 QueuedReturn< NetDatagram > * 0 0 371 0 0 0 0 0 0 0 0 0 0 445 35 QueuedReturn< NetDatagram > const * 0 8576 35 QueuedReturn< NetDatagram > const * 35 QueuedReturn< NetDatagram > const * 0 0 446 0 0 0 0 0 0 0 0 0 0 446 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 447 24 RecentConnectionReader * 0 8576 24 RecentConnectionReader * 24 RecentConnectionReader * 0 0 372 0 0 0 0 0 0 0 0 0 0 0 2 448 9 host_name 0 2 357 243 0 0 0 0 0 0 0 28 ConnectionManager::host_name 0 449 10 interfaces 0 66 359 260 0 0 0 0 258 0 0 29 ConnectionManager::interfaces 0 1 450 14 get_interfaces 0 258 259 33 ConnectionManager::get_interfaces 0