/Generated/v4.2/Org.Apache.Http.Impl.cs

https://gitlab.com/Pfhoenix/api · C# · 1243 lines · 593 code · 122 blank · 528 comment · 0 complexity · abca677a933621f7e7d20fa06a821541 MD5 · raw file 

    

  1. // Copyright (C) 2014 dot42

    2. 

  2. //

    3. 

  3. // Original filename: Org.Apache.Http.Impl.cs

    4. 

  4. //

    5. 

  5. // Licensed under the Apache License, Version 2.0 (the "License");

    6. 

  6. // you may not use this file except in compliance with the License.

    7. 

  7. // You may obtain a copy of the License at

    8. 

  8. // 

    9. 

  9. //     http://www.apache.org/licenses/LICENSE-2.0

    10. 

  10. // 

    11. 

  11. // Unless required by applicable law or agreed to in writing, software

    12. 

  12. // distributed under the License is distributed on an "AS IS" BASIS,

    13. 

  13. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    14. 

  14. // See the License for the specific language governing permissions and

    15. 

  15. // limitations under the License.

    16. 

  16. #pragma warning disable 1717
    17. 

  17. namespace Org.Apache.Http.Impl
    18. 

  18. {
    19. 

  19. 		/// <summary>
    20. 

  20. 		/// <para>Implementation of a server-side HTTP connection that can be bound to a network Socket in order to receive and transmit data.</para><para><para></para><para></para><title>Revision:</title><para>561083 </para></para><para><para>4.0 </para></para>    
    21. 

  21. 		/// </summary>
    22. 

  22. 		/// <java-name>
    23. 

  23. 		/// org/apache/http/impl/SocketHttpServerConnection
    24. 

  24. 		/// </java-name>
    25. 

  25. 		[Dot42.DexImport("org/apache/http/impl/SocketHttpServerConnection", AccessFlags = 33)]
    26. 

  26. 		public partial class SocketHttpServerConnection : global::Org.Apache.Http.Impl.AbstractHttpServerConnection, global::Org.Apache.Http.IHttpInetConnection
    27. 

  27.  /* scope: __dot42__ */ 
    28. 

  28. 		{
    29. 

  29. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    30. 

  30. 				public SocketHttpServerConnection() /* MethodBuilder.Create */ 
    31. 

  31. 				{
    32. 

  32. 				}
    33. 

  33. 

  34. 				/// <java-name>
    35. 

  35. 				/// assertNotOpen
    36. 

  36. 				/// </java-name>
    37. 

  37. 				[Dot42.DexImport("assertNotOpen", "()V", AccessFlags = 4)]
    38. 

  38. 				protected internal virtual void AssertNotOpen() /* MethodBuilder.Create */ 
    39. 

  39. 				{
    40. 

  40. 				}
    41. 

  41. 

  42. 				/// <java-name>
    43. 

  43. 				/// assertOpen
    44. 

  44. 				/// </java-name>
    45. 

  45. 				[Dot42.DexImport("assertOpen", "()V", AccessFlags = 4)]
    46. 

  46. 				protected internal override void AssertOpen() /* MethodBuilder.Create */ 
    47. 

  47. 				{
    48. 

  48. 				}
    49. 

  49. 

  50. 				/// <java-name>
    51. 

  51. 				/// createHttpDataReceiver
    52. 

  52. 				/// </java-name>
    53. 

  53. 				[Dot42.DexImport("createHttpDataReceiver", "(Ljava/net/Socket;ILorg/apache/http/params/HttpParams;)Lorg/apache/http/io/Sessio" +
    54. 

  54.     "nInputBuffer;", AccessFlags = 4)]
    55. 

  55. 				protected internal virtual global::Org.Apache.Http.Io.ISessionInputBuffer CreateHttpDataReceiver(global::Java.Net.Socket socket, int buffersize, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    56. 

  56. 				{
    57. 

  57. 						return default(global::Org.Apache.Http.Io.ISessionInputBuffer);
    58. 

  58. 				}
    59. 

  59. 

  60. 				/// <java-name>
    61. 

  61. 				/// createHttpDataTransmitter
    62. 

  62. 				/// </java-name>
    63. 

  63. 				[Dot42.DexImport("createHttpDataTransmitter", "(Ljava/net/Socket;ILorg/apache/http/params/HttpParams;)Lorg/apache/http/io/Sessio" +
    64. 

  64.     "nOutputBuffer;", AccessFlags = 4)]
    65. 

  65. 				protected internal virtual global::Org.Apache.Http.Io.ISessionOutputBuffer CreateHttpDataTransmitter(global::Java.Net.Socket socket, int buffersize, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    66. 

  66. 				{
    67. 

  67. 						return default(global::Org.Apache.Http.Io.ISessionOutputBuffer);
    68. 

  68. 				}
    69. 

  69. 

  70. 				/// <java-name>
    71. 

  71. 				/// bind
    72. 

  72. 				/// </java-name>
    73. 

  73. 				[Dot42.DexImport("bind", "(Ljava/net/Socket;Lorg/apache/http/params/HttpParams;)V", AccessFlags = 4)]
    74. 

  74. 				protected internal virtual void Bind(global::Java.Net.Socket socket, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    75. 

  75. 				{
    76. 

  76. 				}
    77. 

  77. 

  78. 				/// <java-name>
    79. 

  79. 				/// getSocket
    80. 

  80. 				/// </java-name>
    81. 

  81. 				[Dot42.DexImport("getSocket", "()Ljava/net/Socket;", AccessFlags = 4)]
    82. 

  82. 				protected internal virtual global::Java.Net.Socket GetSocket() /* MethodBuilder.Create */ 
    83. 

  83. 				{
    84. 

  84. 						return default(global::Java.Net.Socket);
    85. 

  85. 				}
    86. 

  86. 

  87. 				/// <summary>
    88. 

  88. 				/// <para>Checks if this connection is open. </para>        
    89. 

  89. 				/// </summary>
    90. 

  90. 				/// <returns>
    91. 

  91. 				/// <para>true if it is open, false if it is closed. </para>
    92. 

  92. 				/// </returns>
    93. 

  93. 				/// <java-name>
    94. 

  94. 				/// isOpen
    95. 

  95. 				/// </java-name>
    96. 

  96. 				[Dot42.DexImport("isOpen", "()Z", AccessFlags = 1)]
    97. 

  97. 				public override bool IsOpen() /* MethodBuilder.Create */ 
    98. 

  98. 				{
    99. 

  99. 						return default(bool);
    100. 

  100. 				}
    101. 

  101. 

  102. 				/// <java-name>
    103. 

  103. 				/// getLocalAddress
    104. 

  104. 				/// </java-name>
    105. 

  105. 				[Dot42.DexImport("getLocalAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    106. 

  106. 				public virtual global::Java.Net.InetAddress GetLocalAddress() /* MethodBuilder.Create */ 
    107. 

  107. 				{
    108. 

  108. 						return default(global::Java.Net.InetAddress);
    109. 

  109. 				}
    110. 

  110. 

  111. 				/// <java-name>
    112. 

  112. 				/// getLocalPort
    113. 

  113. 				/// </java-name>
    114. 

  114. 				[Dot42.DexImport("getLocalPort", "()I", AccessFlags = 1)]
    115. 

  115. 				public virtual int GetLocalPort() /* MethodBuilder.Create */ 
    116. 

  116. 				{
    117. 

  117. 						return default(int);
    118. 

  118. 				}
    119. 

  119. 

  120. 				/// <java-name>
    121. 

  121. 				/// getRemoteAddress
    122. 

  122. 				/// </java-name>
    123. 

  123. 				[Dot42.DexImport("getRemoteAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    124. 

  124. 				public virtual global::Java.Net.InetAddress GetRemoteAddress() /* MethodBuilder.Create */ 
    125. 

  125. 				{
    126. 

  126. 						return default(global::Java.Net.InetAddress);
    127. 

  127. 				}
    128. 

  128. 

  129. 				/// <java-name>
    130. 

  130. 				/// getRemotePort
    131. 

  131. 				/// </java-name>
    132. 

  132. 				[Dot42.DexImport("getRemotePort", "()I", AccessFlags = 1)]
    133. 

  133. 				public virtual int GetRemotePort() /* MethodBuilder.Create */ 
    134. 

  134. 				{
    135. 

  135. 						return default(int);
    136. 

  136. 				}
    137. 

  137. 

  138. 				/// <summary>
    139. 

  139. 				/// <para>Sets the socket timeout value.</para><para></para>        
    140. 

  140. 				/// </summary>
    141. 

  141. 				/// <java-name>
    142. 

  142. 				/// setSocketTimeout
    143. 

  143. 				/// </java-name>
    144. 

  144. 				[Dot42.DexImport("setSocketTimeout", "(I)V", AccessFlags = 1)]
    145. 

  145. 				public override void SetSocketTimeout(int timeout) /* MethodBuilder.Create */ 
    146. 

  146. 				{
    147. 

  147. 				}
    148. 

  148. 

  149. 				/// <summary>
    150. 

  150. 				/// <para>Returns the socket timeout value.</para><para></para>        
    151. 

  151. 				/// </summary>
    152. 

  152. 				/// <returns>
    153. 

  153. 				/// <para>positive value in milliseconds if a timeout is set, <code>0</code> if timeout is disabled or <code>-1</code> if timeout is undefined. </para>
    154. 

  154. 				/// </returns>
    155. 

  155. 				/// <java-name>
    156. 

  156. 				/// getSocketTimeout
    157. 

  157. 				/// </java-name>
    158. 

  158. 				[Dot42.DexImport("getSocketTimeout", "()I", AccessFlags = 1)]
    159. 

  159. 				public override int GetSocketTimeout() /* MethodBuilder.Create */ 
    160. 

  160. 				{
    161. 

  161. 						return default(int);
    162. 

  162. 				}
    163. 

  163. 

  164. 				/// <summary>
    165. 

  165. 				/// <para>Force-closes this connection. This is the only method of a connection which may be called from a different thread to terminate the connection. This method will not attempt to flush the transmitter's internal buffer prior to closing the underlying socket. </para>        
    166. 

  166. 				/// </summary>
    167. 

  167. 				/// <java-name>
    168. 

  168. 				/// shutdown
    169. 

  169. 				/// </java-name>
    170. 

  170. 				[Dot42.DexImport("shutdown", "()V", AccessFlags = 1)]
    171. 

  171. 				public override void Shutdown() /* MethodBuilder.Create */ 
    172. 

  172. 				{
    173. 

  173. 				}
    174. 

  174. 

  175. 				/// <summary>
    176. 

  176. 				/// <para>Closes this connection gracefully. This method will attempt to flush the transmitter's internal buffer prior to closing the underlying socket. This method MUST NOT be called from a different thread to force shutdown of the connection. Use shutdown instead. </para>        
    177. 

  177. 				/// </summary>
    178. 

  178. 				/// <java-name>
    179. 

  179. 				/// close
    180. 

  180. 				/// </java-name>
    181. 

  181. 				[Dot42.DexImport("close", "()V", AccessFlags = 1)]
    182. 

  182. 				public override void Close() /* MethodBuilder.Create */ 
    183. 

  183. 				{
    184. 

  184. 				}
    185. 

  185. 

  186. 				[Dot42.DexImport("org/apache/http/HttpConnection", "isStale", "()Z", AccessFlags = 1025)]
    187. 

  187. 				public override bool IsStale() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    188. 

  188. 				{
    189. 

  189. 						return default(bool);
    190. 

  190. 				}
    191. 

  191. 

  192. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1025)]
    193. 

  193. 				public override global::Org.Apache.Http.IHttpConnectionMetrics GetMetrics() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    194. 

  194. 				{
    195. 

  195. 						return default(global::Org.Apache.Http.IHttpConnectionMetrics);
    196. 

  196. 				}
    197. 

  197. 

  198. 				/// <java-name>
    199. 

  199. 				/// getSocket
    200. 

  200. 				/// </java-name>
    201. 

  201. 				protected internal global::Java.Net.Socket Socket
    202. 

  202. 				{
    203. 

  203. 				[Dot42.DexImport("getSocket", "()Ljava/net/Socket;", AccessFlags = 4)]
    204. 

  204. 						get{ return GetSocket(); }
    205. 

  205. 				}
    206. 

  206. 

  207. 				/// <java-name>
    208. 

  208. 				/// getLocalAddress
    209. 

  209. 				/// </java-name>
    210. 

  210. 				public global::Java.Net.InetAddress LocalAddress
    211. 

  211. 				{
    212. 

  212. 				[Dot42.DexImport("getLocalAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    213. 

  213. 						get{ return GetLocalAddress(); }
    214. 

  214. 				}
    215. 

  215. 

  216. 				/// <java-name>
    217. 

  217. 				/// getLocalPort
    218. 

  218. 				/// </java-name>
    219. 

  219. 				public int LocalPort
    220. 

  220. 				{
    221. 

  221. 				[Dot42.DexImport("getLocalPort", "()I", AccessFlags = 1)]
    222. 

  222. 						get{ return GetLocalPort(); }
    223. 

  223. 				}
    224. 

  224. 

  225. 				/// <java-name>
    226. 

  226. 				/// getRemoteAddress
    227. 

  227. 				/// </java-name>
    228. 

  228. 				public global::Java.Net.InetAddress RemoteAddress
    229. 

  229. 				{
    230. 

  230. 				[Dot42.DexImport("getRemoteAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    231. 

  231. 						get{ return GetRemoteAddress(); }
    232. 

  232. 				}
    233. 

  233. 

  234. 				/// <java-name>
    235. 

  235. 				/// getRemotePort
    236. 

  236. 				/// </java-name>
    237. 

  237. 				public int RemotePort
    238. 

  238. 				{
    239. 

  239. 				[Dot42.DexImport("getRemotePort", "()I", AccessFlags = 1)]
    240. 

  240. 						get{ return GetRemotePort(); }
    241. 

  241. 				}
    242. 

  242. 

  243. 				/// <summary>
    244. 

  244. 				/// <para>Returns the socket timeout value.</para><para></para>        
    245. 

  245. 				/// </summary>
    246. 

  246. 				/// <returns>
    247. 

  247. 				/// <para>positive value in milliseconds if a timeout is set, <code>0</code> if timeout is disabled or <code>-1</code> if timeout is undefined. </para>
    248. 

  248. 				/// </returns>
    249. 

  249. 				/// <java-name>
    250. 

  250. 				/// getSocketTimeout
    251. 

  251. 				/// </java-name>
    252. 

  252. 				public int SocketTimeout
    253. 

  253. 				{
    254. 

  254. 				[Dot42.DexImport("getSocketTimeout", "()I", AccessFlags = 1)]
    255. 

  255. 						get{ return GetSocketTimeout(); }
    256. 

  256. 				[Dot42.DexImport("setSocketTimeout", "(I)V", AccessFlags = 1)]
    257. 

  257. 						set{ SetSocketTimeout(value); }
    258. 

  258. 				}
    259. 

  259. 

  260. 				public global::Org.Apache.Http.IHttpConnectionMetrics Metrics
    261. 

  261. 				{
    262. 

  262. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1025)]
    263. 

  263. 						get{ return GetMetrics(); }
    264. 

  264. 				}
    265. 

  265. 

  266. 		}
    267. 

  267. 

  268. 		/// <summary>
    269. 

  269. 		/// <para>Abstract server-side HTTP connection capable of transmitting and receiving data using arbitrary SessionInputBuffer and SessionOutputBuffer</para><para><para></para><para></para><title>Revision:</title><para>618017 </para></para><para><para>4.0 </para></para>    
    270. 

  270. 		/// </summary>
    271. 

  271. 		/// <java-name>
    272. 

  272. 		/// org/apache/http/impl/AbstractHttpServerConnection
    273. 

  273. 		/// </java-name>
    274. 

  274. 		[Dot42.DexImport("org/apache/http/impl/AbstractHttpServerConnection", AccessFlags = 1057)]
    275. 

  275. 		public abstract partial class AbstractHttpServerConnection : global::Org.Apache.Http.IHttpServerConnection
    276. 

  276.  /* scope: __dot42__ */ 
    277. 

  277. 		{
    278. 

  278. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    279. 

  279. 				public AbstractHttpServerConnection() /* MethodBuilder.Create */ 
    280. 

  280. 				{
    281. 

  281. 				}
    282. 

  282. 

  283. 				/// <java-name>
    284. 

  284. 				/// assertOpen
    285. 

  285. 				/// </java-name>
    286. 

  286. 				[Dot42.DexImport("assertOpen", "()V", AccessFlags = 1028)]
    287. 

  287. 				protected internal abstract void AssertOpen() /* MethodBuilder.Create */ ;
    288. 

  288. 

  289. 				/// <java-name>
    290. 

  290. 				/// createEntityDeserializer
    291. 

  291. 				/// </java-name>
    292. 

  292. 				[Dot42.DexImport("createEntityDeserializer", "()Lorg/apache/http/impl/entity/EntityDeserializer;", AccessFlags = 4)]
    293. 

  293. 				protected internal virtual global::Org.Apache.Http.Impl.Entity.EntityDeserializer CreateEntityDeserializer() /* MethodBuilder.Create */ 
    294. 

  294. 				{
    295. 

  295. 						return default(global::Org.Apache.Http.Impl.Entity.EntityDeserializer);
    296. 

  296. 				}
    297. 

  297. 

  298. 				/// <java-name>
    299. 

  299. 				/// createEntitySerializer
    300. 

  300. 				/// </java-name>
    301. 

  301. 				[Dot42.DexImport("createEntitySerializer", "()Lorg/apache/http/impl/entity/EntitySerializer;", AccessFlags = 4)]
    302. 

  302. 				protected internal virtual global::Org.Apache.Http.Impl.Entity.EntitySerializer CreateEntitySerializer() /* MethodBuilder.Create */ 
    303. 

  303. 				{
    304. 

  304. 						return default(global::Org.Apache.Http.Impl.Entity.EntitySerializer);
    305. 

  305. 				}
    306. 

  306. 

  307. 				/// <java-name>
    308. 

  308. 				/// createHttpRequestFactory
    309. 

  309. 				/// </java-name>
    310. 

  310. 				[Dot42.DexImport("createHttpRequestFactory", "()Lorg/apache/http/HttpRequestFactory;", AccessFlags = 4)]
    311. 

  311. 				protected internal virtual global::Org.Apache.Http.IHttpRequestFactory CreateHttpRequestFactory() /* MethodBuilder.Create */ 
    312. 

  312. 				{
    313. 

  313. 						return default(global::Org.Apache.Http.IHttpRequestFactory);
    314. 

  314. 				}
    315. 

  315. 

  316. 				/// <java-name>
    317. 

  317. 				/// createRequestParser
    318. 

  318. 				/// </java-name>
    319. 

  319. 				[Dot42.DexImport("createRequestParser", "(Lorg/apache/http/io/SessionInputBuffer;Lorg/apache/http/HttpRequestFactory;Lorg/" +
    320. 

  320.     "apache/http/params/HttpParams;)Lorg/apache/http/io/HttpMessageParser;", AccessFlags = 4)]
    321. 

  321. 				protected internal virtual global::Org.Apache.Http.Io.IHttpMessageParser CreateRequestParser(global::Org.Apache.Http.Io.ISessionInputBuffer buffer, global::Org.Apache.Http.IHttpRequestFactory requestFactory, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    322. 

  322. 				{
    323. 

  323. 						return default(global::Org.Apache.Http.Io.IHttpMessageParser);
    324. 

  324. 				}
    325. 

  325. 

  326. 				/// <java-name>
    327. 

  327. 				/// createResponseWriter
    328. 

  328. 				/// </java-name>
    329. 

  329. 				[Dot42.DexImport("createResponseWriter", "(Lorg/apache/http/io/SessionOutputBuffer;Lorg/apache/http/params/HttpParams;)Lorg" +
    330. 

  330.     "/apache/http/io/HttpMessageWriter;", AccessFlags = 4)]
    331. 

  331. 				protected internal virtual global::Org.Apache.Http.Io.IHttpMessageWriter CreateResponseWriter(global::Org.Apache.Http.Io.ISessionOutputBuffer buffer, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    332. 

  332. 				{
    333. 

  333. 						return default(global::Org.Apache.Http.Io.IHttpMessageWriter);
    334. 

  334. 				}
    335. 

  335. 

  336. 				/// <java-name>
    337. 

  337. 				/// init
    338. 

  338. 				/// </java-name>
    339. 

  339. 				[Dot42.DexImport("init", "(Lorg/apache/http/io/SessionInputBuffer;Lorg/apache/http/io/SessionOutputBuffer;L" +
    340. 

  340.     "org/apache/http/params/HttpParams;)V", AccessFlags = 4)]
    341. 

  341. 				protected internal virtual void Init(global::Org.Apache.Http.Io.ISessionInputBuffer inbuffer, global::Org.Apache.Http.Io.ISessionOutputBuffer outbuffer, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    342. 

  342. 				{
    343. 

  343. 				}
    344. 

  344. 

  345. 				/// <summary>
    346. 

  346. 				/// <para>Receives the request line and all headers available from this connection. The caller should examine the returned request and decide if to receive a request entity as well.</para><para></para>        
    347. 

  347. 				/// </summary>
    348. 

  348. 				/// <returns>
    349. 

  349. 				/// <para>a new HttpRequest object whose request line and headers are initialized. </para>
    350. 

  350. 				/// </returns>
    351. 

  351. 				/// <java-name>
    352. 

  352. 				/// receiveRequestHeader
    353. 

  353. 				/// </java-name>
    354. 

  354. 				[Dot42.DexImport("receiveRequestHeader", "()Lorg/apache/http/HttpRequest;", AccessFlags = 1)]
    355. 

  355. 				public virtual global::Org.Apache.Http.IHttpRequest ReceiveRequestHeader() /* MethodBuilder.Create */ 
    356. 

  356. 				{
    357. 

  357. 						return default(global::Org.Apache.Http.IHttpRequest);
    358. 

  358. 				}
    359. 

  359. 

  360. 				/// <java-name>
    361. 

  361. 				/// receiveRequestEntity
    362. 

  362. 				/// </java-name>
    363. 

  363. 				[Dot42.DexImport("receiveRequestEntity", "(Lorg/apache/http/HttpEntityEnclosingRequest;)V", AccessFlags = 1)]
    364. 

  364. 				public virtual void ReceiveRequestEntity(global::Org.Apache.Http.IHttpEntityEnclosingRequest request) /* MethodBuilder.Create */ 
    365. 

  365. 				{
    366. 

  366. 				}
    367. 

  367. 

  368. 				/// <java-name>
    369. 

  369. 				/// doFlush
    370. 

  370. 				/// </java-name>
    371. 

  371. 				[Dot42.DexImport("doFlush", "()V", AccessFlags = 4)]
    372. 

  372. 				protected internal virtual void DoFlush() /* MethodBuilder.Create */ 
    373. 

  373. 				{
    374. 

  374. 				}
    375. 

  375. 

  376. 				/// <summary>
    377. 

  377. 				/// <para>Sends all pending buffered data over this connection. </para>        
    378. 

  378. 				/// </summary>
    379. 

  379. 				/// <java-name>
    380. 

  380. 				/// flush
    381. 

  381. 				/// </java-name>
    382. 

  382. 				[Dot42.DexImport("flush", "()V", AccessFlags = 1)]
    383. 

  383. 				public virtual void Flush() /* MethodBuilder.Create */ 
    384. 

  384. 				{
    385. 

  385. 				}
    386. 

  386. 

  387. 				/// <java-name>
    388. 

  388. 				/// sendResponseHeader
    389. 

  389. 				/// </java-name>
    390. 

  390. 				[Dot42.DexImport("sendResponseHeader", "(Lorg/apache/http/HttpResponse;)V", AccessFlags = 1)]
    391. 

  391. 				public virtual void SendResponseHeader(global::Org.Apache.Http.IHttpResponse response) /* MethodBuilder.Create */ 
    392. 

  392. 				{
    393. 

  393. 				}
    394. 

  394. 

  395. 				/// <java-name>
    396. 

  396. 				/// sendResponseEntity
    397. 

  397. 				/// </java-name>
    398. 

  398. 				[Dot42.DexImport("sendResponseEntity", "(Lorg/apache/http/HttpResponse;)V", AccessFlags = 1)]
    399. 

  399. 				public virtual void SendResponseEntity(global::Org.Apache.Http.IHttpResponse response) /* MethodBuilder.Create */ 
    400. 

  400. 				{
    401. 

  401. 				}
    402. 

  402. 

  403. 				/// <summary>
    404. 

  404. 				/// <para>Checks whether this connection has gone down. Network connections may get closed during some time of inactivity for several reasons. The next time a read is attempted on such a connection it will throw an IOException. This method tries to alleviate this inconvenience by trying to find out if a connection is still usable. Implementations may do that by attempting a read with a very small timeout. Thus this method may block for a small amount of time before returning a result. It is therefore an <b>expensive</b> operation.</para><para></para>        
    405. 

  405. 				/// </summary>
    406. 

  406. 				/// <returns>
    407. 

  407. 				/// <para><code>true</code> if attempts to use this connection are likely to succeed, or <code>false</code> if they are likely to fail and this connection should be closed </para>
    408. 

  408. 				/// </returns>
    409. 

  409. 				/// <java-name>
    410. 

  410. 				/// isStale
    411. 

  411. 				/// </java-name>
    412. 

  412. 				[Dot42.DexImport("isStale", "()Z", AccessFlags = 1)]
    413. 

  413. 				public virtual bool IsStale() /* MethodBuilder.Create */ 
    414. 

  414. 				{
    415. 

  415. 						return default(bool);
    416. 

  416. 				}
    417. 

  417. 

  418. 				/// <summary>
    419. 

  419. 				/// <para>Returns a collection of connection metrcis </para>        
    420. 

  420. 				/// </summary>
    421. 

  421. 				/// <returns>
    422. 

  422. 				/// <para>HttpConnectionMetrics </para>
    423. 

  423. 				/// </returns>
    424. 

  424. 				/// <java-name>
    425. 

  425. 				/// getMetrics
    426. 

  426. 				/// </java-name>
    427. 

  427. 				[Dot42.DexImport("getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1)]
    428. 

  428. 				public virtual global::Org.Apache.Http.IHttpConnectionMetrics GetMetrics() /* MethodBuilder.Create */ 
    429. 

  429. 				{
    430. 

  430. 						return default(global::Org.Apache.Http.IHttpConnectionMetrics);
    431. 

  431. 				}
    432. 

  432. 

  433. 				[Dot42.DexImport("org/apache/http/HttpConnection", "close", "()V", AccessFlags = 1025)]
    434. 

  434. 				public virtual void Close() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    435. 

  435. 				{
    436. 

  436. 				}
    437. 

  437. 

  438. 				[Dot42.DexImport("org/apache/http/HttpConnection", "isOpen", "()Z", AccessFlags = 1025)]
    439. 

  439. 				public virtual bool IsOpen() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    440. 

  440. 				{
    441. 

  441. 						return default(bool);
    442. 

  442. 				}
    443. 

  443. 

  444. 				[Dot42.DexImport("org/apache/http/HttpConnection", "setSocketTimeout", "(I)V", AccessFlags = 1025)]
    445. 

  445. 				public virtual void SetSocketTimeout(int timeout) /* TypeBuilder.AddAbstractInterfaceMethods */ 
    446. 

  446. 				{
    447. 

  447. 				}
    448. 

  448. 

  449. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getSocketTimeout", "()I", AccessFlags = 1025)]
    450. 

  450. 				public virtual int GetSocketTimeout() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    451. 

  451. 				{
    452. 

  452. 						return default(int);
    453. 

  453. 				}
    454. 

  454. 

  455. 				[Dot42.DexImport("org/apache/http/HttpConnection", "shutdown", "()V", AccessFlags = 1025)]
    456. 

  456. 				public virtual void Shutdown() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    457. 

  457. 				{
    458. 

  458. 				}
    459. 

  459. 

  460. 				/// <summary>
    461. 

  461. 				/// <para>Returns a collection of connection metrcis </para>        
    462. 

  462. 				/// </summary>
    463. 

  463. 				/// <returns>
    464. 

  464. 				/// <para>HttpConnectionMetrics </para>
    465. 

  465. 				/// </returns>
    466. 

  466. 				/// <java-name>
    467. 

  467. 				/// getMetrics
    468. 

  468. 				/// </java-name>
    469. 

  469. 				public global::Org.Apache.Http.IHttpConnectionMetrics Metrics
    470. 

  470. 				{
    471. 

  471. 				[Dot42.DexImport("getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1)]
    472. 

  472. 						get{ return GetMetrics(); }
    473. 

  473. 				}
    474. 

  474. 

  475. 				public int SocketTimeout
    476. 

  476. 				{
    477. 

  477. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getSocketTimeout", "()I", AccessFlags = 1025)]
    478. 

  478. 						get{ return GetSocketTimeout(); }
    479. 

  479. 				[Dot42.DexImport("org/apache/http/HttpConnection", "setSocketTimeout", "(I)V", AccessFlags = 1025)]
    480. 

  480. 						set{ SetSocketTimeout(value); }
    481. 

  481. 				}
    482. 

  482. 

  483. 		}
    484. 

  484. 

  485. 		/// <summary>
    486. 

  486. 		/// <para>Default implementation of a factory for creating response objects.</para><para><para></para><para></para><title>Revision:</title><para>618367 </para></para><para><para>4.0 </para></para>    
    487. 

  487. 		/// </summary>
    488. 

  488. 		/// <java-name>
    489. 

  489. 		/// org/apache/http/impl/DefaultHttpResponseFactory
    490. 

  490. 		/// </java-name>
    491. 

  491. 		[Dot42.DexImport("org/apache/http/impl/DefaultHttpResponseFactory", AccessFlags = 33)]
    492. 

  492. 		public partial class DefaultHttpResponseFactory : global::Org.Apache.Http.IHttpResponseFactory
    493. 

  493.  /* scope: __dot42__ */ 
    494. 

  494. 		{
    495. 

  495. 				/// <summary>
    496. 

  496. 				/// <para>The catalog for looking up reason phrases. </para>        
    497. 

  497. 				/// </summary>
    498. 

  498. 				/// <java-name>
    499. 

  499. 				/// reasonCatalog
    500. 

  500. 				/// </java-name>
    501. 

  501. 				[Dot42.DexImport("reasonCatalog", "Lorg/apache/http/ReasonPhraseCatalog;", AccessFlags = 20)]
    502. 

  502. 				protected internal readonly global::Org.Apache.Http.IReasonPhraseCatalog ReasonCatalog;
    503. 

  503. 				/// <summary>
    504. 

  504. 				/// <para>Creates a new response factory with the given catalog.</para><para></para>        
    505. 

  505. 				/// </summary>
    506. 

  506. 				[Dot42.DexImport("<init>", "(Lorg/apache/http/ReasonPhraseCatalog;)V", AccessFlags = 1)]
    507. 

  507. 				public DefaultHttpResponseFactory(global::Org.Apache.Http.IReasonPhraseCatalog catalog) /* MethodBuilder.Create */ 
    508. 

  508. 				{
    509. 

  509. 				}
    510. 

  510. 

  511. 				/// <summary>
    512. 

  512. 				/// <para>Creates a new response factory with the default catalog. The default catalog is EnglishReasonPhraseCatalog. </para>        
    513. 

  513. 				/// </summary>
    514. 

  514. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    515. 

  515. 				public DefaultHttpResponseFactory() /* MethodBuilder.Create */ 
    516. 

  516. 				{
    517. 

  517. 				}
    518. 

  518. 

  519. 				/// <java-name>
    520. 

  520. 				/// newHttpResponse
    521. 

  521. 				/// </java-name>
    522. 

  522. 				[Dot42.DexImport("newHttpResponse", "(Lorg/apache/http/ProtocolVersion;ILorg/apache/http/protocol/HttpContext;)Lorg/ap" +
    523. 

  523.     "ache/http/HttpResponse;", AccessFlags = 1)]
    524. 

  524. 				public virtual global::Org.Apache.Http.IHttpResponse NewHttpResponse(global::Org.Apache.Http.ProtocolVersion ver, int status, global::Org.Apache.Http.Protocol.IHttpContext context) /* MethodBuilder.Create */ 
    525. 

  525. 				{
    526. 

  526. 						return default(global::Org.Apache.Http.IHttpResponse);
    527. 

  527. 				}
    528. 

  528. 

  529. 				/// <java-name>
    530. 

  530. 				/// newHttpResponse
    531. 

  531. 				/// </java-name>
    532. 

  532. 				[Dot42.DexImport("newHttpResponse", "(Lorg/apache/http/StatusLine;Lorg/apache/http/protocol/HttpContext;)Lorg/apache/h" +
    533. 

  533.     "ttp/HttpResponse;", AccessFlags = 1)]
    534. 

  534. 				public virtual global::Org.Apache.Http.IHttpResponse NewHttpResponse(global::Org.Apache.Http.IStatusLine statusline, global::Org.Apache.Http.Protocol.IHttpContext context) /* MethodBuilder.Create */ 
    535. 

  535. 				{
    536. 

  536. 						return default(global::Org.Apache.Http.IHttpResponse);
    537. 

  537. 				}
    538. 

  538. 

  539. 				/// <summary>
    540. 

  540. 				/// <para>Determines the locale of the response. The implementation in this class always returns the default locale.</para><para></para>        
    541. 

  541. 				/// </summary>
    542. 

  542. 				/// <returns>
    543. 

  543. 				/// <para>the locale for the response, never <code>null</code> </para>
    544. 

  544. 				/// </returns>
    545. 

  545. 				/// <java-name>
    546. 

  546. 				/// determineLocale
    547. 

  547. 				/// </java-name>
    548. 

  548. 				[Dot42.DexImport("determineLocale", "(Lorg/apache/http/protocol/HttpContext;)Ljava/util/Locale;", AccessFlags = 4)]
    549. 

  549. 				protected internal virtual global::Java.Util.Locale DetermineLocale(global::Org.Apache.Http.Protocol.IHttpContext context) /* MethodBuilder.Create */ 
    550. 

  550. 				{
    551. 

  551. 						return default(global::Java.Util.Locale);
    552. 

  552. 				}
    553. 

  553. 

  554. 		}
    555. 

  555. 

  556. 		/// <summary>
    557. 

  557. 		/// <para>Implementation of a client-side HTTP connection that can be bound to a network Socket in order to receive and transmit data.</para><para><para></para><para></para><title>Revision:</title><para>561083 </para></para><para><para>4.0 </para></para>    
    558. 

  558. 		/// </summary>
    559. 

  559. 		/// <java-name>
    560. 

  560. 		/// org/apache/http/impl/SocketHttpClientConnection
    561. 

  561. 		/// </java-name>
    562. 

  562. 		[Dot42.DexImport("org/apache/http/impl/SocketHttpClientConnection", AccessFlags = 33)]
    563. 

  563. 		public partial class SocketHttpClientConnection : global::Org.Apache.Http.Impl.AbstractHttpClientConnection, global::Org.Apache.Http.IHttpInetConnection
    564. 

  564.  /* scope: __dot42__ */ 
    565. 

  565. 		{
    566. 

  566. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    567. 

  567. 				public SocketHttpClientConnection() /* MethodBuilder.Create */ 
    568. 

  568. 				{
    569. 

  569. 				}
    570. 

  570. 

  571. 				/// <java-name>
    572. 

  572. 				/// assertNotOpen
    573. 

  573. 				/// </java-name>
    574. 

  574. 				[Dot42.DexImport("assertNotOpen", "()V", AccessFlags = 4)]
    575. 

  575. 				protected internal virtual void AssertNotOpen() /* MethodBuilder.Create */ 
    576. 

  576. 				{
    577. 

  577. 				}
    578. 

  578. 

  579. 				/// <java-name>
    580. 

  580. 				/// assertOpen
    581. 

  581. 				/// </java-name>
    582. 

  582. 				[Dot42.DexImport("assertOpen", "()V", AccessFlags = 4)]
    583. 

  583. 				protected internal override void AssertOpen() /* MethodBuilder.Create */ 
    584. 

  584. 				{
    585. 

  585. 				}
    586. 

  586. 

  587. 				/// <java-name>
    588. 

  588. 				/// createSessionInputBuffer
    589. 

  589. 				/// </java-name>
    590. 

  590. 				[Dot42.DexImport("createSessionInputBuffer", "(Ljava/net/Socket;ILorg/apache/http/params/HttpParams;)Lorg/apache/http/io/Sessio" +
    591. 

  591.     "nInputBuffer;", AccessFlags = 4)]
    592. 

  592. 				protected internal virtual global::Org.Apache.Http.Io.ISessionInputBuffer CreateSessionInputBuffer(global::Java.Net.Socket socket, int buffersize, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    593. 

  593. 				{
    594. 

  594. 						return default(global::Org.Apache.Http.Io.ISessionInputBuffer);
    595. 

  595. 				}
    596. 

  596. 

  597. 				/// <java-name>
    598. 

  598. 				/// createSessionOutputBuffer
    599. 

  599. 				/// </java-name>
    600. 

  600. 				[Dot42.DexImport("createSessionOutputBuffer", "(Ljava/net/Socket;ILorg/apache/http/params/HttpParams;)Lorg/apache/http/io/Sessio" +
    601. 

  601.     "nOutputBuffer;", AccessFlags = 4)]
    602. 

  602. 				protected internal virtual global::Org.Apache.Http.Io.ISessionOutputBuffer CreateSessionOutputBuffer(global::Java.Net.Socket socket, int buffersize, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    603. 

  603. 				{
    604. 

  604. 						return default(global::Org.Apache.Http.Io.ISessionOutputBuffer);
    605. 

  605. 				}
    606. 

  606. 

  607. 				/// <java-name>
    608. 

  608. 				/// bind
    609. 

  609. 				/// </java-name>
    610. 

  610. 				[Dot42.DexImport("bind", "(Ljava/net/Socket;Lorg/apache/http/params/HttpParams;)V", AccessFlags = 4)]
    611. 

  611. 				protected internal virtual void Bind(global::Java.Net.Socket socket, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    612. 

  612. 				{
    613. 

  613. 				}
    614. 

  614. 

  615. 				/// <summary>
    616. 

  616. 				/// <para>Checks if this connection is open. </para>        
    617. 

  617. 				/// </summary>
    618. 

  618. 				/// <returns>
    619. 

  619. 				/// <para>true if it is open, false if it is closed. </para>
    620. 

  620. 				/// </returns>
    621. 

  621. 				/// <java-name>
    622. 

  622. 				/// isOpen
    623. 

  623. 				/// </java-name>
    624. 

  624. 				[Dot42.DexImport("isOpen", "()Z", AccessFlags = 1)]
    625. 

  625. 				public override bool IsOpen() /* MethodBuilder.Create */ 
    626. 

  626. 				{
    627. 

  627. 						return default(bool);
    628. 

  628. 				}
    629. 

  629. 

  630. 				/// <java-name>
    631. 

  631. 				/// getSocket
    632. 

  632. 				/// </java-name>
    633. 

  633. 				[Dot42.DexImport("getSocket", "()Ljava/net/Socket;", AccessFlags = 4)]
    634. 

  634. 				protected internal virtual global::Java.Net.Socket GetSocket() /* MethodBuilder.Create */ 
    635. 

  635. 				{
    636. 

  636. 						return default(global::Java.Net.Socket);
    637. 

  637. 				}
    638. 

  638. 

  639. 				/// <java-name>
    640. 

  640. 				/// getLocalAddress
    641. 

  641. 				/// </java-name>
    642. 

  642. 				[Dot42.DexImport("getLocalAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    643. 

  643. 				public virtual global::Java.Net.InetAddress GetLocalAddress() /* MethodBuilder.Create */ 
    644. 

  644. 				{
    645. 

  645. 						return default(global::Java.Net.InetAddress);
    646. 

  646. 				}
    647. 

  647. 

  648. 				/// <java-name>
    649. 

  649. 				/// getLocalPort
    650. 

  650. 				/// </java-name>
    651. 

  651. 				[Dot42.DexImport("getLocalPort", "()I", AccessFlags = 1)]
    652. 

  652. 				public virtual int GetLocalPort() /* MethodBuilder.Create */ 
    653. 

  653. 				{
    654. 

  654. 						return default(int);
    655. 

  655. 				}
    656. 

  656. 

  657. 				/// <java-name>
    658. 

  658. 				/// getRemoteAddress
    659. 

  659. 				/// </java-name>
    660. 

  660. 				[Dot42.DexImport("getRemoteAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    661. 

  661. 				public virtual global::Java.Net.InetAddress GetRemoteAddress() /* MethodBuilder.Create */ 
    662. 

  662. 				{
    663. 

  663. 						return default(global::Java.Net.InetAddress);
    664. 

  664. 				}
    665. 

  665. 

  666. 				/// <java-name>
    667. 

  667. 				/// getRemotePort
    668. 

  668. 				/// </java-name>
    669. 

  669. 				[Dot42.DexImport("getRemotePort", "()I", AccessFlags = 1)]
    670. 

  670. 				public virtual int GetRemotePort() /* MethodBuilder.Create */ 
    671. 

  671. 				{
    672. 

  672. 						return default(int);
    673. 

  673. 				}
    674. 

  674. 

  675. 				/// <summary>
    676. 

  676. 				/// <para>Sets the socket timeout value.</para><para></para>        
    677. 

  677. 				/// </summary>
    678. 

  678. 				/// <java-name>
    679. 

  679. 				/// setSocketTimeout
    680. 

  680. 				/// </java-name>
    681. 

  681. 				[Dot42.DexImport("setSocketTimeout", "(I)V", AccessFlags = 1)]
    682. 

  682. 				public override void SetSocketTimeout(int timeout) /* MethodBuilder.Create */ 
    683. 

  683. 				{
    684. 

  684. 				}
    685. 

  685. 

  686. 				/// <summary>
    687. 

  687. 				/// <para>Returns the socket timeout value.</para><para></para>        
    688. 

  688. 				/// </summary>
    689. 

  689. 				/// <returns>
    690. 

  690. 				/// <para>positive value in milliseconds if a timeout is set, <code>0</code> if timeout is disabled or <code>-1</code> if timeout is undefined. </para>
    691. 

  691. 				/// </returns>
    692. 

  692. 				/// <java-name>
    693. 

  693. 				/// getSocketTimeout
    694. 

  694. 				/// </java-name>
    695. 

  695. 				[Dot42.DexImport("getSocketTimeout", "()I", AccessFlags = 1)]
    696. 

  696. 				public override int GetSocketTimeout() /* MethodBuilder.Create */ 
    697. 

  697. 				{
    698. 

  698. 						return default(int);
    699. 

  699. 				}
    700. 

  700. 

  701. 				/// <summary>
    702. 

  702. 				/// <para>Force-closes this connection. This is the only method of a connection which may be called from a different thread to terminate the connection. This method will not attempt to flush the transmitter's internal buffer prior to closing the underlying socket. </para>        
    703. 

  703. 				/// </summary>
    704. 

  704. 				/// <java-name>
    705. 

  705. 				/// shutdown
    706. 

  706. 				/// </java-name>
    707. 

  707. 				[Dot42.DexImport("shutdown", "()V", AccessFlags = 1)]
    708. 

  708. 				public override void Shutdown() /* MethodBuilder.Create */ 
    709. 

  709. 				{
    710. 

  710. 				}
    711. 

  711. 

  712. 				/// <summary>
    713. 

  713. 				/// <para>Closes this connection gracefully. This method will attempt to flush the transmitter's internal buffer prior to closing the underlying socket. This method MUST NOT be called from a different thread to force shutdown of the connection. Use shutdown instead. </para>        
    714. 

  714. 				/// </summary>
    715. 

  715. 				/// <java-name>
    716. 

  716. 				/// close
    717. 

  717. 				/// </java-name>
    718. 

  718. 				[Dot42.DexImport("close", "()V", AccessFlags = 1)]
    719. 

  719. 				public override void Close() /* MethodBuilder.Create */ 
    720. 

  720. 				{
    721. 

  721. 				}
    722. 

  722. 

  723. 				[Dot42.DexImport("org/apache/http/HttpConnection", "isStale", "()Z", AccessFlags = 1025)]
    724. 

  724. 				public override bool IsStale() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    725. 

  725. 				{
    726. 

  726. 						return default(bool);
    727. 

  727. 				}
    728. 

  728. 

  729. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1025)]
    730. 

  730. 				public override global::Org.Apache.Http.IHttpConnectionMetrics GetMetrics() /* TypeBuilder.AddAbstractInterfaceMethods */ 
    731. 

  731. 				{
    732. 

  732. 						return default(global::Org.Apache.Http.IHttpConnectionMetrics);
    733. 

  733. 				}
    734. 

  734. 

  735. 				/// <java-name>
    736. 

  736. 				/// getSocket
    737. 

  737. 				/// </java-name>
    738. 

  738. 				protected internal global::Java.Net.Socket Socket
    739. 

  739. 				{
    740. 

  740. 				[Dot42.DexImport("getSocket", "()Ljava/net/Socket;", AccessFlags = 4)]
    741. 

  741. 						get{ return GetSocket(); }
    742. 

  742. 				}
    743. 

  743. 

  744. 				/// <java-name>
    745. 

  745. 				/// getLocalAddress
    746. 

  746. 				/// </java-name>
    747. 

  747. 				public global::Java.Net.InetAddress LocalAddress
    748. 

  748. 				{
    749. 

  749. 				[Dot42.DexImport("getLocalAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    750. 

  750. 						get{ return GetLocalAddress(); }
    751. 

  751. 				}
    752. 

  752. 

  753. 				/// <java-name>
    754. 

  754. 				/// getLocalPort
    755. 

  755. 				/// </java-name>
    756. 

  756. 				public int LocalPort
    757. 

  757. 				{
    758. 

  758. 				[Dot42.DexImport("getLocalPort", "()I", AccessFlags = 1)]
    759. 

  759. 						get{ return GetLocalPort(); }
    760. 

  760. 				}
    761. 

  761. 

  762. 				/// <java-name>
    763. 

  763. 				/// getRemoteAddress
    764. 

  764. 				/// </java-name>
    765. 

  765. 				public global::Java.Net.InetAddress RemoteAddress
    766. 

  766. 				{
    767. 

  767. 				[Dot42.DexImport("getRemoteAddress", "()Ljava/net/InetAddress;", AccessFlags = 1)]
    768. 

  768. 						get{ return GetRemoteAddress(); }
    769. 

  769. 				}
    770. 

  770. 

  771. 				/// <java-name>
    772. 

  772. 				/// getRemotePort
    773. 

  773. 				/// </java-name>
    774. 

  774. 				public int RemotePort
    775. 

  775. 				{
    776. 

  776. 				[Dot42.DexImport("getRemotePort", "()I", AccessFlags = 1)]
    777. 

  777. 						get{ return GetRemotePort(); }
    778. 

  778. 				}
    779. 

  779. 

  780. 				/// <summary>
    781. 

  781. 				/// <para>Returns the socket timeout value.</para><para></para>        
    782. 

  782. 				/// </summary>
    783. 

  783. 				/// <returns>
    784. 

  784. 				/// <para>positive value in milliseconds if a timeout is set, <code>0</code> if timeout is disabled or <code>-1</code> if timeout is undefined. </para>
    785. 

  785. 				/// </returns>
    786. 

  786. 				/// <java-name>
    787. 

  787. 				/// getSocketTimeout
    788. 

  788. 				/// </java-name>
    789. 

  789. 				public int SocketTimeout
    790. 

  790. 				{
    791. 

  791. 				[Dot42.DexImport("getSocketTimeout", "()I", AccessFlags = 1)]
    792. 

  792. 						get{ return GetSocketTimeout(); }
    793. 

  793. 				[Dot42.DexImport("setSocketTimeout", "(I)V", AccessFlags = 1)]
    794. 

  794. 						set{ SetSocketTimeout(value); }
    795. 

  795. 				}
    796. 

  796. 

  797. 				public global::Org.Apache.Http.IHttpConnectionMetrics Metrics
    798. 

  798. 				{
    799. 

  799. 				[Dot42.DexImport("org/apache/http/HttpConnection", "getMetrics", "()Lorg/apache/http/HttpConnectionMetrics;", AccessFlags = 1025)]
    800. 

  800. 						get{ return GetMetrics(); }
    801. 

  801. 				}
    802. 

  802. 

  803. 		}
    804. 

  804. 

  805. 		/// <summary>
    806. 

  806. 		/// <para>Implementation of the metrics interface. </para>    
    807. 

  807. 		/// </summary>
    808. 

  808. 		/// <java-name>
    809. 

  809. 		/// org/apache/http/impl/HttpConnectionMetricsImpl
    810. 

  810. 		/// </java-name>
    811. 

  811. 		[Dot42.DexImport("org/apache/http/impl/HttpConnectionMetricsImpl", AccessFlags = 33)]
    812. 

  812. 		public partial class HttpConnectionMetricsImpl : global::Org.Apache.Http.IHttpConnectionMetrics
    813. 

  813.  /* scope: __dot42__ */ 
    814. 

  814. 		{
    815. 

  815. 				/// <java-name>
    816. 

  816. 				/// REQUEST_COUNT
    817. 

  817. 				/// </java-name>
    818. 

  818. 				[Dot42.DexImport("REQUEST_COUNT", "Ljava/lang/String;", AccessFlags = 25)]
    819. 

  819. 				public const string REQUEST_COUNT = "http.request-count";
    820. 

  820. 				/// <java-name>
    821. 

  821. 				/// RESPONSE_COUNT
    822. 

  822. 				/// </java-name>
    823. 

  823. 				[Dot42.DexImport("RESPONSE_COUNT", "Ljava/lang/String;", AccessFlags = 25)]
    824. 

  824. 				public const string RESPONSE_COUNT = "http.response-count";
    825. 

  825. 				/// <java-name>
    826. 

  826. 				/// SENT_BYTES_COUNT
    827. 

  827. 				/// </java-name>
    828. 

  828. 				[Dot42.DexImport("SENT_BYTES_COUNT", "Ljava/lang/String;", AccessFlags = 25)]
    829. 

  829. 				public const string SENT_BYTES_COUNT = "http.sent-bytes-count";
    830. 

  830. 				/// <java-name>
    831. 

  831. 				/// RECEIVED_BYTES_COUNT
    832. 

  832. 				/// </java-name>
    833. 

  833. 				[Dot42.DexImport("RECEIVED_BYTES_COUNT", "Ljava/lang/String;", AccessFlags = 25)]
    834. 

  834. 				public const string RECEIVED_BYTES_COUNT = "http.received-bytes-count";
    835. 

  835. 				[Dot42.DexImport("<init>", "(Lorg/apache/http/io/HttpTransportMetrics;Lorg/apache/http/io/HttpTransportMetric" +
    836. 

  836.     "s;)V", AccessFlags = 1)]
    837. 

  837. 				public HttpConnectionMetricsImpl(global::Org.Apache.Http.Io.IHttpTransportMetrics inTransportMetric, global::Org.Apache.Http.Io.IHttpTransportMetrics outTransportMetric) /* MethodBuilder.Create */ 
    838. 

  838. 				{
    839. 

  839. 				}
    840. 

  840. 

  841. 				/// <summary>
    842. 

  842. 				/// <para>Returns the number of bytes transferred over the connection, 0 if not available. </para>        
    843. 

  843. 				/// </summary>
    844. 

  844. 				/// <java-name>
    845. 

  845. 				/// getReceivedBytesCount
    846. 

  846. 				/// </java-name>
    847. 

  847. 				[Dot42.DexImport("getReceivedBytesCount", "()J", AccessFlags = 1)]
    848. 

  848. 				public virtual long GetReceivedBytesCount() /* MethodBuilder.Create */ 
    849. 

  849. 				{
    850. 

  850. 						return default(long);
    851. 

  851. 				}
    852. 

  852. 

  853. 				/// <summary>
    854. 

  854. 				/// <para>Returns the number of bytes transferred over the connection, 0 if not available. </para>        
    855. 

  855. 				/// </summary>
    856. 

  856. 				/// <java-name>
    857. 

  857. 				/// getSentBytesCount
    858. 

  858. 				/// </java-name>
    859. 

  859. 				[Dot42.DexImport("getSentBytesCount", "()J", AccessFlags = 1)]
    860. 

  860. 				public virtual long GetSentBytesCount() /* MethodBuilder.Create */ 
    861. 

  861. 				{
    862. 

  862. 						return default(long);
    863. 

  863. 				}
    864. 

  864. 

  865. 				/// <summary>
    866. 

  866. 				/// <para>Returns the number of requests transferred over the connection, 0 if not available. </para>        
    867. 

  867. 				/// </summary>
    868. 

  868. 				/// <java-name>
    869. 

  869. 				/// getRequestCount
    870. 

  870. 				/// </java-name>
    871. 

  871. 				[Dot42.DexImport("getRequestCount", "()J", AccessFlags = 1)]
    872. 

  872. 				public virtual long GetRequestCount() /* MethodBuilder.Create */ 
    873. 

  873. 				{
    874. 

  874. 						return default(long);
    875. 

  875. 				}
    876. 

  876. 

  877. 				/// <java-name>
    878. 

  878. 				/// incrementRequestCount
    879. 

  879. 				/// </java-name>
    880. 

  880. 				[Dot42.DexImport("incrementRequestCount", "()V", AccessFlags = 1)]
    881. 

  881. 				public virtual void IncrementRequestCount() /* MethodBuilder.Create */ 
    882. 

  882. 				{
    883. 

  883. 				}
    884. 

  884. 

  885. 				/// <summary>
    886. 

  886. 				/// <para>Returns the number of responses transferred over the connection, 0 if not available. </para>        
    887. 

  887. 				/// </summary>
    888. 

  888. 				/// <java-name>
    889. 

  889. 				/// getResponseCount
    890. 

  890. 				/// </java-name>
    891. 

  891. 				[Dot42.DexImport("getResponseCount", "()J", AccessFlags = 1)]
    892. 

  892. 				public virtual long GetResponseCount() /* MethodBuilder.Create */ 
    893. 

  893. 				{
    894. 

  894. 						return default(long);
    895. 

  895. 				}
    896. 

  896. 

  897. 				/// <java-name>
    898. 

  898. 				/// incrementResponseCount
    899. 

  899. 				/// </java-name>
    900. 

  900. 				[Dot42.DexImport("incrementResponseCount", "()V", AccessFlags = 1)]
    901. 

  901. 				public virtual void IncrementResponseCount() /* MethodBuilder.Create */ 
    902. 

  902. 				{
    903. 

  903. 				}
    904. 

  904. 

  905. 				/// <java-name>
    906. 

  906. 				/// getMetric
    907. 

  907. 				/// </java-name>
    908. 

  908. 				[Dot42.DexImport("getMetric", "(Ljava/lang/String;)Ljava/lang/Object;", AccessFlags = 1)]
    909. 

  909. 				public virtual object GetMetric(string metricName) /* MethodBuilder.Create */ 
    910. 

  910. 				{
    911. 

  911. 						return default(object);
    912. 

  912. 				}
    913. 

  913. 

  914. 				/// <java-name>
    915. 

  915. 				/// setMetric
    916. 

  916. 				/// </java-name>
    917. 

  917. 				[Dot42.DexImport("setMetric", "(Ljava/lang/String;Ljava/lang/Object;)V", AccessFlags = 1)]
    918. 

  918. 				public virtual void SetMetric(string metricName, object obj) /* MethodBuilder.Create */ 
    919. 

  919. 				{
    920. 

  920. 				}
    921. 

  921. 

  922. 				/// <summary>
    923. 

  923. 				/// <para>Resets the counts </para>        
    924. 

  924. 				/// </summary>
    925. 

  925. 				/// <java-name>
    926. 

  926. 				/// reset
    927. 

  927. 				/// </java-name>
    928. 

  928. 				[Dot42.DexImport("reset", "()V", AccessFlags = 1)]
    929. 

  929. 				public virtual void Reset() /* MethodBuilder.Create */ 
    930. 

  930. 				{
    931. 

  931. 				}
    932. 

  932. 

  933. 				[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
    934. 

  934. 				internal HttpConnectionMetricsImpl() /* TypeBuilder.AddDefaultConstructor */ 
    935. 

  935. 				{
    936. 

  936. 				}
    937. 

  937. 

  938. 				/// <summary>
    939. 

  939. 				/// <para>Returns the number of bytes transferred over the connection, 0 if not available. </para>        
    940. 

  940. 				/// </summary>
    941. 

  941. 				/// <java-name>
    942. 

  942. 				/// getReceivedBytesCount
    943. 

  943. 				/// </java-name>
    944. 

  944. 				public long ReceivedBytesCount
    945. 

  945. 				{
    946. 

  946. 				[Dot42.DexImport("getReceivedBytesCount", "()J", AccessFlags = 1)]
    947. 

  947. 						get{ return GetReceivedBytesCount(); }
    948. 

  948. 				}
    949. 

  949. 

  950. 				/// <summary>
    951. 

  951. 				/// <para>Returns the number of bytes transferred over the connection, 0 if not available. </para>        
    952. 

  952. 				/// </summary>
    953. 

  953. 				/// <java-name>
    954. 

  954. 				/// getSentBytesCount
    955. 

  955. 				/// </java-name>
    956. 

  956. 				public long SentBytesCount
    957. 

  957. 				{
    958. 

  958. 				[Dot42.DexImport("getSentBytesCount", "()J", AccessFlags = 1)]
    959. 

  959. 						get{ return GetSentBytesCount(); }
    960. 

  960. 				}
    961. 

  961. 

  962. 				/// <summary>
    963. 

  963. 				/// <para>Returns the number of requests transferred over the connection, 0 if not available. </para>        
    964. 

  964. 				/// </summary>
    965. 

  965. 				/// <java-name>
    966. 

  966. 				/// getRequestCount
    967. 

  967. 				/// </java-name>
    968. 

  968. 				public long RequestCount
    969. 

  969. 				{
    970. 

  970. 				[Dot42.DexImport("getRequestCount", "()J", AccessFlags = 1)]
    971. 

  971. 						get{ return GetRequestCount(); }
    972. 

  972. 				}
    973. 

  973. 

  974. 				/// <summary>
    975. 

  975. 				/// <para>Returns the number of responses transferred over the connection, 0 if not available. </para>        
    976. 

  976. 				/// </summary>
    977. 

  977. 				/// <java-name>
    978. 

  978. 				/// getResponseCount
    979. 

  979. 				/// </java-name>
    980. 

  980. 				public long ResponseCount
    981. 

  981. 				{
    982. 

  982. 				[Dot42.DexImport("getResponseCount", "()J", AccessFlags = 1)]
    983. 

  983. 						get{ return GetResponseCount(); }
    984. 

  984. 				}
    985. 

  985. 

  986. 		}
    987. 

  987. 

  988. 		/// <summary>
    989. 

  989. 		/// <para>English reason phrases for HTTP status codes. All status codes defined in RFC1945 (HTTP/1.0), RFC2616 (HTTP/1.1), and RFC2518 (WebDAV) are supported.</para><para><para>Unascribed </para><simplesectsep></simplesectsep><para> </para><simplesectsep></simplesectsep><para></para><para></para><title>Revision:</title><para>505744 </para></para>    
    990. 

  990. 		/// </summary>
    991. 

  991. 		/// <java-name>
    992. 

  992. 		/// org/apache/http/impl/EnglishReasonPhraseCatalog
    993. 

  993. 		/// </java-name>
    994. 

  994. 		[Dot42.DexImport("org/apache/http/impl/EnglishReasonPhraseCatalog", AccessFlags = 33)]
    995. 

  995. 		public partial class EnglishReasonPhraseCatalog : global::Org.Apache.Http.IReasonPhraseCatalog
    996. 

  996.  /* scope: __dot42__ */ 
    997. 

  997. 		{
    998. 

  998. 				/// <summary>
    999. 

  999. 				/// <para>The default instance of this catalog. This catalog is thread safe, so there typically is no need to create other instances. </para>        
    1000. 

  1000. 				/// </summary>
    1001. 

  1001. 				/// <java-name>
    1002. 

  1002. 				/// INSTANCE
    1003. 

  1003. 				/// </java-name>
    1004. 

  1004. 				[Dot42.DexImport("INSTANCE", "Lorg/apache/http/impl/EnglishReasonPhraseCatalog;", AccessFlags = 25)]
    1005. 

  1005. 				public static readonly global::Org.Apache.Http.Impl.EnglishReasonPhraseCatalog INSTANCE;
    1006. 

  1006. 				/// <summary>
    1007. 

  1007. 				/// <para>Restricted default constructor, for derived classes. If you need an instance of this class, use INSTANCE. </para>        
    1008. 

  1008. 				/// </summary>
    1009. 

  1009. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 4)]
    1010. 

  1010. 				protected internal EnglishReasonPhraseCatalog() /* MethodBuilder.Create */ 
    1011. 

  1011. 				{
    1012. 

  1012. 				}
    1013. 

  1013. 

  1014. 				/// <summary>
    1015. 

  1015. 				/// <para>Obtains the reason phrase for a status code.</para><para></para>        
    1016. 

  1016. 				/// </summary>
    1017. 

  1017. 				/// <returns>
    1018. 

  1018. 				/// <para>the reason phrase, or <code>null</code> </para>
    1019. 

  1019. 				/// </returns>
    1020. 

  1020. 				/// <java-name>
    1021. 

  1021. 				/// getReason
    1022. 

  1022. 				/// </java-name>
    1023. 

  1023. 				[Dot42.DexImport("getReason", "(ILjava/util/Locale;)Ljava/lang/String;", AccessFlags = 1)]
    1024. 

  1024. 				public virtual string GetReason(int status, global::Java.Util.Locale loc) /* MethodBuilder.Create */ 
    1025. 

  1025. 				{
    1026. 

  1026. 						return default(string);
    1027. 

  1027. 				}
    1028. 

  1028. 

  1029. 		}
    1030. 

  1030. 

  1031. 		/// <summary>
    1032. 

  1032. 		/// <para>Default implementation of a client-side HTTP connection.</para><para><para></para><para></para><title>Revision:</title><para>561083 </para></para><para><para>4.0 </para></para>    
    1033. 

  1033. 		/// </summary>
    1034. 

  1034. 		/// <java-name>
    1035. 

  1035. 		/// org/apache/http/impl/DefaultHttpClientConnection
    1036. 

  1036. 		/// </java-name>
    1037. 

  1037. 		[Dot42.DexImport("org/apache/http/impl/DefaultHttpClientConnection", AccessFlags = 33)]
    1038. 

  1038. 		public partial class DefaultHttpClientConnection : global::Org.Apache.Http.Impl.SocketHttpClientConnection
    1039. 

  1039.  /* scope: __dot42__ */ 
    1040. 

  1040. 		{
    1041. 

  1041. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    1042. 

  1042. 				public DefaultHttpClientConnection() /* MethodBuilder.Create */ 
    1043. 

  1043. 				{
    1044. 

  1044. 				}
    1045. 

  1045. 

  1046. 				/// <java-name>
    1047. 

  1047. 				/// bind
    1048. 

  1048. 				/// </java-name>
    1049. 

  1049. 				[Dot42.DexImport("bind", "(Ljava/net/Socket;Lorg/apache/http/params/HttpParams;)V", AccessFlags = 1)]
    1050. 

  1050. 				public new virtual void Bind(global::Java.Net.Socket socket, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    1051. 

  1051. 				{
    1052. 

  1052. 				}
    1053. 

  1053. 

  1054. 				/// <java-name>
    1055. 

  1055. 				/// toString
    1056. 

  1056. 				/// </java-name>
    1057. 

  1057. 				[Dot42.DexImport("toString", "()Ljava/lang/String;", AccessFlags = 1)]
    1058. 

  1058. 				public override string ToString() /* MethodBuilder.Create */ 
    1059. 

  1059. 				{
    1060. 

  1060. 						return default(string);
    1061. 

  1061. 				}
    1062. 

  1062. 

  1063. 		}
    1064. 

  1064. 

  1065. 		/// <summary>
    1066. 

  1066. 		/// <para>Default implementation of a strategy deciding about connection re-use. The default implementation first checks some basics, for example whether the connection is still open or whether the end of the request entity can be determined without closing the connection. If these checks pass, the tokens in the "Connection" header will be examined. In the absence of a "Connection" header, the non-standard but commonly used "Proxy-Connection" header takes it's role. A token "close" indicates that the connection cannot be reused. If there is no such token, a token "keep-alive" indicates that the connection should be re-used. If neither token is found, or if there are no "Connection" headers, the default policy for the HTTP version is applied. Since HTTP/1.1, connections are re-used by default. Up until HTTP/1.0, connections are not re-used by default.</para><para><para> </para><simplesectsep></simplesectsep><para></para><para></para><title>Revision:</title><para>602537 </para></para><para><para>4.0 </para></para>    
    1067. 

  1067. 		/// </summary>
    1068. 

  1068. 		/// <java-name>
    1069. 

  1069. 		/// org/apache/http/impl/DefaultConnectionReuseStrategy
    1070. 

  1070. 		/// </java-name>
    1071. 

  1071. 		[Dot42.DexImport("org/apache/http/impl/DefaultConnectionReuseStrategy", AccessFlags = 33)]
    1072. 

  1072. 		public partial class DefaultConnectionReuseStrategy : global::Org.Apache.Http.IConnectionReuseStrategy
    1073. 

  1073.  /* scope: __dot42__ */ 
    1074. 

  1074. 		{
    1075. 

  1075. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    1076. 

  1076. 				public DefaultConnectionReuseStrategy() /* MethodBuilder.Create */ 
    1077. 

  1077. 				{
    1078. 

  1078. 				}
    1079. 

  1079. 

  1080. 				/// <java-name>
    1081. 

  1081. 				/// keepAlive
    1082. 

  1082. 				/// </java-name>
    1083. 

  1083. 				[Dot42.DexImport("keepAlive", "(Lorg/apache/http/HttpResponse;Lorg/apache/http/protocol/HttpContext;)Z", AccessFlags = 1)]
    1084. 

  1084. 				public virtual bool KeepAlive(global::Org.Apache.Http.IHttpResponse response, global::Org.Apache.Http.Protocol.IHttpContext context) /* MethodBuilder.Create */ 
    1085. 

  1085. 				{
    1086. 

  1086. 						return default(bool);
    1087. 

  1087. 				}
    1088. 

  1088. 

  1089. 				/// <summary>
    1090. 

  1090. 				/// <para>Creates a token iterator from a header iterator. This method can be overridden to replace the implementation of the token iterator.</para><para></para>        
    1091. 

  1091. 				/// </summary>
    1092. 

  1092. 				/// <returns>
    1093. 

  1093. 				/// <para>the token iterator </para>
    1094. 

  1094. 				/// </returns>
    1095. 

  1095. 				/// <java-name>
    1096. 

  1096. 				/// createTokenIterator
    1097. 

  1097. 				/// </java-name>
    1098. 

  1098. 				[Dot42.DexImport("createTokenIterator", "(Lorg/apache/http/HeaderIterator;)Lorg/apache/http/TokenIterator;", AccessFlags = 4)]
    1099. 

  1099. 				protected internal virtual global::Org.Apache.Http.ITokenIterator CreateTokenIterator(global::Org.Apache.Http.IHeaderIterator hit) /* MethodBuilder.Create */ 
    1100. 

  1100. 				{
    1101. 

  1101. 						return default(global::Org.Apache.Http.ITokenIterator);
    1102. 

  1102. 				}
    1103. 

  1103. 

  1104. 		}
    1105. 

  1105. 

  1106. 		/// <summary>
    1107. 

  1107. 		/// <para>Abstract client-side HTTP connection capable of transmitting and receiving data using arbitrary SessionInputBuffer and SessionOutputBuffer</para><para><para></para><para></para><title>Revision:</title><para>627457 </para></para><para><para>4.0 </para></para>    
    1108. 

  1108. 		/// </summary>
    1109. 

  1109. 		/// <java-name>
    1110. 

  1110. 		/// org/apache/http/impl/AbstractHttpClientConnection
    1111. 

  1111. 		/// </java-name>
    1112. 

  1112. 		[Dot42.DexImport("org/apache/http/impl/AbstractHttpClientConnection", AccessFlags = 1057)]
    1113. 

  1113. 		public abstract partial class AbstractHttpClientConnection : global::Org.Apache.Http.IHttpClientConnection
    1114. 

  1114.  /* scope: __dot42__ */ 
    1115. 

  1115. 		{
    1116. 

  1116. 				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
    1117. 

  1117. 				public AbstractHttpClientConnection() /* MethodBuilder.Create */ 
    1118. 

  1118. 				{
    1119. 

  1119. 				}
    1120. 

  1120. 

  1121. 				/// <java-name>
    1122. 

  1122. 				/// assertOpen
    1123. 

  1123. 				/// </java-name>
    1124. 

  1124. 				[Dot42.DexImport("assertOpen", "()V", AccessFlags = 1028)]
    1125. 

  1125. 				protected internal abstract void AssertOpen() /* MethodBuilder.Create */ ;
    1126. 

  1126. 

  1127. 				/// <java-name>
    1128. 

  1128. 				/// createEntityDeserializer
    1129. 

  1129. 				/// </java-name>
    1130. 

  1130. 				[Dot42.DexImport("createEntityDeserializer", "()Lorg/apache/http/impl/entity/EntityDeserializer;", AccessFlags = 4)]
    1131. 

  1131. 				protected internal virtual global::Org.Apache.Http.Impl.Entity.EntityDeserializer CreateEntityDeserializer() /* MethodBuilder.Create */ 
    1132. 

  1132. 				{
    1133. 

  1133. 						return default(global::Org.Apache.Http.Impl.Entity.EntityDeserializer);
    1134. 

  1134. 				}
    1135. 

  1135. 

  1136. 				/// <java-name>
    1137. 

  1137. 				/// createEntitySerializer
    1138. 

  1138. 				/// </java-name>
    1139. 

  1139. 				[Dot42.DexImport("createEntitySerializer", "()Lorg/apache/http/impl/entity/EntitySerializer;", AccessFlags = 4)]
    1140. 

  1140. 				protected internal virtual global::Org.Apache.Http.Impl.Entity.EntitySerializer CreateEntitySerializer() /* MethodBuilder.Create */ 
    1141. 

  1141. 				{
    1142. 

  1142. 						return default(global::Org.Apache.Http.Impl.Entity.EntitySerializer);
    1143. 

  1143. 				}
    1144. 

  1144. 

  1145. 				/// <java-name>
    1146. 

  1146. 				/// createHttpResponseFactory
    1147. 

  1147. 				/// </java-name>
    1148. 

  1148. 				[Dot42.DexImport("createHttpResponseFactory", "()Lorg/apache/http/HttpResponseFactory;", AccessFlags = 4)]
    1149. 

  1149. 				protected internal virtual global::Org.Apache.Http.IHttpResponseFactory CreateHttpResponseFactory() /* MethodBuilder.Create */ 
    1150. 

  1150. 				{
    1151. 

  1151. 						return default(global::Org.Apache.Http.IHttpResponseFactory);
    1152. 

  1152. 				}
    1153. 

  1153. 

  1154. 				/// <java-name>
    1155. 

  1155. 				/// createResponseParser
    1156. 

  1156. 				/// </java-name>
    1157. 

  1157. 				[Dot42.DexImport("createResponseParser", "(Lorg/apache/http/io/SessionInputBuffer;Lorg/apache/http/HttpResponseFactory;Lorg" +
    1158. 

  1158.     "/apache/http/params/HttpParams;)Lorg/apache/http/io/HttpMessageParser;", AccessFlags = 4)]
    1159. 

  1159. 				protected internal virtual global::Org.Apache.Http.Io.IHttpMessageParser CreateResponseParser(global::Org.Apache.Http.Io.ISessionInputBuffer buffer, global::Org.Apache.Http.IHttpResponseFactory responseFactory, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    1160. 

  1160. 				{
    1161. 

  1161. 						return default(global::Org.Apache.Http.Io.IHttpMessageParser);
    1162. 

  1162. 				}
    1163. 

  1163. 

  1164. 				/// <java-name>
    1165. 

  1165. 				/// createRequestWriter
    1166. 

  1166. 				/// </java-name>
    1167. 

  1167. 				[Dot42.DexImport("createRequestWriter", "(Lorg/apache/http/io/SessionOutputBuffer;Lorg/apache/http/params/HttpParams;)Lorg" +
    1168. 

  1168.     "/apache/http/io/HttpMessageWriter;", AccessFlags = 4)]
    1169. 

  1169. 				protected internal virtual global::Org.Apache.Http.Io.IHttpMessageWriter CreateRequestWriter(global::Org.Apache.Http.Io.ISessionOutputBuffer buffer, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    1170. 

  1170. 				{
    1171. 

  1171. 						return default(global::Org.Apache.Http.Io.IHttpMessageWriter);
    1172. 

  1172. 				}
    1173. 

  1173. 

  1174. 				/// <java-name>
    1175. 

  1175. 				/// init
    1176. 

  1176. 				/// </java-name>
    1177. 

  1177. 				[Dot42.DexImport("init", "(Lorg/apache/http/io/SessionInputBuffer;Lorg/apache/http/io/SessionOutputBuffer;L" +
    1178. 

  1178.     "org/apache/http/params/HttpParams;)V", AccessFlags = 4)]
    1179. 

  1179. 				protected internal virtual void Init(global::Org.Apache.Http.Io.ISessionInputBuffer inbuffer, global::Org.Apache.Http.Io.ISessionOutputBuffer outbuffer, global::Org.Apache.Http.Params.IHttpParams @params) /* MethodBuilder.Create */ 
    1180. 

  1180. 				{
    1181. 

  1181. 				}
    1182. 

  1182. 

  1183. 				/// <summary>
    1184. 

  1184. 				/// <para>Checks if response data is available from the connection. May wait for the specified time until some data becomes available. Note that some implementations may completely ignore the timeout parameter.</para><para></para>        
    1185. 

  1185. 				/// </summary>
    1186. 

  1186. 				/// <returns>
    1187. 

  1187. 				/// <para>true if data is available; false if there was no data available even after waiting for <code>timeout</code> milliseconds. </para>
    1188. 

  1188. 				/// </returns>
    1189. 

  1189. 				/// <java-name>
    1190. 

  1190. 				/// isResponseAvailable
    1191. 

  1191. 				/// </java-name>
    1192. 

  1192. 				[Dot42.DexImport("isResponseAvailable", "(I)Z", AccessFlags = 1)]
    1193. 

  1193. 				public virtual bool IsResponseAvailable(int timeout) /* MethodBuilder.Create */ 
    1194. 

  1194. 				{
    1195. 

  1195. 						return default(bool);
    1196. 

  1196. 				}
    1197. 

  1197. 

  1198. 				/// <java-name>
    1199. 

  1199. 				/// sendRequestHeader
    1200. 

  1200. 				/// </java-name>
    1201. 

  1201. 				[Dot42.DexImport("sendRequestHeader", "(Lorg/apache/http/HttpRequest;)V", AccessFlags = 1)]
    1202. 

  1202. 				public virtual void SendRequestHeader(global::Org.Apache.Http.IHttpRequest request) /* MethodBuilder.Create */ 
    1203. 

  1203. 				{
    1204. 

  1204. 				}
    1205. 

  1205. 

  1206. 				/// <java-name>
    1207. 

  1207. 				/// sendRequestEntity
    1208. 

  1208. 				/// </java-name>
    1209. 

  1209. 				[Dot42.DexImport("sendRequestEntity", "(Lorg/apache/http/HttpEntityEnclosingRequest;)V", AccessFlags = 1)]
    1210. 

  1210. 				public virtual void SendRequestEntity(global::Org.Apache.Http.IHttpEntityEnclosingRequest request) /* MethodBuilder.Create */ 
    1211. 

  1211. 				{
    1212. 

  1212. 				}
    1213. 

  1213. 

  1214. 				/// <java-name>
    1215. 

  1215. 				/// doFlush
    1216. 

  1216. 				/// </java-name>
    1217. 

  1217. 				[Dot42.DexImport("doFlush", "()V", AccessFlags = 4)]
    1218. 

  1218. 				protected internal virtual void DoFlush() /* MethodBuilder.Create */ 
    1219. 

  1219. 				{
    1220. 

  1220. 				}
    1221. 

  1221. 

  1222. 				/// <summary>
    1223. 

  1223. 				/// <para>Writes out all pending buffered data over the open connection.</para><para></para>        
    1224. 

  1224. 				/// </summary>
    1225. 

  1225. 				/// <java-name>
    1226. 

  1226. 				/// flush
    1227. 

  1227. 				/// </java-name>
    1228. 

  1228. 				[Dot42.DexImport("flush", "()V", AccessFlags = 1)]
    1229. 

  1229. 				public virtual void Flush() /* MethodBuilder.Create */ 
    1230. 

  1230. 				{
    1231. 

  1231. 				}
    1232. 

  1232. 

  1233. 				/// <summary>
    1234. 

  1234. 				/// <para>Receives the request line and headers of the next response available from this connection. The caller should examine the HttpResponse object to find out if it should try to receive a response entity as well.</para><para></para>        
    1235. 

  1235. 				/// </summary>
    1236. 

  1236. 				/// <returns>
    1237. 

  1237. 				/// <para>a new HttpResponse object with status line and headers initialized. </para>
    1238. 

  1238. 				/// </returns>
    1239. 

  1239. 				/// <java-name>
    1240. 

  1240. 				/// receiveResponseHeader
    1241. 

  1241. 				/// </java-name>
    1242. 

  1242. 				[Dot42.DexImport("receiveResponseHeader", "()Lorg/apache/http/HttpResponse;", AccessFlags = 1)]
    1243. 

  1243. 				public virtual global::Org.Apache.
    1244.