| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 part of dart.io; | |
| 6 | |
| 7 /** | |
| 8 * A low-level class for communicating synchronously over a TCP socket. | |
| 9 * | |
| 10 * Warning: [RawSynchronousSocket] should probably only be used to connect to | |
| 11 * 'localhost'. The operations below will block the calling thread to wait for | |
| 12 * a response from the network. The thread can process no other events while | |
| 13 * waiting for these operations to complete. [RawSynchronousSocket] is not | |
| 14 * suitable for applications that require high performance or asynchronous I/O | |
| 15 * such as a server. Instead such applications should use the non-blocking | |
| 16 * sockets and asynchronous operations in the Socket or RawSocket classes. | |
| 17 */ | |
| 18 abstract class RawSynchronousSocket { | |
| 19 /** | |
| 20 * Creates a new socket connection and returns a [RawSynchronousSocket]. | |
| 21 * | |
| 22 * [host] can either be a [String] or an [InternetAddress]. If [host] is a | |
| 23 * [String], [connectSync] will perform a [InternetAddress.lookup] and try | |
| 24 * all returned [InternetAddress]es, until connected. Unless a | |
| 25 * connection was established, the error from the first failing connection is | |
| 26 * returned. | |
| 27 */ | |
| 28 external static RawSynchronousSocket connectSync(host, int port); | |
| 29 | |
| 30 /** | |
| 31 * Returns the number of received and unread bytes in the socket that can be | |
| 32 * read. | |
| 33 */ | |
| 34 int available(); | |
| 35 | |
| 36 /** | |
| 37 * Closes the [RawSynchronousSocket]. | |
| 38 * | |
| 39 * Once [closeSync] has been called, attempting to call [readSync], | |
| 40 * [readIntoSync], [writeFromSync], [remoteAddress], and [remotePort] will | |
| 41 * cause a [SocketException] to be thrown. | |
| 42 */ | |
| 43 void closeSync(); | |
| 44 | |
| 45 /** | |
| 46 * Reads into an existing [List<int>] from the socket into the range: | |
| 47 * [[start],[end]). | |
| 48 * | |
| 49 * Reads into an existing [List<int>] from the socket. If [start] is present, | |
| 50 * the bytes will be filled into [buffer] from index [start], otherwise index | |
| 51 * 0. If [end] is present, [end] - [start] bytes will be read into [buffer], | |
| 52 * otherwise up to [buffer.length]. If [end] == [start], no bytes are read. | |
| 53 * Returns the number of bytes read. | |
| 54 */ | |
| 55 int readIntoSync(List<int> buffer, [int start = 0, int end]); | |
| 56 | |
| 57 /** | |
| 58 * Reads up to [bytes] bytes from the socket. | |
| 59 * | |
| 60 * Blocks and waits for a response of up to a specified number of bytes | |
| 61 * sent by the socket. [bytes] specifies the maximum number of bytes to | |
| 62 * be read. Returns the list of bytes read, which could be less than the | |
| 63 * value specified by [bytes]. | |
| 64 */ | |
| 65 List<int> readSync(int bytes); | |
| 66 | |
| 67 /** | |
| 68 * Shutdown a socket in the provided direction. | |
| 69 * | |
| 70 * Calling shutdown will never throw an exception and calling it several times | |
| 71 * is supported. If both [RECEIVE] and [SEND] directions are closed, the | |
| 72 * socket is closed completely, the same as if [closeSync] has been called. | |
| 73 */ | |
| 74 void shutdown(SocketDirection direction); | |
| 75 | |
| 76 /** | |
| 77 * Writes data from a specified range in a [List<int>] to the socket. | |
| 78 * | |
| 79 * Writes into the socket from a [List<int>]. If [start] is present, the bytes | |
| 80 * will be written to the socket starting from index [start]. If [start] is | |
| 81 * not present, the bytes will be written starting from index 0. If [end] is | |
| 82 * present, the [end] - [start] bytes will be written into the socket starting | |
| 83 * at index [start]. If [end] is not provided, [buffer.length] elements will | |
| 84 * be written to the socket starting from index [start]. If [end] == [start], | |
| 85 * nothing happens. | |
| 86 */ | |
| 87 void writeFromSync(List<int> buffer, [int start = 0, int end]); | |
| 88 | |
| 89 /** | |
| 90 * The port used by this socket. | |
| 91 */ | |
| 92 int get port; | |
| 93 | |
| 94 /** | |
| 95 * The remote port connected to by this socket. | |
| 96 */ | |
| 97 int get remotePort; | |
| 98 | |
| 99 /** | |
| 100 * The [InternetAddress] used to connect this socket. | |
| 101 */ | |
| 102 InternetAddress get address; | |
| 103 | |
| 104 /** | |
| 105 * The remote [InternetAddress] connected to by this socket. | |
| 106 */ | |
| 107 InternetAddress get remoteAddress; | |
| 108 } | |
| OLD | NEW |