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