Documentation for tokio-rs/tokio-core@71741f0
diff --git a/.lock b/.lock
new file mode 100755
index 0000000..e69de29
--- /dev/null
+++ b/.lock
diff --git a/.nojekyll b/.nojekyll
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/.nojekyll
diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
new file mode 100644
index 0000000..c69861a
--- /dev/null
+++ b/COPYRIGHT.txt
@@ -0,0 +1,59 @@
+These documentation pages include resources by third parties. This copyright
+file applies only to those resources. The following third party resources are
+included, and carry their own copyright notices and license terms:
+
+* Fira Sans (FiraSans-Regular.woff, FiraSans-Medium.woff):
+
+ Copyright (c) 2014, Mozilla Foundation https://mozilla.org/
+ with Reserved Font Name Fira Sans.
+
+ Copyright (c) 2014, Telefonica S.A.
+
+ Licensed under the SIL Open Font License, Version 1.1.
+ See FiraSans-LICENSE.txt.
+
+* Heuristica (Heuristica-Italic.woff):
+
+ Copyright 1989, 1991 Adobe Systems Incorporated. All rights reserved.
+ Utopia is either a registered trademark or trademark of Adobe Systems
+ Incorporated in the United States and/or other countries. Used under
+ license.
+
+ Copyright 2006 Han The Thanh, Vntopia font family, http://vntex.sf.net
+
+ Copyright (c) 2008-2012, Andrey V. Panov (panov@canopus.iacp.dvo.ru),
+ with Reserved Font Name Heuristica.
+
+ Licensed under the SIL Open Font License, Version 1.1.
+ See Heuristica-LICENSE.txt.
+
+* rustdoc.css, main.js, and playpen.js:
+
+ Copyright 2015 The Rust Developers.
+ Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE.txt) or
+ the MIT license (LICENSE-MIT.txt) at your option.
+
+* normalize.css:
+
+ Copyright (c) Nicolas Gallagher and Jonathan Neal.
+ Licensed under the MIT license (see LICENSE-MIT.txt).
+
+* Source Code Pro (SourceCodePro-Regular.woff, SourceCodePro-Semibold.woff):
+
+ Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/),
+ with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark
+ of Adobe Systems Incorporated in the United States and/or other countries.
+
+ Licensed under the SIL Open Font License, Version 1.1.
+ See SourceCodePro-LICENSE.txt.
+
+* Source Serif Pro (SourceSerifPro-Regular.woff, SourceSerifPro-Bold.woff):
+
+ Copyright 2014 Adobe Systems Incorporated (http://www.adobe.com/), with
+ Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of
+ Adobe Systems Incorporated in the United States and/or other countries.
+
+ Licensed under the SIL Open Font License, Version 1.1.
+ See SourceSerifPro-LICENSE.txt.
+
+This copyright file is intended to be distributed with rustdoc output.
diff --git a/FiraSans-LICENSE.txt b/FiraSans-LICENSE.txt
new file mode 100644
index 0000000..b4a3967
--- /dev/null
+++ b/FiraSans-LICENSE.txt
@@ -0,0 +1,99 @@
+Copyright (c) 2014, Mozilla Foundation https://mozilla.org/
+with Reserved Font Name Fira Sans.
+
+Copyright (c) 2014, Mozilla Foundation https://mozilla.org/
+with Reserved Font Name Fira Mono.
+
+Copyright (c) 2014, Telefonica S.A.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/FiraSans-Medium.woff b/FiraSans-Medium.woff
new file mode 100644
index 0000000..5627227
--- /dev/null
+++ b/FiraSans-Medium.woff
Binary files differ
diff --git a/FiraSans-Regular.woff b/FiraSans-Regular.woff
new file mode 100644
index 0000000..9ff4044
--- /dev/null
+++ b/FiraSans-Regular.woff
Binary files differ
diff --git a/Heuristica-Italic.woff b/Heuristica-Italic.woff
new file mode 100644
index 0000000..b0cebf0
--- /dev/null
+++ b/Heuristica-Italic.woff
Binary files differ
diff --git a/Heuristica-LICENSE.txt b/Heuristica-LICENSE.txt
new file mode 100644
index 0000000..dd85e40
--- /dev/null
+++ b/Heuristica-LICENSE.txt
@@ -0,0 +1,101 @@
+Copyright 1989, 1991 Adobe Systems Incorporated. All rights reserved.
+Utopia is either a registered trademark or trademark of Adobe Systems
+Incorporated in the United States and/or other countries. Used under
+license.
+
+Copyright 2006 Han The Thanh, Vntopia font family, http://vntex.sf.net
+
+Copyright (c) 2008-2012, Andrey V. Panov (panov@canopus.iacp.dvo.ru),
+with Reserved Font Name Heuristica.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/LICENSE-APACHE.txt b/LICENSE-APACHE.txt
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/LICENSE-APACHE.txt
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/LICENSE-MIT.txt b/LICENSE-MIT.txt
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/LICENSE-MIT.txt
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/SourceCodePro-LICENSE.txt b/SourceCodePro-LICENSE.txt
new file mode 100644
index 0000000..0754257
--- /dev/null
+++ b/SourceCodePro-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/SourceCodePro-Regular.woff b/SourceCodePro-Regular.woff
new file mode 100644
index 0000000..5576670
--- /dev/null
+++ b/SourceCodePro-Regular.woff
Binary files differ
diff --git a/SourceCodePro-Semibold.woff b/SourceCodePro-Semibold.woff
new file mode 100644
index 0000000..ca972a1
--- /dev/null
+++ b/SourceCodePro-Semibold.woff
Binary files differ
diff --git a/SourceSerifPro-Bold.woff b/SourceSerifPro-Bold.woff
new file mode 100644
index 0000000..ac1b1b3
--- /dev/null
+++ b/SourceSerifPro-Bold.woff
Binary files differ
diff --git a/SourceSerifPro-LICENSE.txt b/SourceSerifPro-LICENSE.txt
new file mode 100644
index 0000000..b77d653
--- /dev/null
+++ b/SourceSerifPro-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2014 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/SourceSerifPro-Regular.woff b/SourceSerifPro-Regular.woff
new file mode 100644
index 0000000..e8c43b8
--- /dev/null
+++ b/SourceSerifPro-Regular.woff
Binary files differ
diff --git a/brush.svg b/brush.svg
new file mode 100644
index 0000000..072264a
--- /dev/null
+++ b/brush.svg
@@ -0,0 +1 @@
+<?xml version="1.0" ?><svg height="1792" viewBox="0 0 1792 1792" width="1792" xmlns="http://www.w3.org/2000/svg"><path d="M1615 0q70 0 122.5 46.5t52.5 116.5q0 63-45 151-332 629-465 752-97 91-218 91-126 0-216.5-92.5t-90.5-219.5q0-128 92-212l638-579q59-54 130-54zm-909 1034q39 76 106.5 130t150.5 76l1 71q4 213-129.5 347t-348.5 134q-123 0-218-46.5t-152.5-127.5-86.5-183-29-220q7 5 41 30t62 44.5 59 36.5 46 17q41 0 55-37 25-66 57.5-112.5t69.5-76 88-47.5 103-25.5 125-10.5z"/></svg>
\ No newline at end of file
diff --git a/dark.css b/dark.css
new file mode 100644
index 0000000..4c6bcab
--- /dev/null
+++ b/dark.css
@@ -0,0 +1,388 @@
+/**
+ * Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+body {
+ background-color: #353535;
+ color: #ddd;
+}
+
+h1, h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {
+ color: #ddd;
+}
+h1.fqn {
+ border-bottom-color: #d2d2d2;
+}
+h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {
+ border-bottom-color: #d2d2d2;
+}
+
+.in-band {
+ background-color: #353535;
+}
+
+.invisible {
+ background: rgba(0, 0, 0, 0);
+}
+
+.docblock code, .docblock-short code {
+ background-color: #2A2A2A;
+}
+pre {
+ background-color: #2A2A2A;
+}
+
+.sidebar {
+ background-color: #505050;
+}
+
+.sidebar .current {
+ background-color: #333;
+}
+
+.source .sidebar {
+ background-color: #353535;
+}
+
+.sidebar .location {
+ border-color: #fff;
+ background: #575757;
+ color: #DDD;
+}
+
+.sidebar .version {
+ border-bottom-color: #DDD;
+}
+
+.sidebar-title {
+ border-top-color: #777;
+ border-bottom-color: #777;
+}
+
+.block a:hover {
+ background: #444;
+}
+
+.line-numbers span { color: #3B91E2; }
+.line-numbers .line-highlighted {
+ background-color: #0a042f !important;
+}
+
+.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5 {
+ border-bottom-color: #DDD;
+}
+
+.docblock table {
+ border-color: #ddd;
+}
+
+.docblock table td {
+ border-top-color: #ddd;
+ border-bottom-color: #ddd;
+}
+
+.docblock table th {
+ border-top-color: #ddd;
+ border-bottom-color: #ddd;
+}
+
+:target { background: #494a3d; }
+
+:target > .in-band {
+ background: #494a3d;
+}
+
+.content .method .where,
+.content .fn .where,
+.content .where.fmt-newline {
+ color: #ddd;
+}
+
+.content .highlighted {
+ color: #eee !important;
+ background-color: #333;
+}
+.content .highlighted a, .content .highlighted span { color: #eee !important; }
+.content .highlighted.trait { background-color: #013191; }
+.content .highlighted.mod { background-color: #803a1b; }
+.content .highlighted.externcrate { background-color: #396bac; }
+.content .highlighted.enum { background-color: #5b4e68; }
+.content .highlighted.struct { background-color: #194e9f; }
+.content .highlighted.fn,
+.content .highlighted.method,
+.content .highlighted.tymethod { background-color: #4950ed; }
+.content .highlighted.type { background-color: #38902c; }
+.content .highlighted.foreigntype { background-color: #b200d6; }
+.content .highlighted.macro { background-color: #217d1c; }
+.content .highlighted.constant,
+.content .highlighted.static { background-color: #0063cc; }
+.content .highlighted.primitive { background-color: #00708a; }
+
+.content span.enum, .content a.enum, .block a.current.enum { color: #82b089; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #ff794d; }
+.content span.type, .content a.type, .block a.current.type { color: #ff7f00; }
+.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #dd7de8; }
+.content span.macro, .content a.macro, .block a.current.macro { color: #09bd00; }
+.content span.union, .content a.union, .block a.current.union { color: #a6ae37; }
+.content span.constant, .content a.constant, .block a.current.constant,
+.content span.static, .content a.static, .block a.current.static { color: #82a5c9; }
+.content span.primitive, .content a.primitive, .block a.current.primitive { color: #43aec7; }
+.content span.externcrate,
+.content span.mod, .content a.mod, .block a.current.mod { color: #bda000; }
+.content span.trait, .content a.trait, .block a.current.trait { color: #b78cf2; }
+.content span.fn, .content a.fn, .block a.current.fn,
+.content span.method, .content a.method, .block a.current.method,
+.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
+.content .fnname{ color: #2BAB63; }
+
+pre.rust .comment { color: #8d8d8b; }
+pre.rust .doccomment { color: #8ca375; }
+
+nav {
+ border-bottom-color: #4e4e4e;
+}
+nav.main .current {
+ border-top-color: #eee;
+ border-bottom-color: #eee;
+}
+nav.main .separator {
+ border-color: #eee;
+}
+a {
+ color: #ddd;
+}
+
+.docblock a, .docblock-short a, .stability a {
+ color: #D2991D;
+}
+
+a.test-arrow {
+ color: #dedede;
+}
+
+.collapse-toggle {
+ color: #999;
+}
+
+.search-input {
+ color: #111;
+ box-shadow: 0 0 0 1px #000, 0 0 0 2px transparent;
+ background-color: #f0f0f0;
+}
+
+.search-input:focus {
+ border-color: #008dfd;
+}
+
+.stab.unstable { background: #FFF5D6; border-color: #FFC600; color: #404040; }
+.stab.deprecated { background: #F3DFFF; border-color: #7F0087; color: #404040; }
+.stab.portability { background: #C4ECFF; border-color: #7BA5DB; color: #404040; }
+
+.module-item .stab {
+ color: #ddd;
+}
+
+#help > div {
+ background: #4d4d4d;
+ border-color: #bfbfbf;
+}
+
+#help dt {
+ border-color: #bfbfbf;
+ background: rgba(0,0,0,0);
+ color: black;
+}
+
+.since {
+ color: grey;
+}
+
+tr.result span.primitive::after {
+ color: #ddd;
+}
+
+.line-numbers :target { background-color: transparent; }
+
+/* Code highlighting */
+pre.rust .kw { color: #ab8ac1; }
+pre.rust .kw-2, pre.rust .prelude-ty { color: #769acb; }
+pre.rust .number, pre.rust .string { color: #83a300; }
+pre.rust .self, pre.rust .bool-val, pre.rust .prelude-val,
+pre.rust .attribute, pre.rust .attribute .ident { color: #ee6868; }
+pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999F; }
+pre.rust .lifetime { color: #d97f26; }
+pre.rust .question-mark {
+ color: #ff9011;
+}
+
+a.test-arrow {
+ background-color: rgba(78, 139, 202, 0.2);
+}
+
+a.test-arrow:hover{
+ background-color: #4e8bca;
+}
+
+.toggle-label {
+ color: #999;
+}
+
+:target > code {
+ background: #FDFFD3;
+}
+
+pre.compile_fail {
+ border-left: 2px solid rgba(255,0,0,.6);
+}
+
+pre.compile_fail:hover, .information:hover + pre.compile_fail {
+ border-left: 2px solid #f00;
+}
+
+pre.ignore {
+ border-left: 2px solid rgba(255,142,0,.6);
+}
+
+pre.ignore:hover, .information:hover + pre.ignore {
+ border-left: 2px solid #ff9200;
+}
+
+.tooltip.compile_fail {
+ color: rgba(255,0,0,.6);
+}
+
+.information > .compile_fail:hover {
+ color: #f00;
+}
+
+.tooltip.ignore {
+ color: rgba(255,142,0,.6);
+}
+
+.information > .ignore:hover {
+ color: rgba(255,142,0,1);
+}
+
+.search-failed > a {
+ color: #0089ff;
+}
+
+.tooltip .tooltiptext {
+ background-color: black;
+ color: #fff;
+}
+
+.tooltip .tooltiptext::after {
+ border-color: transparent black transparent transparent;
+}
+
+.important-traits .tooltip .tooltiptext {
+ background-color: white;
+ color: black;
+ border-color: black;
+}
+
+#titles > div {
+ border-bottom-color: #ccc;
+}
+
+#titles > div.selected {
+ border-bottom-color: #0078ee;
+}
+
+#titles > div:hover {
+ border-bottom-color: #0089ff;
+}
+
+#titles > div > div.count {
+ color: #888;
+}
+
+.modal {
+ background-color: rgba(0,0,0,0.3);
+}
+
+.modal-content {
+ background-color: #272727;
+ border-color: #999;
+}
+
+.modal-content > .close {
+ background-color: #272727;
+ border-color: #999;
+}
+
+.modal-content > .close:hover {
+ background-color: #ff1f1f;
+ color: white;
+}
+
+.modal-content > .whiter {
+ background-color: #272727;
+}
+
+.modal-content > .close:hover + .whiter {
+ background-color: #ff1f1f;
+}
+
+@media (max-width: 700px) {
+ .sidebar-menu {
+ background-color: #505050;
+ border-bottom-color: #e0e0e0;
+ border-right-color: #e0e0e0;
+ }
+
+ .sidebar-elems {
+ background-color: #505050;
+ border-right-color: #000;
+ }
+
+ #sidebar-filler {
+ background-color: #505050;
+ border-bottom-color: #e0e0e0;
+ }
+}
+
+kbd {
+ color: #000;
+ background-color: #fafbfc;
+ border-color: #d1d5da;
+ border-bottom-color: #c6cbd1;
+ box-shadow-color: #c6cbd1;
+}
+
+#theme-picker {
+ border-color: #e0e0e0;
+ background: #f0f0f0;
+}
+
+#theme-picker:hover, #theme-picker:focus {
+ border-color: #ffb900;
+}
+
+#theme-choices {
+ border-color: #e0e0e0;
+ background-color: #353535;
+}
+
+#theme-choices > button:not(:first-child) {
+ border-top-color: #e0e0e0;
+}
+
+#theme-choices > button:hover, #theme-choices > button:focus {
+ background-color: #444;
+}
+
+@media (max-width: 700px) {
+ #theme-picker {
+ background: #353535;
+ }
+}
diff --git a/implementors/core/clone/trait.Clone.js b/implementors/core/clone/trait.Clone.js
new file mode 100644
index 0000000..99a82c8
--- /dev/null
+++ b/implementors/core/clone/trait.Clone.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Remote.html\" title=\"struct tokio_core::reactor::Remote\">Remote</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Handle.html\" title=\"struct tokio_core::reactor::Handle\">Handle</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/cmp/trait.Eq.js b/implementors/core/cmp/trait.Eq.js
new file mode 100644
index 0000000..e86fa69
--- /dev/null
+++ b/implementors/core/cmp/trait.Eq.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/cmp/trait.PartialEq.js b/implementors/core/cmp/trait.PartialEq.js
new file mode 100644
index 0000000..12085c3
--- /dev/null
+++ b/implementors/core/cmp/trait.PartialEq.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/fmt/trait.Debug.js b/implementors/core/fmt/trait.Debug.js
new file mode 100644
index 0000000..f043325
--- /dev/null
+++ b/implementors/core/fmt/trait.Debug.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpListener.html\" title=\"struct tokio_core::net::TcpListener\">TcpListener</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/net/struct.UdpSocket.html\" title=\"struct tokio_core::net::UdpSocket\">UdpSocket</a>","impl<E: <a class=\"trait\" href=\"https://docs.rs/mio/0.6.13/mio/event_imp/trait.Evented.html\" title=\"trait mio::event_imp::Evented\">Evented</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Timeout.html\" title=\"struct tokio_core::reactor::Timeout\">Timeout</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Core.html\" title=\"struct tokio_core::reactor::Core\">Core</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Remote.html\" title=\"struct tokio_core::reactor::Remote\">Remote</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Handle.html\" title=\"struct tokio_core::reactor::Handle\">Handle</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/hash/trait.Hash.js b/implementors/core/hash/trait.Hash.js
new file mode 100644
index 0000000..111b7c0
--- /dev/null
+++ b/implementors/core/hash/trait.Hash.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/marker/trait.Copy.js b/implementors/core/marker/trait.Copy.js
new file mode 100644
index 0000000..c097e69
--- /dev/null
+++ b/implementors/core/marker/trait.Copy.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.CoreId.html\" title=\"struct tokio_core::reactor::CoreId\">CoreId</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/core/ops/drop/trait.Drop.js b/implementors/core/ops/drop/trait.Drop.js
new file mode 100644
index 0000000..943c8a2
--- /dev/null
+++ b/implementors/core/ops/drop/trait.Drop.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl<E> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Timeout.html\" title=\"struct tokio_core::reactor::Timeout\">Timeout</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Interval.html\" title=\"struct tokio_core::reactor::Interval\">Interval</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/futures/future/trait.Executor.js b/implementors/futures/future/trait.Executor.js
new file mode 100644
index 0000000..ce90559
--- /dev/null
+++ b/implementors/futures/future/trait.Executor.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl<F> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Executor.html\" title=\"trait futures::future::Executor\">Executor</a><F> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Core.html\" title=\"struct tokio_core::reactor::Core\">Core</a> <span class=\"where fmt-newline\">where<br> F: <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, Error = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>> + 'static, </span>","impl<F> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Executor.html\" title=\"trait futures::future::Executor\">Executor</a><F> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Remote.html\" title=\"struct tokio_core::reactor::Remote\">Remote</a> <span class=\"where fmt-newline\">where<br> F: <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, Error = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + 'static, </span>","impl<F> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Executor.html\" title=\"trait futures::future::Executor\">Executor</a><F> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Handle.html\" title=\"struct tokio_core::reactor::Handle\">Handle</a> <span class=\"where fmt-newline\">where<br> F: <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, Error = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>> + 'static, </span>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/futures/future/trait.Future.js b/implementors/futures/future/trait.Future.js
new file mode 100644
index 0000000..e5f4436
--- /dev/null
+++ b/implementors/futures/future/trait.Future.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStreamNew.html\" title=\"struct tokio_core::net::TcpStreamNew\">TcpStreamNew</a>","impl<T> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a> for <a class=\"struct\" href=\"tokio_core/net/struct.SendDgram.html\" title=\"struct tokio_core::net::SendDgram\">SendDgram</a><T> <span class=\"where fmt-newline\">where<br> T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[</a><a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.u8.html\">u8</a><a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">]</a>>, </span>","impl<T> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a> for <a class=\"struct\" href=\"tokio_core/net/struct.RecvDgram.html\" title=\"struct tokio_core::net::RecvDgram\">RecvDgram</a><T> <span class=\"where fmt-newline\">where<br> T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsMut.html\" title=\"trait core::convert::AsMut\">AsMut</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[</a><a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.u8.html\">u8</a><a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">]</a>>, </span>","impl <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/future/trait.Future.html\" title=\"trait futures::future::Future\">Future</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Timeout.html\" title=\"struct tokio_core::reactor::Timeout\">Timeout</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/futures/sink/trait.Sink.js b/implementors/futures/sink/trait.Sink.js
new file mode 100644
index 0000000..92be9fc
--- /dev/null
+++ b/implementors/futures/sink/trait.Sink.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl<C: <a class=\"trait\" href=\"tokio_core/net/trait.UdpCodec.html\" title=\"trait tokio_core::net::UdpCodec\">UdpCodec</a>> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/sink/trait.Sink.html\" title=\"trait futures::sink::Sink\">Sink</a> for <a class=\"struct\" href=\"tokio_core/net/struct.UdpFramed.html\" title=\"struct tokio_core::net::UdpFramed\">UdpFramed</a><C>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/futures/stream/trait.Stream.js b/implementors/futures/stream/trait.Stream.js
new file mode 100644
index 0000000..97f0ea7
--- /dev/null
+++ b/implementors/futures/stream/trait.Stream.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/stream/trait.Stream.html\" title=\"trait futures::stream::Stream\">Stream</a> for <a class=\"struct\" href=\"tokio_core/net/struct.Incoming.html\" title=\"struct tokio_core::net::Incoming\">Incoming</a>","impl<C: <a class=\"trait\" href=\"tokio_core/net/trait.UdpCodec.html\" title=\"trait tokio_core::net::UdpCodec\">UdpCodec</a>> <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/stream/trait.Stream.html\" title=\"trait futures::stream::Stream\">Stream</a> for <a class=\"struct\" href=\"tokio_core/net/struct.UdpFramed.html\" title=\"struct tokio_core::net::UdpFramed\">UdpFramed</a><C>","impl <a class=\"trait\" href=\"https://docs.rs/futures/0.1/futures/stream/trait.Stream.html\" title=\"trait futures::stream::Stream\">Stream</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.Interval.html\" title=\"struct tokio_core::reactor::Interval\">Interval</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/std/io/trait.Read.js b/implementors/std/io/trait.Read.js
new file mode 100644
index 0000000..c78ab50
--- /dev/null
+++ b/implementors/std/io/trait.Read.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<'a> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a> for &'a <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl<'a, E> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a> for &'a <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E> <span class=\"where fmt-newline\">where<br> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a </a>E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a>, </span>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/std/io/trait.Write.js b/implementors/std/io/trait.Write.js
new file mode 100644
index 0000000..dd119f3
--- /dev/null
+++ b/implementors/std/io/trait.Write.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<'a> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a> for &'a <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl<'a, E> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a> for &'a <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E> <span class=\"where fmt-newline\">where<br> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a </a>E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a>, </span>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/std/sys/unix/ext/io/trait.AsRawFd.js b/implementors/std/sys/unix/ext/io/trait.AsRawFd.js
new file mode 100644
index 0000000..b993dec
--- /dev/null
+++ b/implementors/std/sys/unix/ext/io/trait.AsRawFd.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html\" title=\"trait std::sys::unix::ext::io::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html\" title=\"trait std::sys::unix::ext::io::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpListener.html\" title=\"struct tokio_core::net::TcpListener\">TcpListener</a>","impl <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html\" title=\"trait std::sys::unix::ext::io::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"tokio_core/net/struct.UdpSocket.html\" title=\"struct tokio_core::net::UdpSocket\">UdpSocket</a>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/tokio_io/trait.AsyncRead.js b/implementors/tokio_io/trait.AsyncRead.js
new file mode 100644
index 0000000..e7eefd6
--- /dev/null
+++ b/implementors/tokio_io/trait.AsyncRead.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html\" title=\"trait tokio_io::AsyncRead\">AsyncRead</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<'a> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html\" title=\"trait tokio_io::AsyncRead\">AsyncRead</a> for &'a <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a>> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html\" title=\"trait tokio_io::AsyncRead\">AsyncRead</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl<'a, E> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html\" title=\"trait tokio_io::AsyncRead\">AsyncRead</a> for &'a <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E> <span class=\"where fmt-newline\">where<br> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a </a>E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Read.html\" title=\"trait std::io::Read\">Read</a>, </span>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/implementors/tokio_io/trait.AsyncWrite.js b/implementors/tokio_io/trait.AsyncWrite.js
new file mode 100644
index 0000000..c012ab8
--- /dev/null
+++ b/implementors/tokio_io/trait.AsyncWrite.js
@@ -0,0 +1,10 @@
+(function() {var implementors = {};
+implementors["tokio_core"] = ["impl <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html\" title=\"trait tokio_io::AsyncWrite\">AsyncWrite</a> for <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<'a> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html\" title=\"trait tokio_io::AsyncWrite\">AsyncWrite</a> for &'a <a class=\"struct\" href=\"tokio_core/net/struct.TcpStream.html\" title=\"struct tokio_core::net::TcpStream\">TcpStream</a>","impl<E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a>> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html\" title=\"trait tokio_io::AsyncWrite\">AsyncWrite</a> for <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E>","impl<'a, E> <a class=\"trait\" href=\"https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html\" title=\"trait tokio_io::AsyncWrite\">AsyncWrite</a> for &'a <a class=\"struct\" href=\"tokio_core/reactor/struct.PollEvented.html\" title=\"struct tokio_core::reactor::PollEvented\">PollEvented</a><E> <span class=\"where fmt-newline\">where<br> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a </a>E: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/io/trait.Write.html\" title=\"trait std::io::Write\">Write</a>, </span>",];
+
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+
+})()
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..ba2df60
--- /dev/null
+++ b/index.html
@@ -0,0 +1 @@
+<meta http-equiv=refresh content=0;url=tokio_core/index.html>
\ No newline at end of file
diff --git a/main.css b/main.css
new file mode 100644
index 0000000..e076464
--- /dev/null
+++ b/main.css
@@ -0,0 +1,385 @@
+/**
+ * Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+/* General structure and fonts */
+
+body {
+ background-color: white;
+ color: black;
+}
+
+h1, h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {
+ color: black;
+}
+h1.fqn {
+ border-bottom-color: #D5D5D5;
+}
+h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {
+ border-bottom-color: #DDDDDD;
+}
+
+.in-band {
+ background-color: white;
+}
+
+.invisible {
+ background: rgba(0, 0, 0, 0);
+}
+
+.docblock code, .docblock-short code {
+ background-color: #F5F5F5;
+}
+pre {
+ background-color: #F5F5F5;
+}
+
+.sidebar {
+ background-color: #F1F1F1;
+}
+
+.sidebar .current {
+ background-color: #fff;
+}
+
+.source .sidebar {
+ background-color: #fff;
+}
+
+.sidebar .location {
+ border-color: #000;
+ background-color: #fff;
+ color: #333;
+}
+
+.sidebar .version {
+ border-bottom-color: #DDD;
+}
+
+.sidebar-title {
+ border-top-color: #777;
+ border-bottom-color: #777;
+}
+
+.block a:hover {
+ background: #F5F5F5;
+}
+
+.line-numbers span { color: #c67e2d; }
+.line-numbers .line-highlighted {
+ background-color: #f6fdb0 !important;
+}
+
+.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5 {
+ border-bottom-color: #DDD;
+}
+
+.docblock table {
+ border-color: #ddd;
+}
+
+.docblock table td {
+ border-top-color: #ddd;
+ border-bottom-color: #ddd;
+}
+
+.docblock table th {
+ border-top-color: #ddd;
+ border-bottom-color: #ddd;
+}
+
+:target { background: #FDFFD3; }
+
+:target > .in-band {
+ background: #FDFFD3;
+}
+
+.content .method .where,
+.content .fn .where,
+.content .where.fmt-newline {
+ color: #4E4C4C;
+}
+
+.content .highlighted {
+ color: #000 !important;
+ background-color: #ccc;
+}
+.content .highlighted a, .content .highlighted span { color: #000 !important; }
+.content .highlighted.trait { background-color: #c7b6ff; }
+.content .highlighted.mod,
+.content .highlighted.externcrate { background-color: #afc6e4; }
+.content .highlighted.enum { background-color: #b4d1b9; }
+.content .highlighted.struct { background-color: #e7b1a0; }
+.content .highlighted.union { background-color: #b7bd49; }
+.content .highlighted.fn,
+.content .highlighted.method,
+.content .highlighted.tymethod { background-color: #c6afb3; }
+.content .highlighted.type { background-color: #ffc891; }
+.content .highlighted.foreigntype { background-color: #f5c4ff; }
+.content .highlighted.macro { background-color: #8ce488; }
+.content .highlighted.constant,
+.content .highlighted.static { background-color: #c3e0ff; }
+.content .highlighted.primitive { background-color: #9aecff; }
+
+.content span.enum, .content a.enum, .block a.current.enum { color: #508157; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #df3600; }
+.content span.type, .content a.type, .block a.current.type { color: #ba5d00; }
+.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #cd00e2; }
+.content span.macro, .content a.macro, .block a.current.macro { color: #068000; }
+.content span.union, .content a.union, .block a.current.union { color: #767b27; }
+.content span.constant, .content a.constant, .block a.current.constant,
+.content span.static, .content a.static, .block a.current.static { color: #546e8a; }
+.content span.primitive, .content a.primitive, .block a.current.primitive { color: #2c8093; }
+.content span.externcrate,
+.content span.mod, .content a.mod, .block a.current.mod { color: #4d76ae; }
+.content span.trait, .content a.trait, .block a.current.trait { color: #7c5af3; }
+.content span.fn, .content a.fn, .block a.current.fn,
+.content span.method, .content a.method, .block a.current.method,
+.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
+.content .fnname { color: #9a6e31; }
+
+pre.rust .comment { color: #8E908C; }
+pre.rust .doccomment { color: #4D4D4C; }
+
+nav {
+ border-bottom-color: #e0e0e0;
+}
+nav.main .current {
+ border-top-color: #000;
+ border-bottom-color: #000;
+}
+nav.main .separator {
+ border: 1px solid #000;
+}
+a {
+ color: #000;
+}
+
+.docblock a, .docblock-short a, .stability a {
+ color: #3873AD;
+}
+
+a.test-arrow {
+ color: #f5f5f5;
+}
+
+.collapse-toggle {
+ color: #999;
+}
+
+.search-input {
+ color: #555;
+ box-shadow: 0 0 0 1px #e0e0e0, 0 0 0 2px transparent;
+ background-color: white;
+}
+
+.search-input:focus {
+ border-color: #66afe9;
+}
+
+.stab.unstable { background: #FFF5D6; border-color: #FFC600; }
+.stab.deprecated { background: #F3DFFF; border-color: #7F0087; }
+.stab.portability { background: #C4ECFF; border-color: #7BA5DB; }
+
+.module-item .stab {
+ color: #000;
+}
+
+#help > div {
+ background: #e9e9e9;
+ border-color: #bfbfbf;
+}
+
+.since {
+ color: grey;
+}
+
+tr.result span.primitive::after {
+ color: black;
+}
+
+.line-numbers :target { background-color: transparent; }
+
+/* Code highlighting */
+pre.rust .kw { color: #8959A8; }
+pre.rust .kw-2, pre.rust .prelude-ty { color: #4271AE; }
+pre.rust .number, pre.rust .string { color: #718C00; }
+pre.rust .self, pre.rust .bool-val, pre.rust .prelude-val,
+pre.rust .attribute, pre.rust .attribute .ident { color: #C82829; }
+pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999F; }
+pre.rust .lifetime { color: #B76514; }
+pre.rust .question-mark {
+ color: #ff9011;
+}
+
+a.test-arrow {
+ background-color: rgba(78, 139, 202, 0.2);
+}
+
+a.test-arrow:hover{
+ background-color: #4e8bca;
+}
+
+.toggle-label {
+ color: #999;
+}
+
+:target > code {
+ background: #FDFFD3;
+}
+
+pre.compile_fail {
+ border-left: 2px solid rgba(255,0,0,.4);
+}
+
+pre.compile_fail:hover, .information:hover + pre.compile_fail {
+ border-left: 2px solid #f00;
+}
+
+pre.ignore {
+ border-left: 2px solid rgba(255,142,0,.4);
+}
+
+pre.ignore:hover, .information:hover + pre.ignore {
+ border-left: 2px solid #ff9200;
+}
+
+.tooltip.compile_fail {
+ color: rgba(255,0,0,.3);
+}
+
+.information > .compile_fail:hover {
+ color: #f00;
+}
+
+.tooltip.ignore {
+ color: rgba(255,142,0,.3);
+}
+
+.information > .ignore:hover {
+ color: rgba(255,142,0,1);
+}
+
+.search-failed > a {
+ color: #0089ff;
+}
+
+.tooltip .tooltiptext {
+ background-color: black;
+ color: #fff;
+}
+
+.tooltip .tooltiptext::after {
+ border-color: transparent black transparent transparent;
+}
+
+.important-traits .tooltip .tooltiptext {
+ background-color: white;
+ color: black;
+ border-color: black;
+}
+
+#titles > div {
+ border-bottom-color: #ccc;
+}
+
+#titles > div.selected {
+ border-bottom-color: #0078ee;
+}
+
+#titles > div:hover {
+ border-bottom-color: #0089ff;
+}
+
+#titles > div > div.count {
+ color: #888;
+}
+
+.modal {
+ background-color: rgba(0,0,0,0.3);
+}
+
+.modal-content {
+ background-color: #eee;
+ border-color: #999;
+}
+
+.modal-content > .close {
+ background-color: #eee;
+ border-color: #999;
+}
+
+.modal-content > .close:hover {
+ background-color: #ff1f1f;
+ color: white;
+}
+
+.modal-content > .whiter {
+ background-color: #eee;
+}
+
+.modal-content > .close:hover + .whiter {
+ background-color: #ff1f1f;
+}
+
+@media (max-width: 700px) {
+ .sidebar-menu {
+ background-color: #F1F1F1;
+ border-bottom-color: #e0e0e0;
+ border-right-color: #e0e0e0;
+ }
+
+ .sidebar-elems {
+ background-color: #F1F1F1;
+ border-right-color: #000;
+ }
+
+ #sidebar-filler {
+ background-color: #F1F1F1;
+ border-bottom-color: #e0e0e0;
+ }
+}
+
+kbd {
+ color: #000;
+ background-color: #fafbfc;
+ border-color: #d1d5da;
+ border-bottom-color: #c6cbd1;
+ box-shadow-color: #c6cbd1;
+}
+
+#theme-picker {
+ border-color: #e0e0e0;
+ background-color: #fff;
+}
+
+#theme-picker:hover, #theme-picker:focus {
+ border-color: #717171;
+}
+
+#theme-choices {
+ border-color: #ccc;
+ background-color: #fff;
+}
+
+#theme-choices > button:not(:first-child) {
+ border-top-color: #e0e0e0;
+}
+
+#theme-choices > button:hover, #theme-choices > button:focus {
+ background-color: #eee;
+}
+
+@media (max-width: 700px) {
+ #theme-picker {
+ background: #fff;
+ }
+}
diff --git a/main.js b/main.js
new file mode 100644
index 0000000..0f9e700
--- /dev/null
+++ b/main.js
@@ -0,0 +1,1902 @@
+/*!
+ * Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+/*jslint browser: true, es5: true */
+/*globals $: true, rootPath: true */
+
+(function() {
+ "use strict";
+
+ // This mapping table should match the discriminants of
+ // `rustdoc::html::item_type::ItemType` type in Rust.
+ var itemTypes = ["mod",
+ "externcrate",
+ "import",
+ "struct",
+ "enum",
+ "fn",
+ "type",
+ "static",
+ "trait",
+ "impl",
+ "tymethod",
+ "method",
+ "structfield",
+ "variant",
+ "macro",
+ "primitive",
+ "associatedtype",
+ "constant",
+ "associatedconstant",
+ "union",
+ "foreigntype"];
+
+ // On the search screen, so you remain on the last tab you opened.
+ //
+ // 0 for "In Names"
+ // 1 for "In Parameters"
+ // 2 for "In Return Types"
+ var currentTab = 0;
+
+ function hasClass(elem, className) {
+ if (elem && className && elem.className) {
+ var elemClass = elem.className;
+ var start = elemClass.indexOf(className);
+ if (start === -1) {
+ return false;
+ } else if (elemClass.length === className.length) {
+ return true;
+ } else {
+ if (start > 0 && elemClass[start - 1] !== ' ') {
+ return false;
+ }
+ var end = start + className.length;
+ if (end < elemClass.length && elemClass[end] !== ' ') {
+ return false;
+ }
+ return true;
+ }
+ if (start > 0 && elemClass[start - 1] !== ' ') {
+ return false;
+ }
+ var end = start + className.length;
+ if (end < elemClass.length && elemClass[end] !== ' ') {
+ return false;
+ }
+ return true;
+ }
+ return false;
+ }
+
+ function addClass(elem, className) {
+ if (elem && className && !hasClass(elem, className)) {
+ if (elem.className && elem.className.length > 0) {
+ elem.className += ' ' + className;
+ } else {
+ elem.className = className;
+ }
+ }
+ }
+
+ function removeClass(elem, className) {
+ if (elem && className && elem.className) {
+ elem.className = (" " + elem.className + " ").replace(" " + className + " ", " ")
+ .trim();
+ }
+ }
+
+ function onEach(arr, func) {
+ if (arr && arr.length > 0 && func) {
+ for (var i = 0; i < arr.length; i++) {
+ func(arr[i]);
+ }
+ }
+ }
+
+ function isHidden(elem) {
+ return (elem.offsetParent === null)
+ }
+
+ function showSidebar() {
+ var elems = document.getElementsByClassName("sidebar-elems")[0];
+ if (elems) {
+ addClass(elems, "show-it");
+ }
+ var sidebar = document.getElementsByClassName('sidebar')[0];
+ if (sidebar) {
+ addClass(sidebar, 'mobile');
+ var filler = document.getElementById("sidebar-filler");
+ if (!filler) {
+ var div = document.createElement("div");
+ div.id = "sidebar-filler";
+ sidebar.appendChild(div);
+ }
+ }
+ document.getElementsByTagName("body")[0].style.marginTop = '45px';
+ var themePicker = document.getElementById("theme-picker");
+ if (themePicker) {
+ themePicker.style.position = "fixed";
+ }
+ }
+
+ function hideSidebar() {
+ var elems = document.getElementsByClassName("sidebar-elems")[0];
+ if (elems) {
+ removeClass(elems, "show-it");
+ }
+ var sidebar = document.getElementsByClassName('sidebar')[0];
+ removeClass(sidebar, 'mobile');
+ var filler = document.getElementById("sidebar-filler");
+ if (filler) {
+ filler.remove();
+ }
+ document.getElementsByTagName("body")[0].style.marginTop = '';
+ var themePicker = document.getElementById("theme-picker");
+ if (themePicker) {
+ themePicker.style.position = "absolute";
+ }
+ }
+
+ // used for special search precedence
+ var TY_PRIMITIVE = itemTypes.indexOf("primitive");
+
+ onEach(document.getElementsByClassName('js-only'), function(e) {
+ removeClass(e, 'js-only');
+ });
+
+ function getQueryStringParams() {
+ var params = {};
+ window.location.search.substring(1).split("&").
+ map(function(s) {
+ var pair = s.split("=");
+ params[decodeURIComponent(pair[0])] =
+ typeof pair[1] === "undefined" ? null : decodeURIComponent(pair[1]);
+ });
+ return params;
+ }
+
+ function browserSupportsHistoryApi() {
+ return document.location.protocol != "file:" &&
+ window.history && typeof window.history.pushState === "function";
+ }
+
+ function highlightSourceLines(ev) {
+ // If we're in mobile mode, we should add the sidebar in any case.
+ hideSidebar();
+ var search = document.getElementById("search");
+ var i, from, to, match = window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/);
+ if (match) {
+ from = parseInt(match[1], 10);
+ to = Math.min(50000, parseInt(match[2] || match[1], 10));
+ from = Math.min(from, to);
+ var elem = document.getElementById(from);
+ if (!elem) {
+ return;
+ }
+ if (ev === null) {
+ var x = document.getElementById(from);
+ if (x) {
+ x.scrollIntoView();
+ }
+ }
+ onEach(document.getElementsByClassName('line-numbers'), function(e) {
+ onEach(e.getElementsByTagName('span'), function(i_e) {
+ removeClass(i_e, 'line-highlighted');
+ });
+ })
+ for (i = from; i <= to; ++i) {
+ addClass(document.getElementById(i), 'line-highlighted');
+ }
+ } else if (ev !== null && search && !hasClass(search, "hidden") && ev.newURL) {
+ addClass(search, "hidden");
+ removeClass(document.getElementById("main"), "hidden");
+ var hash = ev.newURL.slice(ev.newURL.indexOf('#') + 1);
+ if (browserSupportsHistoryApi()) {
+ history.replaceState(hash, "", "?search=#" + hash);
+ }
+ var elem = document.getElementById(hash);
+ if (elem) {
+ elem.scrollIntoView();
+ }
+ }
+ }
+ highlightSourceLines(null);
+ window.onhashchange = highlightSourceLines;
+
+ // Gets the human-readable string for the virtual-key code of the
+ // given KeyboardEvent, ev.
+ //
+ // This function is meant as a polyfill for KeyboardEvent#key,
+ // since it is not supported in Trident. We also test for
+ // KeyboardEvent#keyCode because the handleShortcut handler is
+ // also registered for the keydown event, because Blink doesn't fire
+ // keypress on hitting the Escape key.
+ //
+ // So I guess you could say things are getting pretty interoperable.
+ function getVirtualKey(ev) {
+ if ("key" in ev && typeof ev.key != "undefined")
+ return ev.key;
+
+ var c = ev.charCode || ev.keyCode;
+ if (c == 27)
+ return "Escape";
+ return String.fromCharCode(c);
+ }
+
+ function displayHelp(display, ev) {
+ if (display === true) {
+ if (hasClass(help, "hidden")) {
+ ev.preventDefault();
+ removeClass(help, "hidden");
+ addClass(document.body, "blur");
+ }
+ } else if (!hasClass(help, "hidden")) {
+ ev.preventDefault();
+ addClass(help, "hidden");
+ removeClass(document.body, "blur");
+ }
+ }
+
+ function handleShortcut(ev) {
+ if (document.activeElement.tagName === "INPUT")
+ return;
+
+ // Don't interfere with browser shortcuts
+ if (ev.ctrlKey || ev.altKey || ev.metaKey)
+ return;
+
+ var help = document.getElementById("help");
+ switch (getVirtualKey(ev)) {
+ case "Escape":
+ hideModal();
+ var search = document.getElementById("search");
+ if (!hasClass(help, "hidden")) {
+ displayHelp(false, ev);
+ } else if (!hasClass(search, "hidden")) {
+ ev.preventDefault();
+ addClass(search, "hidden");
+ removeClass(document.getElementById("main"), "hidden");
+ }
+ defocusSearchBar();
+ break;
+
+ case "s":
+ case "S":
+ displayHelp(false, ev);
+ hideModal();
+ ev.preventDefault();
+ focusSearchBar();
+ break;
+
+ case "+":
+ case "-":
+ ev.preventDefault();
+ toggleAllDocs();
+ break;
+
+ case "?":
+ if (ev.shiftKey) {
+ hideModal();
+ displayHelp(true, ev);
+ }
+ break;
+ }
+ }
+
+ document.onkeypress = handleShortcut;
+ document.onkeydown = handleShortcut;
+ document.onclick = function(ev) {
+ if (hasClass(ev.target, 'collapse-toggle')) {
+ collapseDocs(ev.target);
+ } else if (hasClass(ev.target.parentNode, 'collapse-toggle')) {
+ collapseDocs(ev.target.parentNode);
+ } else if (ev.target.tagName === 'SPAN' && hasClass(ev.target.parentNode, 'line-numbers')) {
+ var prev_id = 0;
+
+ var set_fragment = function (name) {
+ if (browserSupportsHistoryApi()) {
+ history.replaceState(null, null, '#' + name);
+ window.hashchange();
+ } else {
+ location.replace('#' + name);
+ }
+ };
+
+ var cur_id = parseInt(ev.target.id, 10);
+
+ if (ev.shiftKey && prev_id) {
+ if (prev_id > cur_id) {
+ var tmp = prev_id;
+ prev_id = cur_id;
+ cur_id = tmp;
+ }
+
+ set_fragment(prev_id + '-' + cur_id);
+ } else {
+ prev_id = cur_id;
+
+ set_fragment(cur_id);
+ }
+ } else if (!hasClass(document.getElementById("help"), "hidden")) {
+ addClass(document.getElementById("help"), "hidden");
+ removeClass(document.body, "blur");
+ }
+ };
+
+ var x = document.getElementsByClassName('version-selector');
+ if (x.length > 0) {
+ x[0].onchange = function() {
+ var i, match,
+ url = document.location.href,
+ stripped = '',
+ len = rootPath.match(/\.\.\//g).length + 1;
+
+ for (i = 0; i < len; ++i) {
+ match = url.match(/\/[^\/]*$/);
+ if (i < len - 1) {
+ stripped = match[0] + stripped;
+ }
+ url = url.substring(0, url.length - match[0].length);
+ }
+
+ url += '/' + document.getElementsByClassName('version-selector')[0].value + stripped;
+
+ document.location.href = url;
+ };
+ }
+
+ /**
+ * A function to compute the Levenshtein distance between two strings
+ * Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported
+ * Full License can be found at http://creativecommons.org/licenses/by-sa/3.0/legalcode
+ * This code is an unmodified version of the code written by Marco de Wit
+ * and was found at http://stackoverflow.com/a/18514751/745719
+ */
+ var levenshtein_row2 = [];
+ function levenshtein(s1, s2) {
+ if (s1 === s2) {
+ return 0;
+ }
+ var s1_len = s1.length, s2_len = s2.length;
+ if (s1_len && s2_len) {
+ var i1 = 0, i2 = 0, a, b, c, c2, row = levenshtein_row2;
+ while (i1 < s1_len) {
+ row[i1] = ++i1;
+ }
+ while (i2 < s2_len) {
+ c2 = s2.charCodeAt(i2);
+ a = i2;
+ ++i2;
+ b = i2;
+ for (i1 = 0; i1 < s1_len; ++i1) {
+ c = a + (s1.charCodeAt(i1) !== c2 ? 1 : 0);
+ a = row[i1];
+ b = b < a ? (b < c ? b + 1 : c) : (a < c ? a + 1 : c);
+ row[i1] = b;
+ }
+ }
+ return b;
+ }
+ return s1_len + s2_len;
+ }
+
+ function initSearch(rawSearchIndex) {
+ var currentResults, index, searchIndex;
+ var MAX_LEV_DISTANCE = 3;
+ var MAX_RESULTS = 200;
+ var params = getQueryStringParams();
+
+ // Populate search bar with query string search term when provided,
+ // but only if the input bar is empty. This avoid the obnoxious issue
+ // where you start trying to do a search, and the index loads, and
+ // suddenly your search is gone!
+ if (document.getElementsByClassName("search-input")[0].value === "") {
+ document.getElementsByClassName("search-input")[0].value = params.search || '';
+ }
+
+ /**
+ * Executes the query and builds an index of results
+ * @param {[Object]} query [The user query]
+ * @param {[type]} searchWords [The list of search words to query
+ * against]
+ * @return {[type]} [A search index of results]
+ */
+ function execQuery(query, searchWords) {
+ function itemTypeFromName(typename) {
+ for (var i = 0; i < itemTypes.length; ++i) {
+ if (itemTypes[i] === typename) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ var valLower = query.query.toLowerCase(),
+ val = valLower,
+ typeFilter = itemTypeFromName(query.type),
+ results = {}, results_in_args = {}, results_returned = {},
+ split = valLower.split("::");
+
+ for (var z = 0; z < split.length; ++z) {
+ if (split[z] === "") {
+ split.splice(z, 1);
+ z -= 1;
+ }
+ }
+
+ function transformResults(results, isType) {
+ var out = [];
+ for (i = 0; i < results.length; ++i) {
+ if (results[i].id > -1) {
+ var obj = searchIndex[results[i].id];
+ obj.lev = results[i].lev;
+ if (isType !== true || obj.type) {
+ out.push(obj);
+ }
+ }
+ if (out.length >= MAX_RESULTS) {
+ break;
+ }
+ }
+ return out;
+ }
+
+ function sortResults(results, isType) {
+ var ar = [];
+ for (var entry in results) {
+ if (results.hasOwnProperty(entry)) {
+ ar.push(results[entry]);
+ }
+ }
+ results = ar;
+ var nresults = results.length;
+ for (var i = 0; i < nresults; ++i) {
+ results[i].word = searchWords[results[i].id];
+ results[i].item = searchIndex[results[i].id] || {};
+ }
+ // if there are no results then return to default and fail
+ if (results.length === 0) {
+ return [];
+ }
+
+ results.sort(function(aaa, bbb) {
+ var a, b;
+
+ // Sort by non levenshtein results and then levenshtein results by the distance
+ // (less changes required to match means higher rankings)
+ a = (aaa.lev);
+ b = (bbb.lev);
+ if (a !== b) { return a - b; }
+
+ // sort by crate (non-current crate goes later)
+ a = (aaa.item.crate !== window.currentCrate);
+ b = (bbb.item.crate !== window.currentCrate);
+ if (a !== b) { return a - b; }
+
+ // sort by exact match (mismatch goes later)
+ a = (aaa.word !== valLower);
+ b = (bbb.word !== valLower);
+ if (a !== b) { return a - b; }
+
+ // sort by item name length (longer goes later)
+ a = aaa.word.length;
+ b = bbb.word.length;
+ if (a !== b) { return a - b; }
+
+ // sort by item name (lexicographically larger goes later)
+ a = aaa.word;
+ b = bbb.word;
+ if (a !== b) { return (a > b ? +1 : -1); }
+
+ // sort by index of keyword in item name (no literal occurrence goes later)
+ a = (aaa.index < 0);
+ b = (bbb.index < 0);
+ if (a !== b) { return a - b; }
+ // (later literal occurrence, if any, goes later)
+ a = aaa.index;
+ b = bbb.index;
+ if (a !== b) { return a - b; }
+
+ // special precedence for primitive pages
+ if ((aaa.item.ty === TY_PRIMITIVE) && (bbb.item.ty !== TY_PRIMITIVE)) {
+ return -1;
+ }
+ if ((bbb.item.ty === TY_PRIMITIVE) && (aaa.item.ty !== TY_PRIMITIVE)) {
+ return 1;
+ }
+
+ // sort by description (no description goes later)
+ a = (aaa.item.desc === '');
+ b = (bbb.item.desc === '');
+ if (a !== b) { return a - b; }
+
+ // sort by type (later occurrence in `itemTypes` goes later)
+ a = aaa.item.ty;
+ b = bbb.item.ty;
+ if (a !== b) { return a - b; }
+
+ // sort by path (lexicographically larger goes later)
+ a = aaa.item.path;
+ b = bbb.item.path;
+ if (a !== b) { return (a > b ? +1 : -1); }
+
+ // que sera, sera
+ return 0;
+ });
+
+ for (var i = 0; i < results.length; ++i) {
+ var result = results[i];
+
+ // this validation does not make sense when searching by types
+ if (result.dontValidate) {
+ continue;
+ }
+ var name = result.item.name.toLowerCase(),
+ path = result.item.path.toLowerCase(),
+ parent = result.item.parent;
+
+ if (isType !== true &&
+ validateResult(name, path, split, parent) === false)
+ {
+ result.id = -1;
+ }
+ }
+ return transformResults(results);
+ }
+
+ function extractGenerics(val) {
+ val = val.toLowerCase();
+ if (val.indexOf('<') !== -1) {
+ var values = val.substring(val.indexOf('<') + 1, val.lastIndexOf('>'));
+ return {
+ name: val.substring(0, val.indexOf('<')),
+ generics: values.split(/\s*,\s*/),
+ };
+ }
+ return {
+ name: val,
+ generics: [],
+ };
+ }
+
+ function checkGenerics(obj, val) {
+ // The names match, but we need to be sure that all generics kinda
+ // match as well.
+ var lev_distance = MAX_LEV_DISTANCE + 1;
+ if (val.generics.length > 0) {
+ if (obj.generics && obj.generics.length >= val.generics.length) {
+ var elems = obj.generics.slice(0);
+ var total = 0;
+ var done = 0;
+ // We need to find the type that matches the most to remove it in order
+ // to move forward.
+ for (var y = 0; y < val.generics.length; ++y) {
+ var lev = { pos: -1, lev: MAX_LEV_DISTANCE + 1};
+ for (var x = 0; x < elems.length; ++x) {
+ var tmp_lev = levenshtein(elems[x], val.generics[y]);
+ if (tmp_lev < lev.lev) {
+ lev.lev = tmp_lev;
+ lev.pos = x;
+ }
+ }
+ if (lev.pos !== -1) {
+ elems.splice(lev.pos, 1);
+ lev_distance = Math.min(lev.lev, lev_distance);
+ total += lev.lev;
+ done += 1;
+ } else {
+ return MAX_LEV_DISTANCE + 1;
+ }
+ }
+ return lev_distance;//Math.ceil(total / done);
+ }
+ }
+ return MAX_LEV_DISTANCE + 1;
+ }
+
+ // Check for type name and type generics (if any).
+ function checkType(obj, val, literalSearch) {
+ var lev_distance = MAX_LEV_DISTANCE + 1;
+ if (obj.name === val.name) {
+ if (literalSearch === true) {
+ if (val.generics && val.generics.length !== 0) {
+ if (obj.generics && obj.length >= val.generics.length) {
+ var elems = obj.generics.slice(0);
+ var allFound = true;
+ var x;
+
+ for (var y = 0; allFound === true && y < val.generics.length; ++y) {
+ allFound = false;
+ for (x = 0; allFound === false && x < elems.length; ++x) {
+ allFound = elems[x] === val.generics[y];
+ }
+ if (allFound === true) {
+ elems.splice(x - 1, 1);
+ }
+ }
+ if (allFound === true) {
+ return true;
+ }
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+ // If the type has generics but don't match, then it won't return at this point.
+ // Otherwise, `checkGenerics` will return 0 and it'll return.
+ if (obj.generics && obj.generics.length !== 0) {
+ var tmp_lev = checkGenerics(obj, val);
+ if (tmp_lev <= MAX_LEV_DISTANCE) {
+ return tmp_lev;
+ }
+ } else {
+ return 0;
+ }
+ }
+ // Names didn't match so let's check if one of the generic types could.
+ if (literalSearch === true) {
+ if (obj.generics && obj.generics.length > 0) {
+ for (var x = 0; x < obj.generics.length; ++x) {
+ if (obj.generics[x] === val.name) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ var lev_distance = Math.min(levenshtein(obj.name, val.name), lev_distance);
+ if (lev_distance <= MAX_LEV_DISTANCE) {
+ lev_distance = Math.min(checkGenerics(obj, val), lev_distance);
+ } else if (obj.generics && obj.generics.length > 0) {
+ // We can check if the type we're looking for is inside the generics!
+ for (var x = 0; x < obj.generics.length; ++x) {
+ lev_distance = Math.min(levenshtein(obj.generics[x], val.name),
+ lev_distance);
+ }
+ }
+ // Now whatever happens, the returned distance is "less good" so we should mark it
+ // as such, and so we add 1 to the distance to make it "less good".
+ return lev_distance + 1;
+ }
+
+ function findArg(obj, val, literalSearch) {
+ var lev_distance = MAX_LEV_DISTANCE + 1;
+
+ if (obj && obj.type && obj.type.inputs.length > 0) {
+ for (var i = 0; i < obj.type.inputs.length; i++) {
+ var tmp = checkType(obj.type.inputs[i], val, literalSearch);
+ if (literalSearch === true && tmp === true) {
+ return true;
+ }
+ lev_distance = Math.min(tmp, lev_distance);
+ if (lev_distance === 0) {
+ return 0;
+ }
+ }
+ }
+ return literalSearch === true ? false : lev_distance;
+ }
+
+ function checkReturned(obj, val, literalSearch) {
+ var lev_distance = MAX_LEV_DISTANCE + 1;
+
+ if (obj && obj.type && obj.type.output) {
+ var tmp = checkType(obj.type.output, val, literalSearch);
+ if (literalSearch === true && tmp === true) {
+ return true;
+ }
+ lev_distance = Math.min(tmp, lev_distance);
+ if (lev_distance === 0) {
+ return 0;
+ }
+ }
+ return literalSearch === true ? false : lev_distance;
+ }
+
+ function checkPath(startsWith, lastElem, ty) {
+ if (startsWith.length === 0) {
+ return 0;
+ }
+ var ret_lev = MAX_LEV_DISTANCE + 1;
+ var path = ty.path.split("::");
+
+ if (ty.parent && ty.parent.name) {
+ path.push(ty.parent.name.toLowerCase());
+ }
+
+ if (startsWith.length > path.length) {
+ return MAX_LEV_DISTANCE + 1;
+ }
+ for (var i = 0; i < path.length; ++i) {
+ if (i + startsWith.length > path.length) {
+ break;
+ }
+ var lev_total = 0;
+ var aborted = false;
+ for (var x = 0; x < startsWith.length; ++x) {
+ var lev = levenshtein(path[i + x], startsWith[x]);
+ if (lev > MAX_LEV_DISTANCE) {
+ aborted = true;
+ break;
+ }
+ lev_total += lev;
+ }
+ if (aborted === false) {
+ ret_lev = Math.min(ret_lev, Math.round(lev_total / startsWith.length));
+ }
+ }
+ return ret_lev;
+ }
+
+ function typePassesFilter(filter, type) {
+ // No filter
+ if (filter < 0) return true;
+
+ // Exact match
+ if (filter === type) return true;
+
+ // Match related items
+ var name = itemTypes[type];
+ switch (itemTypes[filter]) {
+ case "constant":
+ return (name == "associatedconstant");
+ case "fn":
+ return (name == "method" || name == "tymethod");
+ case "type":
+ return (name == "primitive");
+ }
+
+ // No match
+ return false;
+ }
+
+ function generateId(ty) {
+ if (ty.parent && ty.parent.name) {
+ return itemTypes[ty.ty] + ty.path + ty.parent.name + ty.name;
+ }
+ return itemTypes[ty.ty] + ty.path + ty.name;
+ }
+
+ // quoted values mean literal search
+ var nSearchWords = searchWords.length;
+ if ((val.charAt(0) === "\"" || val.charAt(0) === "'") &&
+ val.charAt(val.length - 1) === val.charAt(0))
+ {
+ val = extractGenerics(val.substr(1, val.length - 2));
+ for (var i = 0; i < nSearchWords; ++i) {
+ var in_args = findArg(searchIndex[i], val, true);
+ var returned = checkReturned(searchIndex[i], val, true);
+ var ty = searchIndex[i];
+ var fullId = generateId(ty);
+
+ if (searchWords[i] === val.name) {
+ // filter type: ... queries
+ if (typePassesFilter(typeFilter, searchIndex[i].ty) &&
+ results[fullId] === undefined)
+ {
+ results[fullId] = {id: i, index: -1};
+ }
+ } else if ((in_args === true || returned === true) &&
+ typePassesFilter(typeFilter, searchIndex[i].ty)) {
+ if (in_args === true || returned === true) {
+ if (in_args === true) {
+ results_in_args[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ if (returned === true) {
+ results_returned[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ } else {
+ results[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ }
+ }
+ query.inputs = [val];
+ query.output = val;
+ query.search = val;
+ // searching by type
+ } else if (val.search("->") > -1) {
+ var trimmer = function (s) { return s.trim(); };
+ var parts = val.split("->").map(trimmer);
+ var input = parts[0];
+ // sort inputs so that order does not matter
+ var inputs = input.split(",").map(trimmer).sort();
+ for (var i = 0; i < inputs.length; ++i) {
+ inputs[i] = extractGenerics(inputs[i]);
+ }
+ var output = extractGenerics(parts[1]);
+
+ for (var i = 0; i < nSearchWords; ++i) {
+ var type = searchIndex[i].type;
+ var ty = searchIndex[i];
+ if (!type) {
+ continue;
+ }
+ var fullId = generateId(ty);
+
+ // allow searching for void (no output) functions as well
+ var typeOutput = type.output ? type.output.name : "";
+ var returned = checkReturned(ty, output, true);
+ if (output.name === "*" || returned === true) {
+ var in_args = false;
+ var module = false;
+
+ if (input === "*") {
+ module = true;
+ } else {
+ var allFound = true;
+ for (var it = 0; allFound === true && it < inputs.length; it++) {
+ allFound = checkType(type, inputs[it], true);
+ }
+ in_args = allFound;
+ }
+ if (in_args === true) {
+ results_in_args[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ if (returned === true) {
+ results_returned[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ if (module === true) {
+ results[fullId] = {
+ id: i,
+ index: -1,
+ dontValidate: true,
+ };
+ }
+ }
+ }
+ query.inputs = inputs.map(function(input) {
+ return input.name;
+ });
+ query.output = output.name;
+ } else {
+ query.inputs = [val];
+ query.output = val;
+ query.search = val;
+ // gather matching search results up to a certain maximum
+ val = val.replace(/\_/g, "");
+
+ var valGenerics = extractGenerics(val);
+
+ var paths = valLower.split("::");
+ var j;
+ for (j = 0; j < paths.length; ++j) {
+ if (paths[j] === "") {
+ paths.splice(j, 1);
+ j -= 1;
+ }
+ }
+ val = paths[paths.length - 1];
+ var startsWith = paths.slice(0, paths.length > 1 ? paths.length - 1 : 1);
+
+ for (j = 0; j < nSearchWords; ++j) {
+ var lev_distance;
+ var ty = searchIndex[j];
+ if (!ty) {
+ continue;
+ }
+ var lev_add = 0;
+ if (paths.length > 1) {
+ var lev = checkPath(startsWith, paths[paths.length - 1], ty);
+ if (lev > MAX_LEV_DISTANCE) {
+ continue;
+ } else if (lev > 0) {
+ lev_add = 1;
+ }
+ }
+
+ var returned = MAX_LEV_DISTANCE + 1;
+ var in_args = MAX_LEV_DISTANCE + 1;
+ var index = -1;
+ // we want lev results to go lower than others
+ var lev = MAX_LEV_DISTANCE + 1;
+ var fullId = generateId(ty);
+
+ if (searchWords[j].indexOf(split[i]) > -1 ||
+ searchWords[j].indexOf(val) > -1 ||
+ searchWords[j].replace(/_/g, "").indexOf(val) > -1)
+ {
+ // filter type: ... queries
+ if (typePassesFilter(typeFilter, ty.ty) && results[fullId] === undefined) {
+ index = searchWords[j].replace(/_/g, "").indexOf(val);
+ }
+ }
+ if ((lev = levenshtein(searchWords[j], val)) <= MAX_LEV_DISTANCE) {
+ if (typePassesFilter(typeFilter, ty.ty) === false) {
+ lev = MAX_LEV_DISTANCE + 1;
+ } else {
+ lev += 1;
+ }
+ }
+ if ((in_args = findArg(ty, valGenerics)) <= MAX_LEV_DISTANCE) {
+ if (typePassesFilter(typeFilter, ty.ty) === false) {
+ in_args = MAX_LEV_DISTANCE + 1;
+ }
+ }
+ if ((returned = checkReturned(ty, valGenerics)) <= MAX_LEV_DISTANCE) {
+ if (typePassesFilter(typeFilter, ty.ty) === false) {
+ returned = MAX_LEV_DISTANCE + 1;
+ }
+ }
+
+ lev += lev_add;
+ if (lev > 0 && val.length > 3 && searchWords[j].startsWith(val)) {
+ if (val.length < 6) {
+ lev -= 1;
+ } else {
+ lev = 0;
+ }
+ }
+ if (in_args <= MAX_LEV_DISTANCE) {
+ if (results_in_args[fullId] === undefined) {
+ results_in_args[fullId] = {
+ id: j,
+ index: index,
+ lev: in_args,
+ };
+ }
+ results_in_args[fullId].lev =
+ Math.min(results_in_args[fullId].lev, in_args);
+ }
+ if (returned <= MAX_LEV_DISTANCE) {
+ if (results_returned[fullId] === undefined) {
+ results_returned[fullId] = {
+ id: j,
+ index: index,
+ lev: returned,
+ };
+ }
+ results_returned[fullId].lev =
+ Math.min(results_returned[fullId].lev, returned);
+ }
+ if (index !== -1 || lev <= MAX_LEV_DISTANCE) {
+ if (index !== -1) {
+ lev = 0;
+ }
+ if (results[fullId] === undefined) {
+ results[fullId] = {
+ id: j,
+ index: index,
+ lev: lev,
+ };
+ }
+ results[fullId].lev = Math.min(results[fullId].lev, lev);
+ }
+ }
+ }
+
+ return {
+ 'in_args': sortResults(results_in_args, true),
+ 'returned': sortResults(results_returned, true),
+ 'others': sortResults(results),
+ };
+ }
+
+ /**
+ * Validate performs the following boolean logic. For example:
+ * "File::open" will give IF A PARENT EXISTS => ("file" && "open")
+ * exists in (name || path || parent) OR => ("file" && "open") exists in
+ * (name || path )
+ *
+ * This could be written functionally, but I wanted to minimise
+ * functions on stack.
+ *
+ * @param {[string]} name [The name of the result]
+ * @param {[string]} path [The path of the result]
+ * @param {[string]} keys [The keys to be used (["file", "open"])]
+ * @param {[object]} parent [The parent of the result]
+ * @return {[boolean]} [Whether the result is valid or not]
+ */
+ function validateResult(name, path, keys, parent) {
+ for (var i = 0; i < keys.length; ++i) {
+ // each check is for validation so we negate the conditions and invalidate
+ if (!(
+ // check for an exact name match
+ name.indexOf(keys[i]) > -1 ||
+ // then an exact path match
+ path.indexOf(keys[i]) > -1 ||
+ // next if there is a parent, check for exact parent match
+ (parent !== undefined &&
+ parent.name.toLowerCase().indexOf(keys[i]) > -1) ||
+ // lastly check to see if the name was a levenshtein match
+ levenshtein(name, keys[i]) <= MAX_LEV_DISTANCE)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function getQuery(raw) {
+ var matches, type, query;
+ query = raw;
+
+ matches = query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);
+ if (matches) {
+ type = matches[1].replace(/^const$/, 'constant');
+ query = query.substring(matches[0].length);
+ }
+
+ return {
+ raw: raw,
+ query: query,
+ type: type,
+ id: query + type
+ };
+ }
+
+ function initSearchNav() {
+ var hoverTimeout;
+
+ var click_func = function(e) {
+ var el = e.target;
+ // to retrieve the real "owner" of the event.
+ while (el.tagName !== 'TR') {
+ el = el.parentNode;
+ }
+ var dst = e.target.getElementsByTagName('a');
+ if (dst.length < 1) {
+ return;
+ }
+ dst = dst[0];
+ if (window.location.pathname === dst.pathname) {
+ addClass(document.getElementById('search'), 'hidden');
+ removeClass(document.getElementById('main'), 'hidden');
+ document.location.href = dst.href;
+ }
+ };
+ var mouseover_func = function(e) {
+ var el = e.target;
+ // to retrieve the real "owner" of the event.
+ while (el.tagName !== 'TR') {
+ el = el.parentNode;
+ }
+ clearTimeout(hoverTimeout);
+ hoverTimeout = setTimeout(function() {
+ onEach(document.getElementsByClassName('search-results'), function(e) {
+ onEach(e.getElementsByClassName('result'), function(i_e) {
+ removeClass(i_e, 'highlighted');
+ });
+ });
+ addClass(el, 'highlighted');
+ }, 20);
+ };
+ onEach(document.getElementsByClassName('search-results'), function(e) {
+ onEach(e.getElementsByClassName('result'), function(i_e) {
+ i_e.onclick = click_func;
+ i_e.onmouseover = mouseover_func;
+ });
+ });
+
+ var search_input = document.getElementsByClassName('search-input')[0];
+ search_input.onkeydown = function(e) {
+ // "actives" references the currently highlighted item in each search tab.
+ // Each array in "actives" represents a tab.
+ var actives = [[], [], []];
+ // "current" is used to know which tab we're looking into.
+ var current = 0;
+ onEach(document.getElementsByClassName('search-results'), function(e) {
+ onEach(e.getElementsByClassName('highlighted'), function(e) {
+ actives[current].push(e);
+ });
+ current += 1;
+ });
+
+ if (e.which === 38) { // up
+ if (!actives[currentTab].length ||
+ !actives[currentTab][0].previousElementSibling) {
+ return;
+ }
+
+ addClass(actives[currentTab][0].previousElementSibling, 'highlighted');
+ removeClass(actives[currentTab][0], 'highlighted');
+ } else if (e.which === 40) { // down
+ if (!actives[currentTab].length) {
+ var results = document.getElementsByClassName('search-results');
+ if (results.length > 0) {
+ var res = results[currentTab].getElementsByClassName('result');
+ if (res.length > 0) {
+ addClass(res[0], 'highlighted');
+ }
+ }
+ } else if (actives[currentTab][0].nextElementSibling) {
+ addClass(actives[currentTab][0].nextElementSibling, 'highlighted');
+ removeClass(actives[currentTab][0], 'highlighted');
+ }
+ } else if (e.which === 13) { // return
+ if (actives[currentTab].length) {
+ document.location.href =
+ actives[currentTab][0].getElementsByTagName('a')[0].href;
+ }
+ } else if (e.which === 9) { // tab
+ if (e.shiftKey) {
+ printTab(currentTab > 0 ? currentTab - 1 : 2);
+ } else {
+ printTab(currentTab > 1 ? 0 : currentTab + 1);
+ }
+ e.preventDefault();
+ } else if (e.which === 16) { // shift
+ // Does nothing, it's just to avoid losing "focus" on the highlighted element.
+ } else if (e.which === 27) { // escape
+ removeClass(actives[currentTab][0], 'highlighted');
+ document.getElementsByClassName('search-input')[0].value = '';
+ defocusSearchBar();
+ } else if (actives[currentTab].length > 0) {
+ removeClass(actives[currentTab][0], 'highlighted');
+ }
+ };
+ }
+
+ function escape(content) {
+ var h1 = document.createElement('h1');
+ h1.textContent = content;
+ return h1.innerHTML;
+ }
+
+ function addTab(array, query, display) {
+ var extraStyle = '';
+ if (display === false) {
+ extraStyle = ' style="display: none;"';
+ }
+
+ var output = '';
+ if (array.length > 0) {
+ output = '<table class="search-results"' + extraStyle + '>';
+ var shown = [];
+
+ array.forEach(function(item) {
+ var name, type, href, displayPath;
+
+ if (shown.indexOf(item) !== -1) {
+ return;
+ }
+
+ shown.push(item);
+ name = item.name;
+ type = itemTypes[item.ty];
+
+ if (type === 'mod') {
+ displayPath = item.path + '::';
+ href = rootPath + item.path.replace(/::/g, '/') + '/' +
+ name + '/index.html';
+ } else if (type === "primitive") {
+ displayPath = "";
+ href = rootPath + item.path.replace(/::/g, '/') +
+ '/' + type + '.' + name + '.html';
+ } else if (type === "externcrate") {
+ displayPath = "";
+ href = rootPath + name + '/index.html';
+ } else if (item.parent !== undefined) {
+ var myparent = item.parent;
+ var anchor = '#' + type + '.' + name;
+ var parentType = itemTypes[myparent.ty];
+ if (parentType === "primitive") {
+ displayPath = myparent.name + '::';
+ } else {
+ displayPath = item.path + '::' + myparent.name + '::';
+ }
+ href = rootPath + item.path.replace(/::/g, '/') +
+ '/' + parentType +
+ '.' + myparent.name +
+ '.html' + anchor;
+ } else {
+ displayPath = item.path + '::';
+ href = rootPath + item.path.replace(/::/g, '/') +
+ '/' + type + '.' + name + '.html';
+ }
+
+ output += '<tr class="' + type + ' result"><td>' +
+ '<a href="' + href + '">' +
+ displayPath + '<span class="' + type + '">' +
+ name + '</span></a></td><td>' +
+ '<a href="' + href + '">' +
+ '<span class="desc">' + escape(item.desc) +
+ ' </span></a></td></tr>';
+ });
+ output += '</table>';
+ } else {
+ output = '<div class="search-failed"' + extraStyle + '>No results :(<br/>' +
+ 'Try on <a href="https://duckduckgo.com/?q=' +
+ encodeURIComponent('rust ' + query.query) +
+ '">DuckDuckGo</a>?</div>';
+ }
+ return output;
+ }
+
+ function makeTabHeader(tabNb, text, nbElems) {
+ if (currentTab === tabNb) {
+ return '<div class="selected">' + text +
+ ' <div class="count">(' + nbElems + ')</div></div>';
+ }
+ return '<div>' + text + ' <div class="count">(' + nbElems + ')</div></div>';
+ }
+
+ function showResults(results) {
+ var output, query = getQuery(document.getElementsByClassName('search-input')[0].value);
+
+ currentResults = query.id;
+ output = '<h1>Results for ' + escape(query.query) +
+ (query.type ? ' (type: ' + escape(query.type) + ')' : '') + '</h1>' +
+ '<div id="titles">' +
+ makeTabHeader(0, "In Names", results['others'].length) +
+ makeTabHeader(1, "In Parameters", results['in_args'].length) +
+ makeTabHeader(2, "In Return Types", results['returned'].length) +
+ '</div><div id="results">';
+
+ output += addTab(results['others'], query);
+ output += addTab(results['in_args'], query, false);
+ output += addTab(results['returned'], query, false);
+ output += '</div>';
+
+ addClass(document.getElementById('main'), 'hidden');
+ var search = document.getElementById('search');
+ removeClass(search, 'hidden');
+ search.innerHTML = output;
+ var tds = search.getElementsByTagName('td');
+ var td_width = 0;
+ if (tds.length > 0) {
+ td_width = tds[0].offsetWidth;
+ }
+ var width = search.offsetWidth - 40 - td_width;
+ onEach(search.getElementsByClassName('desc'), function(e) {
+ e.style.width = width + 'px';
+ });
+ initSearchNav();
+ var elems = document.getElementById('titles').childNodes;
+ elems[0].onclick = function() { printTab(0); };
+ elems[1].onclick = function() { printTab(1); };
+ elems[2].onclick = function() { printTab(2); };
+ printTab(currentTab);
+ }
+
+ function search(e) {
+ var query,
+ obj, i, len,
+ results = {"in_args": [], "returned": [], "others": []},
+ resultIndex;
+ var params = getQueryStringParams();
+
+ query = getQuery(document.getElementsByClassName('search-input')[0].value);
+ if (e) {
+ e.preventDefault();
+ }
+
+ if (!query.query || query.id === currentResults) {
+ return;
+ }
+
+ // Update document title to maintain a meaningful browser history
+ document.title = "Results for " + query.query + " - Rust";
+
+ // Because searching is incremental by character, only the most
+ // recent search query is added to the browser history.
+ if (browserSupportsHistoryApi()) {
+ if (!history.state && !params.search) {
+ history.pushState(query, "", "?search=" + encodeURIComponent(query.raw));
+ } else {
+ history.replaceState(query, "", "?search=" + encodeURIComponent(query.raw));
+ }
+ }
+
+ results = execQuery(query, index);
+ showResults(results);
+ }
+
+ function buildIndex(rawSearchIndex) {
+ searchIndex = [];
+ var searchWords = [];
+ for (var crate in rawSearchIndex) {
+ if (!rawSearchIndex.hasOwnProperty(crate)) { continue; }
+
+ searchWords.push(crate);
+ searchIndex.push({
+ crate: crate,
+ ty: 1, // == ExternCrate
+ name: crate,
+ path: "",
+ desc: rawSearchIndex[crate].doc,
+ type: null,
+ });
+
+ // an array of [(Number) item type,
+ // (String) name,
+ // (String) full path or empty string for previous path,
+ // (String) description,
+ // (Number | null) the parent path index to `paths`]
+ // (Object | null) the type of the function (if any)
+ var items = rawSearchIndex[crate].items;
+ // an array of [(Number) item type,
+ // (String) name]
+ var paths = rawSearchIndex[crate].paths;
+
+ // convert `paths` into an object form
+ var len = paths.length;
+ for (var i = 0; i < len; ++i) {
+ paths[i] = {ty: paths[i][0], name: paths[i][1]};
+ }
+
+ // convert `items` into an object form, and construct word indices.
+ //
+ // before any analysis is performed lets gather the search terms to
+ // search against apart from the rest of the data. This is a quick
+ // operation that is cached for the life of the page state so that
+ // all other search operations have access to this cached data for
+ // faster analysis operations
+ var len = items.length;
+ var lastPath = "";
+ for (var i = 0; i < len; ++i) {
+ var rawRow = items[i];
+ var row = {crate: crate, ty: rawRow[0], name: rawRow[1],
+ path: rawRow[2] || lastPath, desc: rawRow[3],
+ parent: paths[rawRow[4]], type: rawRow[5]};
+ searchIndex.push(row);
+ if (typeof row.name === "string") {
+ var word = row.name.toLowerCase();
+ searchWords.push(word);
+ } else {
+ searchWords.push("");
+ }
+ lastPath = row.path;
+ }
+ }
+ return searchWords;
+ }
+
+ function startSearch() {
+ var searchTimeout;
+ var callback = function() {
+ var search_input = document.getElementsByClassName('search-input');
+ if (search_input.length < 1) { return; }
+ search_input = search_input[0];
+ clearTimeout(searchTimeout);
+ if (search_input.value.length === 0) {
+ if (browserSupportsHistoryApi()) {
+ history.replaceState("", "std - Rust", "?search=");
+ }
+ var main = document.getElementById('main');
+ if (hasClass(main, 'content')) {
+ removeClass(main, 'hidden');
+ }
+ var search_c = document.getElementById('search');
+ if (hasClass(search_c, 'content')) {
+ addClass(search_c, 'hidden');
+ }
+ } else {
+ searchTimeout = setTimeout(search, 500);
+ }
+ };
+ var search_input = document.getElementsByClassName("search-input")[0];
+ search_input.onkeyup = callback;
+ search_input.oninput = callback;
+ document.getElementsByClassName("search-form")[0].onsubmit = function(e) {
+ e.preventDefault();
+ clearTimeout(searchTimeout);
+ search();
+ };
+ search_input.onchange = function(e) {
+ // Do NOT e.preventDefault() here. It will prevent pasting.
+ clearTimeout(searchTimeout);
+ // zero-timeout necessary here because at the time of event handler execution the
+ // pasted content is not in the input field yet. Shouldn’t make any difference for
+ // change, though.
+ setTimeout(search, 0);
+ };
+ search_input.onpaste = search_input.onchange;
+
+ // Push and pop states are used to add search results to the browser
+ // history.
+ if (browserSupportsHistoryApi()) {
+ // Store the previous <title> so we can revert back to it later.
+ var previousTitle = document.title;
+
+ window.onpopstate = function(e) {
+ var params = getQueryStringParams();
+ // When browsing back from search results the main page
+ // visibility must be reset.
+ if (!params.search) {
+ var main = document.getElementById('main');
+ if (hasClass(main, 'content')) {
+ removeClass(main, 'hidden');
+ }
+ var search_c = document.getElementById('search');
+ if (hasClass(search_c, 'content')) {
+ addClass(search_c, 'hidden');
+ }
+ }
+ // Revert to the previous title manually since the History
+ // API ignores the title parameter.
+ document.title = previousTitle;
+ // When browsing forward to search results the previous
+ // search will be repeated, so the currentResults are
+ // cleared to ensure the search is successful.
+ currentResults = null;
+ // Synchronize search bar with query string state and
+ // perform the search. This will empty the bar if there's
+ // nothing there, which lets you really go back to a
+ // previous state with nothing in the bar.
+ if (params.search) {
+ document.getElementsByClassName('search-input')[0].value = params.search;
+ } else {
+ document.getElementsByClassName('search-input')[0].value = '';
+ }
+ // Some browsers fire 'onpopstate' for every page load
+ // (Chrome), while others fire the event only when actually
+ // popping a state (Firefox), which is why search() is
+ // called both here and at the end of the startSearch()
+ // function.
+ search();
+ };
+ }
+ search();
+ }
+
+ index = buildIndex(rawSearchIndex);
+ startSearch();
+
+ // Draw a convenient sidebar of known crates if we have a listing
+ if (rootPath === '../') {
+ var sidebar = document.getElementsByClassName('sidebar-elems')[0];
+ var div = document.createElement('div');
+ div.className = 'block crate';
+ div.innerHTML = '<h3>Crates</h3>';
+ var ul = document.createElement('ul');
+ div.appendChild(ul);
+
+ var crates = [];
+ for (var crate in rawSearchIndex) {
+ if (!rawSearchIndex.hasOwnProperty(crate)) {
+ continue;
+ }
+ crates.push(crate);
+ }
+ crates.sort();
+ for (var i = 0; i < crates.length; ++i) {
+ var klass = 'crate';
+ if (crates[i] === window.currentCrate) {
+ klass += ' current';
+ }
+ var link = document.createElement('a');
+ link.href = '../' + crates[i] + '/index.html';
+ link.title = rawSearchIndex[crates[i]].doc;
+ link.className = klass;
+ link.textContent = crates[i];
+
+ var li = document.createElement('li');
+ li.appendChild(link);
+ ul.appendChild(li);
+ }
+ sidebar.appendChild(div);
+ }
+ }
+
+ window.initSearch = initSearch;
+
+ // delayed sidebar rendering.
+ function initSidebarItems(items) {
+ var sidebar = document.getElementsByClassName('sidebar-elems')[0];
+ var current = window.sidebarCurrent;
+
+ function block(shortty, longty) {
+ var filtered = items[shortty];
+ if (!filtered) { return; }
+
+ var div = document.createElement('div');
+ div.className = 'block ' + shortty;
+ var h3 = document.createElement('h3');
+ h3.textContent = longty;
+ div.appendChild(h3);
+ var ul = document.createElement('ul');
+
+ for (var i = 0; i < filtered.length; ++i) {
+ var item = filtered[i];
+ var name = item[0];
+ var desc = item[1]; // can be null
+
+ var klass = shortty;
+ if (name === current.name && shortty === current.ty) {
+ klass += ' current';
+ }
+ var path;
+ if (shortty === 'mod') {
+ path = name + '/index.html';
+ } else {
+ path = shortty + '.' + name + '.html';
+ }
+ var link = document.createElement('a');
+ link.href = current.relpath + path;
+ link.title = desc;
+ link.className = klass;
+ link.textContent = name;
+ var li = document.createElement('li');
+ li.appendChild(link);
+ ul.appendChild(li);
+ }
+ div.appendChild(ul);
+ if (sidebar) {
+ sidebar.appendChild(div);
+ }
+ }
+
+ block("primitive", "Primitive Types");
+ block("mod", "Modules");
+ block("macro", "Macros");
+ block("struct", "Structs");
+ block("enum", "Enums");
+ block("union", "Unions");
+ block("constant", "Constants");
+ block("static", "Statics");
+ block("trait", "Traits");
+ block("fn", "Functions");
+ block("type", "Type Definitions");
+ block("foreigntype", "Foreign Types");
+ }
+
+ window.initSidebarItems = initSidebarItems;
+
+ window.register_implementors = function(imp) {
+ var list = document.getElementById('implementors-list');
+ var libs = Object.getOwnPropertyNames(imp);
+ for (var i = 0; i < libs.length; ++i) {
+ if (libs[i] === currentCrate) { continue; }
+ var structs = imp[libs[i]];
+ for (var j = 0; j < structs.length; ++j) {
+ var code = document.createElement('code');
+ code.innerHTML = structs[j];
+
+ var x = code.getElementsByTagName('a');
+ for (var k = 0; k < x.length; k++) {
+ var href = x[k].getAttribute('href');
+ if (href && href.indexOf('http') !== 0) {
+ x[k].setAttribute('href', rootPath + href);
+ }
+ }
+ var li = document.createElement('li');
+ li.appendChild(code);
+ list.appendChild(li);
+ }
+ }
+ };
+ if (window.pending_implementors) {
+ window.register_implementors(window.pending_implementors);
+ }
+
+ function labelForToggleButton(sectionIsCollapsed) {
+ if (sectionIsCollapsed) {
+ // button will expand the section
+ return "+";
+ }
+ // button will collapse the section
+ // note that this text is also set in the HTML template in render.rs
+ return "\u2212"; // "\u2212" is '−' minus sign
+ }
+
+ function onEveryMatchingChild(elem, className, func) {
+ if (elem && className && func) {
+ for (var i = 0; i < elem.childNodes.length; i++) {
+ if (hasClass(elem.childNodes[i], className)) {
+ func(elem.childNodes[i]);
+ } else {
+ onEveryMatchingChild(elem.childNodes[i], className, func);
+ }
+ }
+ }
+ }
+
+ function toggleAllDocs() {
+ var toggle = document.getElementById("toggle-all-docs");
+ if (hasClass(toggle, "will-expand")) {
+ removeClass(toggle, "will-expand");
+ onEveryMatchingChild(toggle, "inner", function(e) {
+ e.innerHTML = labelForToggleButton(false);
+ });
+ toggle.title = "collapse all docs";
+ onEach(document.getElementsByClassName("docblock"), function(e) {
+ e.style.display = 'block';
+ });
+ onEach(document.getElementsByClassName("toggle-label"), function(e) {
+ e.style.display = 'none';
+ });
+ onEach(document.getElementsByClassName("toggle-wrapper"), function(e) {
+ removeClass(e, "collapsed");
+ });
+ onEach(document.getElementsByClassName("collapse-toggle"), function(e) {
+ onEveryMatchingChild(e, "inner", function(i_e) {
+ i_e.innerHTML = labelForToggleButton(false);
+ });
+ });
+ } else {
+ addClass(toggle, "will-expand");
+ onEveryMatchingChild(toggle, "inner", function(e) {
+ e.innerHTML = labelForToggleButton(true);
+ });
+ toggle.title = "expand all docs";
+ onEach(document.getElementsByClassName("docblock"), function(e) {
+ e.style.display = 'none';
+ });
+ onEach(document.getElementsByClassName("toggle-label"), function(e) {
+ e.style.display = 'inline-block';
+ });
+ onEach(document.getElementsByClassName("toggle-wrapper"), function(e) {
+ addClass(e, "collapsed");
+ });
+ onEach(document.getElementsByClassName("collapse-toggle"), function(e) {
+ onEveryMatchingChild(e, "inner", function(i_e) {
+ i_e.innerHTML = labelForToggleButton(true);
+ });
+ });
+ }
+ }
+
+ function collapseDocs(toggle) {
+ if (!toggle || !toggle.parentNode) {
+ return;
+ }
+ var relatedDoc = toggle.parentNode.nextElementSibling;
+ if (hasClass(relatedDoc, "stability")) {
+ relatedDoc = relatedDoc.nextElementSibling;
+ }
+ if (hasClass(relatedDoc, "docblock")) {
+ if (!isHidden(relatedDoc)) {
+ relatedDoc.style.display = 'none';
+ onEach(toggle.childNodes, function(e) {
+ if (hasClass(e, 'toggle-label')) {
+ e.style.display = 'inline-block';
+ }
+ if (hasClass(e, 'inner')) {
+ e.innerHTML = labelForToggleButton(true);
+ }
+ });
+ addClass(toggle.parentNode, 'collapsed');
+ } else {
+ relatedDoc.style.display = 'block';
+ removeClass(toggle.parentNode, 'collapsed');
+ onEach(toggle.childNodes, function(e) {
+ if (hasClass(e, 'toggle-label')) {
+ e.style.display = 'none';
+ }
+ if (hasClass(e, 'inner')) {
+ e.innerHTML = labelForToggleButton(false);
+ }
+ });
+ }
+ }
+ }
+
+ var x = document.getElementById('toggle-all-docs');
+ if (x) {
+ x.onclick = toggleAllDocs;
+ }
+
+ function insertAfter(newNode, referenceNode) {
+ referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
+ }
+
+ var toggle = document.createElement('a');
+ toggle.href = 'javascript:void(0)';
+ toggle.className = 'collapse-toggle';
+ toggle.innerHTML = "[<span class='inner'>"+labelForToggleButton(false)+"</span>]";
+
+ var func = function(e) {
+ var next = e.nextElementSibling;
+ if (!next) {
+ return;
+ }
+ if (hasClass(next, 'docblock') ||
+ (hasClass(next, 'stability') &&
+ hasClass(next.nextElementSibling, 'docblock'))) {
+ insertAfter(toggle.cloneNode(true), e.childNodes[e.childNodes.length - 1]);
+ }
+ }
+ onEach(document.getElementsByClassName('method'), func);
+ onEach(document.getElementsByClassName('impl-items'), function(e) {
+ onEach(e.getElementsByClassName('associatedconstant'), func);
+ });
+
+ function createToggle() {
+ var span = document.createElement('span');
+ span.className = 'toggle-label';
+ span.style.display = 'none';
+ span.innerHTML = ' Expand description';
+
+ var mainToggle = toggle.cloneNode(true);
+ mainToggle.appendChild(span);
+
+ var wrapper = document.createElement('div');
+ wrapper.className = 'toggle-wrapper';
+ wrapper.appendChild(mainToggle);
+ return wrapper;
+ }
+
+ onEach(document.getElementById('main').getElementsByClassName('docblock'), function(e) {
+ if (e.parentNode.id === "main") {
+ e.parentNode.insertBefore(createToggle(), e);
+ }
+ });
+
+ onEach(document.getElementsByClassName('docblock'), function(e) {
+ if (hasClass(e, 'autohide')) {
+ var wrap = e.previousElementSibling;
+ if (wrap && hasClass(wrap, 'toggle-wrapper')) {
+ var toggle = wrap.childNodes[0];
+ if (e.childNodes[0].tagName === 'H3') {
+ onEach(toggle.getElementsByClassName('toggle-label'), function(i_e) {
+ i_e.innerHTML = " Show " + e.childNodes[0].innerHTML;
+ });
+ }
+ e.style.display = 'none';
+ addClass(wrap, 'collapsed');
+ onEach(toggle.getElementsByClassName('inner'), function(e) {
+ e.innerHTML = labelForToggleButton(true);
+ });
+ onEach(toggle.getElementsByClassName('toggle-label'), function(e) {
+ e.style.display = 'inline-block';
+ });
+ }
+ }
+ })
+
+ function createToggleWrapper() {
+ var span = document.createElement('span');
+ span.className = 'toggle-label';
+ span.style.display = 'none';
+ span.innerHTML = ' Expand attributes';
+ toggle.appendChild(span);
+
+ var wrapper = document.createElement('div');
+ wrapper.className = 'toggle-wrapper toggle-attributes';
+ wrapper.appendChild(toggle);
+ return wrapper;
+ }
+
+ // In the search display, allows to switch between tabs.
+ function printTab(nb) {
+ if (nb === 0 || nb === 1 || nb === 2) {
+ currentTab = nb;
+ }
+ var nb_copy = nb;
+ onEach(document.getElementById('titles').childNodes, function(elem) {
+ if (nb_copy === 0) {
+ addClass(elem, 'selected');
+ } else {
+ removeClass(elem, 'selected');
+ }
+ nb_copy -= 1;
+ });
+ onEach(document.getElementById('results').childNodes, function(elem) {
+ if (nb === 0) {
+ elem.style.display = '';
+ } else {
+ elem.style.display = 'none';
+ }
+ nb -= 1;
+ });
+ }
+
+ onEach(document.getElementById('main').getElementsByTagName('pre'), function(e) {
+ onEach(e.getElementsByClassName('attributes'), function(i_e) {
+ i_e.parentNode.insertBefore(createToggleWrapper(), i_e);
+ collapseDocs(i_e.previousSibling.childNodes[0]);
+ });
+ });
+
+ onEach(document.getElementsByClassName('rust-example-rendered'), function(e) {
+ if (hasClass(e, 'compile_fail')) {
+ e.addEventListener("mouseover", function(event) {
+ e.previousElementSibling.childNodes[0].style.color = '#f00';
+ });
+ e.addEventListener("mouseout", function(event) {
+ e.previousElementSibling.childNodes[0].style.color = '';
+ });
+ } else if (hasClass(e, 'ignore')) {
+ e.addEventListener("mouseover", function(event) {
+ e.previousElementSibling.childNodes[0].style.color = '#ff9200';
+ });
+ e.addEventListener("mouseout", function(event) {
+ e.previousElementSibling.childNodes[0].style.color = '';
+ });
+ }
+ });
+
+ function showModal(content) {
+ var modal = document.createElement('div');
+ modal.id = "important";
+ addClass(modal, 'modal');
+ modal.innerHTML = '<div class="modal-content"><div class="close" id="modal-close">✕</div>' +
+ '<div class="whiter"></div><span class="docblock">' + content +
+ '</span></div>';
+ document.getElementsByTagName('body')[0].appendChild(modal);
+ document.getElementById('modal-close').onclick = hideModal;
+ modal.onclick = hideModal;
+ }
+
+ function hideModal() {
+ var modal = document.getElementById("important");
+ if (modal) {
+ modal.parentNode.removeChild(modal);
+ }
+ }
+
+ onEach(document.getElementsByClassName('important-traits'), function(e) {
+ e.onclick = function() {
+ showModal(e.lastElementChild.innerHTML);
+ };
+ });
+
+ var search_input = document.getElementsByClassName("search-input")[0];
+
+ if (search_input) {
+ search_input.onfocus = function() {
+ if (search_input.value !== "") {
+ addClass(document.getElementById("main"), "hidden");
+ removeClass(document.getElementById("search"), "hidden");
+ if (browserSupportsHistoryApi()) {
+ history.replaceState(search_input.value,
+ "",
+ "?search=" + encodeURIComponent(search_input.value));
+ }
+ }
+ };
+ }
+
+ var params = getQueryStringParams();
+ if (params && params.search) {
+ addClass(document.getElementById("main"), "hidden");
+ var search = document.getElementById("search");
+ removeClass(search, "hidden");
+ search.innerHTML = '<h3 style="text-align: center;">Loading search results...</h3>';
+ }
+
+ var sidebar_menu = document.getElementsByClassName("sidebar-menu")[0];
+ if (sidebar_menu) {
+ sidebar_menu.onclick = function() {
+ var sidebar = document.getElementsByClassName('sidebar')[0];
+ if (hasClass(sidebar, "mobile") === true) {
+ hideSidebar();
+ } else {
+ showSidebar();
+ }
+ };
+ }
+
+ window.onresize = function() {
+ hideSidebar();
+ };
+}());
+
+// Sets the focus on the search bar at the top of the page
+function focusSearchBar() {
+ document.getElementsByClassName('search-input')[0].focus();
+}
+
+// Removes the focus from the search bar
+function defocusSearchBar() {
+ document.getElementsByClassName('search-input')[0].blur();
+}
diff --git a/normalize.css b/normalize.css
new file mode 100644
index 0000000..2804c26
--- /dev/null
+++ b/normalize.css
@@ -0,0 +1 @@
+/*! normalize.css v3.0.0 | MIT License | git.io/normalize */html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:bold}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type="checkbox"],input[type="radio"]{box-sizing:border-box;padding:0}input[type="number"]::-webkit-inner-spin-button,input[type="number"]::-webkit-outer-spin-button{height:auto}input[type="search"]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}input[type="search"]::-webkit-search-cancel-button,input[type="search"]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}legend{border:0;padding:0}textarea{overflow:auto}optgroup{font-weight:bold}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}
diff --git a/rustdoc.css b/rustdoc.css
new file mode 100644
index 0000000..2b1f920
--- /dev/null
+++ b/rustdoc.css
@@ -0,0 +1,1205 @@
+/**
+ * Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+/* See FiraSans-LICENSE.txt for the Fira Sans license. */
+@font-face {
+ font-family: 'Fira Sans';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Fira Sans'), url("FiraSans-Regular.woff") format('woff');
+}
+@font-face {
+ font-family: 'Fira Sans';
+ font-style: normal;
+ font-weight: 500;
+ src: local('Fira Sans Medium'), url("FiraSans-Medium.woff") format('woff');
+}
+
+/* See SourceSerifPro-LICENSE.txt for the Source Serif Pro license and
+ * Heuristica-LICENSE.txt for the Heuristica license. */
+@font-face {
+ font-family: 'Source Serif Pro';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Source Serif Pro'), url("SourceSerifPro-Regular.woff") format('woff');
+}
+@font-face {
+ font-family: 'Source Serif Pro';
+ font-style: italic;
+ font-weight: 400;
+ src: url("Heuristica-Italic.woff") format('woff');
+}
+@font-face {
+ font-family: 'Source Serif Pro';
+ font-style: normal;
+ font-weight: 700;
+ src: local('Source Serif Pro Bold'), url("SourceSerifPro-Bold.woff") format('woff');
+}
+
+/* See SourceCodePro-LICENSE.txt for the Source Code Pro license. */
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 400;
+ /* Avoid using locally installed font because bad versions are in circulation:
+ * see https://github.com/rust-lang/rust/issues/24355 */
+ src: url("SourceCodePro-Regular.woff") format('woff');
+}
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 600;
+ src: url("SourceCodePro-Semibold.woff") format('woff');
+}
+
+* {
+ -webkit-box-sizing: border-box;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+}
+
+/* General structure and fonts */
+
+body {
+ font: 16px/1.4 "Source Serif Pro", Georgia, Times, "Times New Roman", serif;
+ margin: 0;
+ position: relative;
+ padding: 10px 15px 20px 15px;
+
+ -webkit-font-feature-settings: "kern", "liga";
+ -moz-font-feature-settings: "kern", "liga";
+ font-feature-settings: "kern", "liga";
+}
+
+h1 {
+ font-size: 1.5em;
+}
+h2 {
+ font-size: 1.4em;
+}
+h3 {
+ font-size: 1.3em;
+}
+h1, h2, h3:not(.impl):not(.method):not(.type):not(.tymethod):not(.important), h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant) {
+ font-weight: 500;
+ margin: 20px 0 15px 0;
+ padding-bottom: 6px;
+}
+h1.fqn {
+ border-bottom: 1px dashed;
+ margin-top: 0;
+ position: relative;
+}
+h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant) {
+ border-bottom: 1px solid;
+}
+h3.impl, h3.method, h4.method, h3.type, h4.type, h4.associatedconstant {
+ font-weight: 600;
+ margin-top: 10px;
+ margin-bottom: 10px;
+ position: relative;
+}
+h3.impl, h3.method, h3.type {
+ margin-top: 15px;
+}
+
+h1, h2, h3, h4,
+.sidebar, a.source, .search-input, .content table :not(code)>a,
+.collapse-toggle, ul.item-list > li > .out-of-band {
+ font-family: "Fira Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
+ol, ul {
+ padding-left: 25px;
+}
+ul ul, ol ul, ul ol, ol ol {
+ margin-bottom: 0;
+}
+
+p {
+ margin: 0 0 .6em 0;
+}
+
+summary {
+ outline: none;
+}
+
+code, pre {
+ font-family: "Source Code Pro", Menlo, Monaco, Consolas, "DejaVu Sans Mono", Inconsolata, monospace;
+ white-space: pre-wrap;
+}
+.docblock code, .docblock-short code {
+ border-radius: 3px;
+ padding: 0 0.2em;
+}
+.docblock pre code, .docblock-short pre code, .docblock code.spotlight {
+ padding: 0;
+}
+.docblock code.spotlight :last-child {
+ padding-bottom: 0.6em;
+}
+pre {
+ padding: 14px;
+}
+
+.source .content pre {
+ padding: 20px;
+}
+
+img {
+ max-width: 100%;
+}
+
+.source .content {
+ margin-top: 50px;
+ max-width: none;
+ overflow: visible;
+ margin-left: 0px;
+ min-width: 70em;
+}
+
+nav.sub {
+ font-size: 16px;
+ text-transform: uppercase;
+}
+
+.sidebar {
+ width: 200px;
+ position: fixed;
+ left: 0;
+ top: 0;
+ height: 100vh;
+ overflow: auto;
+}
+
+.sidebar .block > ul > li {
+ margin-right: -20px;
+}
+
+.content, nav {
+ max-width: 960px;
+}
+
+/* Everything else */
+
+.js-only, .hidden {
+ display: none !important;
+}
+
+.sidebar img {
+ margin: 20px auto;
+ display: block;
+ margin-top: 10px;
+}
+
+.sidebar .location {
+ border: 1px solid;
+ font-size: 17px;
+ margin: 30px 10px 20px 10px;
+ text-align: center;
+ word-wrap: break-word;
+}
+
+.sidebar .version {
+ font-size: 15px;
+ text-align: center;
+ border-bottom: 1px solid;
+ overflow-wrap: break-word;
+ word-wrap: break-word; /* deprecated */
+ word-break: break-word; /* Chrome, non-standard */
+}
+
+.location:empty {
+ border: none;
+}
+
+.location a:first-child {
+ font-weight: 500;
+}
+
+.block {
+ padding: 0;
+ margin-bottom: 14px;
+}
+.block h2, .block h3 {
+ margin-top: 0;
+ margin-bottom: 8px;
+ text-align: center;
+}
+.block ul, .block li {
+ margin: 0 10px;
+ padding: 0;
+ list-style: none;
+}
+
+.block a {
+ display: block;
+ text-overflow: ellipsis;
+ overflow: hidden;
+ line-height: 15px;
+ padding: 7px 5px;
+ font-size: 14px;
+ font-weight: 300;
+ transition: border 500ms ease-out;
+}
+
+.sidebar-title {
+ border-top: 1px solid;
+ border-bottom: 1px solid;
+ text-align: center;
+ font-size: 17px;
+ margin-bottom: 5px;
+}
+
+.sidebar-links {
+ margin-bottom: 15px;
+}
+
+.sidebar-links > a {
+ padding-left: 10px;
+ width: 100%;
+}
+
+.sidebar-menu {
+ display: none;
+}
+
+.content {
+ padding: 15px 0;
+}
+
+.source .content pre.rust {
+ white-space: pre;
+ overflow: auto;
+ padding-left: 0;
+}
+
+#search {
+ margin-left: 230px;
+ position: relative;
+}
+
+#results {
+ position: absolute;
+ right: 0;
+ left: 0;
+ overflow: auto;
+}
+
+.content pre.line-numbers {
+ float: left;
+ border: none;
+ position: relative;
+
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+.line-numbers span {
+ cursor: pointer;
+}
+
+.docblock-short p {
+ display: inline;
+}
+
+.docblock-short.nowrap {
+ display: block;
+ overflow: hidden;
+ white-space: nowrap;
+ text-overflow: ellipsis;
+}
+
+.docblock-short p {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ margin: 0;
+}
+.docblock-short code {
+ white-space: nowrap;
+}
+
+.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5 {
+ border-bottom: 1px solid;
+}
+
+#main > .docblock h1 { font-size: 1.3em; }
+#main > .docblock h2 { font-size: 1.15em; }
+#main > .docblock h3, #main > .docblock h4, #main > .docblock h5 { font-size: 1em; }
+
+.docblock h1 { font-size: 1em; }
+.docblock h2 { font-size: 0.95em; }
+.docblock h3, .docblock h4, .docblock h5 { font-size: 0.9em; }
+
+.docblock {
+ margin-left: 24px;
+ position: relative;
+}
+
+.content .out-of-band {
+ font-size: 23px;
+ margin: 0px;
+ padding: 0px;
+ text-align: right;
+ display: inline-block;
+ font-weight: normal;
+ position: absolute;
+ right: 0;
+}
+
+h3.impl > .out-of-band {
+ font-size: 21px;
+}
+
+h4.method > .out-of-band {
+ font-size: 19px;
+}
+
+ul.item-list > li > .out-of-band {
+ font-size: 19px;
+}
+
+h4 > code, h3 > code, .invisible > code {
+ max-width: calc(100% - 41px);
+ display: block;
+}
+
+.in-band, code {
+ z-index: 5;
+}
+
+.invisible {
+ width: 100%;
+ display: inline-block;
+}
+
+.content .in-band {
+ margin: 0px;
+ padding: 0px;
+ display: inline-block;
+ max-width: calc(100% - 43px);
+}
+
+.in-band > code {
+ display: inline-block;
+}
+
+#main {
+ position: relative;
+}
+#main > .since {
+ top: inherit;
+ font-family: "Fira Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
+.content table {
+ border-spacing: 0 5px;
+ border-collapse: separate;
+}
+.content td { vertical-align: top; }
+.content td:first-child { padding-right: 20px; }
+.content td p:first-child { margin-top: 0; }
+.content td h1, .content td h2 { margin-left: 0; font-size: 1.1em; }
+
+.docblock table {
+ border: 1px solid;
+ margin: .5em 0;
+ border-collapse: collapse;
+ width: 100%;
+}
+
+.docblock table td {
+ padding: .5em;
+ border-top: 1px dashed;
+ border-bottom: 1px dashed;
+}
+
+.docblock table th {
+ padding: .5em;
+ text-align: left;
+ border-top: 1px solid;
+ border-bottom: 1px solid;
+}
+
+.fields + table {
+ margin-bottom: 1em;
+}
+
+.content .item-list {
+ list-style-type: none;
+ padding: 0;
+}
+
+.content .item-list li {
+ margin-bottom: 1em;
+}
+
+.content .multi-column {
+ -moz-column-count: 5;
+ -moz-column-gap: 2.5em;
+ -webkit-column-count: 5;
+ -webkit-column-gap: 2.5em;
+ column-count: 5;
+ column-gap: 2.5em;
+}
+.content .multi-column li { width: 100%; display: inline-block; }
+
+.content .method {
+ font-size: 1em;
+ position: relative;
+}
+/* Shift "where ..." part of method or fn definition down a line */
+.content .method .where,
+.content .fn .where,
+.content .where.fmt-newline {
+ display: block;
+ font-size: 0.8em;
+}
+
+.content .methods > div:not(.important-traits) { margin-left: 40px; }
+
+.content .impl-items .docblock, .content .impl-items .stability {
+ margin-left: 40px;
+ margin-bottom: .6em;
+}
+.content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant {
+ margin-left: 20px;
+}
+
+.content .stability code {
+ font-size: 90%;
+}
+
+nav {
+ border-bottom: 1px solid;
+ padding-bottom: 10px;
+ margin-bottom: 10px;
+}
+nav.main {
+ padding: 20px 0;
+ text-align: center;
+}
+nav.main .current {
+ border-top: 1px solid;
+ border-bottom: 1px solid;
+}
+nav.main .separator {
+ border: 1px solid;
+ display: inline-block;
+ height: 23px;
+ margin: 0 20px;
+}
+nav.sum { text-align: right; }
+nav.sub form { display: inline; }
+
+nav.sub, .content {
+ margin-left: 230px;
+}
+
+a {
+ text-decoration: none;
+ background: transparent;
+}
+
+.small-section-header:hover > .anchor {
+ display: initial;
+}
+
+.in-band:hover > .anchor {
+ display: inline-block;
+ position: absolute;
+}
+.anchor {
+ display: none;
+ position: absolute;
+ left: -25px;
+}
+.anchor.field {
+ left: -20px;
+}
+.anchor:before {
+ content: '\2002\00a7\2002';
+}
+
+.docblock a:hover, .docblock-short a:hover, .stability a {
+ text-decoration: underline;
+}
+
+.block a.current.crate { font-weight: 500; }
+
+.search-input {
+ width: 100%;
+ /* Override Normalize.css: we have margins and do
+ not want to overflow - the `moz` attribute is necessary
+ until Firefox 29, too early to drop at this point */
+ -moz-box-sizing: border-box !important;
+ box-sizing: border-box !important;
+ outline: none;
+ border: none;
+ border-radius: 1px;
+ margin-top: 5px;
+ padding: 10px 16px;
+ font-size: 17px;
+ transition: border-color 300ms ease;
+ transition: border-radius 300ms ease-in-out;
+ transition: box-shadow 300ms ease-in-out;
+}
+
+.search-input:focus {
+ border-radius: 2px;
+ border: 0;
+ outline: 0;
+ box-shadow: 0 0 8px #078dd8;
+}
+
+.search-results .desc {
+ white-space: nowrap;
+ text-overflow: ellipsis;
+ overflow: hidden;
+ display: block;
+}
+
+.search-results a {
+ display: block;
+}
+
+.content .search-results td:first-child { padding-right: 0; }
+.content .search-results td:first-child a { padding-right: 10px; }
+
+tr.result span.primitive::after {
+ content: ' (primitive type)';
+ font-style: italic;
+}
+
+body.blur > :not(#help) {
+ filter: blur(8px);
+ -webkit-filter: blur(8px);
+ opacity: .7;
+}
+
+#help {
+ width: 100%;
+ height: 100vh;
+ position: fixed;
+ top: 0;
+ left: 0;
+ display: flex;
+ justify-content: center;
+ align-items: center;
+}
+#help > div {
+ flex: 0 0 auto;
+ box-shadow: 0 0 6px rgba(0,0,0,.2);
+ width: 550px;
+ height: auto;
+ border: 1px solid;
+}
+#help dt {
+ float: left;
+ clear: left;
+ display: block;
+}
+#help dd { margin: 5px 35px; }
+#help .infos { padding-left: 0; }
+#help h1, #help h2 { margin-top: 0; }
+#help > div div {
+ width: 50%;
+ float: left;
+ padding: 20px;
+ padding-left: 17px;
+}
+
+.stab {
+ display: table;
+ border-width: 1px;
+ border-style: solid;
+ padding: 3px;
+ margin-bottom: 5px;
+ font-size: 90%;
+}
+.stab p {
+ display: inline;
+}
+
+.stab summary {
+ display: list-item;
+}
+
+.stab .microscope {
+ font-size: 1.5em;
+}
+
+.module-item .stab {
+ display: inline;
+ border-width: 0;
+ padding: 0;
+ margin: 0;
+ background: inherit !important;
+}
+
+.module-item.unstable {
+ opacity: 0.65;
+}
+
+.since {
+ font-weight: normal;
+ font-size: initial;
+ position: absolute;
+ right: 0;
+ top: 0;
+}
+
+.variants_table {
+ width: 100%;
+}
+
+.variants_table tbody tr td:first-child {
+ width: 1%; /* make the variant name as small as possible */
+}
+
+td.summary-column {
+ width: 100%;
+}
+
+.summary {
+ padding-right: 0px;
+}
+
+pre.rust .question-mark {
+ font-weight: bold;
+}
+
+a.test-arrow {
+ display: inline-block;
+ position: absolute;
+ padding: 5px 10px 5px 10px;
+ border-radius: 5px;
+ font-size: 130%;
+ top: 5px;
+ right: 5px;
+}
+a.test-arrow:hover{
+ text-decoration: none;
+}
+
+.section-header:hover a:before {
+ position: absolute;
+ left: -25px;
+ content: '\2002\00a7\2002';
+}
+
+.section-header:hover a {
+ text-decoration: none;
+}
+
+.section-header a {
+ color: inherit;
+}
+
+.collapse-toggle {
+ font-weight: 300;
+ position: absolute;
+ left: -23px;
+ top: 0;
+}
+
+h3 > .collapse-toggle, h4 > .collapse-toggle {
+ font-size: 0.8em;
+ top: 5px;
+}
+
+.toggle-wrapper > .collapse-toggle {
+ left: -24px;
+ margin-top: 0px;
+}
+
+.toggle-wrapper {
+ position: relative;
+ margin-top: 5px;
+}
+
+.toggle-wrapper.collapsed {
+ height: 25px;
+ transition: height .2s;
+ margin-bottom: .6em;
+}
+
+.collapse-toggle > .inner {
+ display: inline-block;
+ width: 1.2ch;
+ text-align: center;
+}
+
+.ghost {
+ display: none;
+}
+
+.ghost + .since {
+ position: initial;
+ display: table-cell;
+}
+
+.since + .srclink {
+ display: table-cell;
+ padding-left: 10px;
+}
+
+.item-spacer {
+ width: 100%;
+ height: 12px;
+}
+
+span.since {
+ position: initial;
+ font-size: 20px;
+ margin-right: 5px;
+}
+
+.toggle-wrapper > .collapse-toggle {
+ left: 0;
+}
+
+.variant + .toggle-wrapper + .docblock > p {
+ margin-top: 5px;
+}
+
+.sub-variant, .sub-variant > h3 {
+ margin-top: 0 !important;
+}
+
+.toggle-label {
+ display: inline-block;
+ margin-left: 4px;
+ margin-top: 3px;
+}
+
+.enum > .toggle-wrapper + .docblock, .struct > .toggle-wrapper + .docblock {
+ margin-left: 30px;
+ margin-bottom: 20px;
+ margin-top: 5px;
+}
+
+.docblock > .section-header:first-child {
+ margin-left: 15px;
+ margin-top: 0;
+}
+
+.docblock > .section-header:first-child:hover > a:before {
+ left: -10px;
+}
+
+.enum > .collapsed, .struct > .collapsed {
+ margin-bottom: 25px;
+}
+
+#main > .variant, #main > .structfield {
+ display: block;
+}
+
+.attributes {
+ display: block;
+ margin: 0px 0px 0px 30px !important;
+}
+.toggle-attributes.collapsed {
+ margin-bottom: 5px;
+}
+
+:target > code {
+ opacity: 1;
+}
+
+/* Media Queries */
+
+@media (max-width: 700px) {
+ body {
+ padding-top: 0px;
+ }
+
+ .sidebar {
+ height: 45px;
+ min-height: 40px;
+ width: calc(100% + 30px);
+ margin: 0;
+ margin-left: -15px;
+ padding: 0 15px;
+ position: static;
+ z-index: 1;
+ }
+
+ .sidebar > .location {
+ float: right;
+ margin: 0px;
+ margin-top: 2px;
+ padding: 3px 10px 1px 10px;
+ min-height: 39px;
+ background: inherit;
+ text-align: left;
+ font-size: 24px;
+ }
+
+ .sidebar .location:empty {
+ padding: 0;
+ }
+
+ .sidebar img {
+ width: 35px;
+ margin-top: 5px;
+ margin-bottom: 5px;
+ float: left;
+ margin-left: 50px;
+ }
+
+ .sidebar-menu {
+ position: fixed;
+ z-index: 10;
+ font-size: 2rem;
+ cursor: pointer;
+ width: 45px;
+ left: 0;
+ text-align: center;
+ display: block;
+ border-bottom: 1px solid;
+ border-right: 1px solid;
+ }
+
+ .sidebar-elems {
+ position: fixed;
+ z-index: 1;
+ left: 0;
+ top: 45px;
+ bottom: 0;
+ overflow-y: auto;
+ border-right: 1px solid;
+ display: none;
+ }
+
+ .sidebar > .block.version {
+ border-bottom: none;
+ margin-top: 12px;
+ }
+
+ nav.sub {
+ margin: 0 auto;
+ }
+
+ .content {
+ margin-left: 0px;
+ }
+
+ .content .in-band {
+ width: 100%;
+ }
+
+ .content h4 > .out-of-band {
+ position: inherit;
+ }
+
+ .toggle-wrapper > .collapse-toggle {
+ left: 0px;
+ }
+
+ .toggle-wrapper {
+ height: 1.5em;
+ }
+
+ #search {
+ margin-left: 0;
+ }
+
+ .content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant {
+ display: flex;
+ }
+}
+
+@media print {
+ nav.sub, .content .out-of-band, .collapse-toggle {
+ display: none;
+ }
+}
+
+.information {
+ position: absolute;
+ left: -20px;
+ margin-top: 7px;
+ z-index: 1;
+}
+
+.tooltip {
+ position: relative;
+ display: inline-block;
+ cursor: pointer;
+}
+
+.tooltip .tooltiptext {
+ width: 120px;
+ display: none;
+ text-align: center;
+ padding: 5px 3px;
+ border-radius: 6px;
+ margin-left: 5px;
+ top: -5px;
+ left: 105%;
+ z-index: 1;
+}
+
+.tooltip:hover .tooltiptext {
+ display: inline;
+}
+
+.tooltip .tooltiptext::after {
+ content: " ";
+ position: absolute;
+ top: 50%;
+ left: 11px;
+ margin-top: -5px;
+ border-width: 5px;
+ border-style: solid;
+}
+
+.important-traits .tooltip .tooltiptext {
+ border: 1px solid;
+}
+
+pre.rust {
+ position: relative;
+}
+
+.search-failed {
+ text-align: center;
+ margin-top: 20px;
+}
+
+#titles {
+ height: 35px;
+}
+
+#titles > div {
+ float: left;
+ width: 33.3%;
+ text-align: center;
+ border-bottom: 1px solid;
+ font-size: 18px;
+ cursor: pointer;
+}
+
+#titles > div.selected {
+ border-bottom: 3px solid;
+}
+
+#titles > div:hover {
+ border-bottom: 3px solid;
+}
+
+#titles > div > div.count {
+ display: inline-block;
+ font-size: 16px;
+}
+
+.important-traits {
+ cursor: pointer;
+ z-index: 2;
+}
+
+h4 > .important-traits {
+ position: absolute;
+ left: -44px;
+ top: 2px;
+}
+
+@media (max-width: 700px) {
+ h4 > .important-traits {
+ position: absolute;
+ left: -22px;
+ top: 24px;
+ }
+
+ #titles > div > div.count {
+ float: left;
+ width: 100%;
+ }
+
+ #titles {
+ height: 50px;
+ }
+
+ .sidebar.mobile {
+ position: fixed;
+ width: 100%;
+ margin-left: 0;
+ background-color: rgba(0,0,0,0);
+ height: 100%;
+ }
+
+ .show-it {
+ display: block;
+ }
+
+ /* Because of ios, we need to actually have a full height sidebar title so the
+ * actual sidebar can show up. But then we need to make it transparent so we don't
+ * hide content. The filler just allows to create the background for the sidebar
+ * title. But because of the absolute position, I had to lower the z-index.
+ */
+ #sidebar-filler {
+ position: fixed;
+ left: 45px;
+ width: calc(100% - 45px);
+ top: 0;
+ height: 45px;
+ z-index: -1;
+ border-bottom: 1px solid;
+ }
+}
+
+
+@media (max-width: 416px) {
+ #titles {
+ height: 73px;
+ }
+
+ #titles > div {
+ height: 73px;
+ }
+}
+
+.modal {
+ position: fixed;
+ width: 100vw;
+ height: 100vh;
+ z-index: 10000;
+ top: 0;
+ left: 0;
+}
+
+.modal-content {
+ display: block;
+ max-width: 60%;
+ min-width: 200px;
+ padding: 8px;
+ top: 40%;
+ position: absolute;
+ left: 50%;
+ transform: translate(-50%, -40%);
+ border: 1px solid;
+ border-radius: 4px;
+ border-top-right-radius: 0;
+}
+
+.modal-content > .docblock {
+ margin: 0;
+}
+
+h3.important {
+ margin: 0;
+ margin-bottom: 13px;
+ font-size: 19px;
+}
+
+.modal-content > .docblock > code.content {
+ margin: 0;
+ padding: 0;
+ font-size: 20px;
+}
+
+.modal-content > .close {
+ position: absolute;
+ font-weight: 900;
+ right: -25px;
+ top: -1px;
+ font-size: 18px;
+ width: 25px;
+ padding-right: 2px;
+ border-top-right-radius: 5px;
+ border-bottom-right-radius: 5px;
+ text-align: center;
+ border: 1px solid;
+ border-right: 0;
+ cursor: pointer;
+}
+
+.modal-content > .whiter {
+ height: 25px;
+ position: absolute;
+ width: 3px;
+ right: -2px;
+ top: 0px;
+}
+
+#main > div.important-traits {
+ position: absolute;
+ left: -24px;
+ margin-top: 16px;
+}
+
+.content > .methods > div.important-traits {
+ position: absolute;
+ left: -42px;
+ margin-top: 2px;
+}
+
+kbd {
+ display: inline-block;
+ padding: 3px 5px;
+ font: 15px "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
+ line-height: 10px;
+ vertical-align: middle;
+ border: solid 1px;
+ border-radius: 3px;
+ box-shadow: inset 0 -1px 0;
+ cursor: default;
+}
+
+.theme-picker {
+ position: absolute;
+ left: 211px;
+ top: 19px;
+}
+
+#theme-picker {
+ padding: 4px;
+ width: 27px;
+ height: 29px;
+ border: 1px solid;
+ border-radius: 3px;
+ cursor: pointer;
+}
+
+#theme-choices {
+ display: none;
+ position: absolute;
+ left: 0;
+ top: 28px;
+ border: 1px solid;
+ border-radius: 3px;
+ z-index: 1;
+ cursor: pointer;
+}
+
+#theme-choices > button {
+ border: none;
+ width: 100%;
+ padding: 4px;
+ text-align: center;
+ background: rgba(0,0,0,0);
+}
+
+#theme-choices > button:not(:first-child) {
+ border-top: 1px solid;
+}
+
+@media (max-width: 700px) {
+ .theme-picker {
+ left: 109px;
+ top: 7px;
+ z-index: 1;
+ }
+}
diff --git a/search-index.js b/search-index.js
new file mode 100644
index 0000000..e0869a3
--- /dev/null
+++ b/search-index.js
@@ -0,0 +1,3 @@
+var searchIndex = {};
+searchIndex["tokio_core"] = {"doc":"`Future`-powered I/O at the core of Tokio","items":[[0,"net","tokio_core","TCP/UDP bindings for `tokio-core`",null,null],[3,"TcpStream","tokio_core::net","An I/O object representing a TCP stream connected to a remote endpoint.",null,null],[3,"TcpStreamNew","","Future returned by `TcpStream::connect` which will resolve to a `TcpStream` when the stream is connected.",null,null],[3,"TcpListener","","An I/O object representing a TCP socket listening for incoming connections.",null,null],[3,"Incoming","","Stream returned by the `TcpListener::incoming` function representing the stream of sockets received from a listener.",null,null],[3,"UdpSocket","","An I/O object representing a UDP socket.",null,null],[3,"UdpFramed","","A unified `Stream` and `Sink` interface to an underlying `UdpSocket`, using the `UdpCodec` trait to encode and decode frames.",null,null],[3,"SendDgram","","A future used to write the entire contents of some data to a UDP socket.",null,null],[3,"RecvDgram","","A future used to receive a datagram from a UDP socket.",null,null],[11,"as_raw_fd","","",0,{"inputs":[{"name":"self"}],"output":{"name":"rawfd"}}],[11,"as_raw_fd","","",1,{"inputs":[{"name":"self"}],"output":{"name":"rawfd"}}],[11,"bind","","Create a new TCP listener associated with this event loop.",1,{"inputs":[{"name":"socketaddr"},{"name":"handle"}],"output":{"generics":["tcplistener"],"name":"result"}}],[11,"accept","","Attempt to accept a connection and create a new connected `TcpStream` if successful.",1,{"inputs":[{"name":"self"}],"output":{"name":"result"}}],[11,"accept_std","","Like `accept`, except that it returns a raw `std::net::TcpStream`.",1,{"inputs":[{"name":"self"}],"output":{"name":"result"}}],[11,"from_listener","","Create a new TCP listener from the standard library's TCP listener.",1,{"inputs":[{"name":"tcplistener"},{"name":"socketaddr"},{"name":"handle"}],"output":{"generics":["tcplistener"],"name":"result"}}],[11,"poll_read","","Test whether this socket is ready to be read or not.",1,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"local_addr","","Returns the local address that this listener is bound to.",1,{"inputs":[{"name":"self"}],"output":{"generics":["socketaddr"],"name":"result"}}],[11,"incoming","","Consumes this listener, returning a stream of the sockets this listener accepts.",1,{"inputs":[{"name":"self"}],"output":{"name":"incoming"}}],[11,"set_ttl","","Sets the value for the `IP_TTL` option on this socket.",1,{"inputs":[{"name":"self"},{"name":"u32"}],"output":{"name":"result"}}],[11,"ttl","","Gets the value of the `IP_TTL` option for this socket.",1,{"inputs":[{"name":"self"}],"output":{"generics":["u32"],"name":"result"}}],[11,"set_only_v6","","Sets the value for the `IPV6_V6ONLY` option on this socket.",1,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"only_v6","","Gets the value of the `IPV6_V6ONLY` option for this socket.",1,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"fmt","","",1,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"poll","","",2,{"inputs":[{"name":"self"}],"output":{"generics":["option","error"],"name":"poll"}}],[11,"connect","","Create a new TCP stream connected to the specified address.",0,{"inputs":[{"name":"socketaddr"},{"name":"handle"}],"output":{"name":"tcpstreamnew"}}],[11,"from_stream","","Create a new `TcpStream` from a `net::TcpStream`.",0,{"inputs":[{"name":"tcpstream"},{"name":"handle"}],"output":{"generics":["tcpstream"],"name":"result"}}],[11,"connect_stream","","Creates a new `TcpStream` from the pending socket inside the given `std::net::TcpStream`, connecting it to the address specified.",0,{"inputs":[{"name":"tcpstream"},{"name":"socketaddr"},{"name":"handle"}],"output":{"generics":["future"],"name":"box"}}],[11,"poll_read","","Test whether this socket is ready to be read or not.",0,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"poll_write","","Test whether this socket is ready to be written to or not.",0,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"local_addr","","Returns the local address that this stream is bound to.",0,{"inputs":[{"name":"self"}],"output":{"generics":["socketaddr"],"name":"result"}}],[11,"peer_addr","","Returns the remote address that this stream is connected to.",0,{"inputs":[{"name":"self"}],"output":{"generics":["socketaddr"],"name":"result"}}],[11,"peek","","Receives data on the socket from the remote address to which it is connected, without removing that data from the queue. On success, returns the number of bytes peeked.",0,null],[11,"shutdown","","Shuts down the read, write, or both halves of this connection.",0,{"inputs":[{"name":"self"},{"name":"shutdown"}],"output":{"name":"result"}}],[11,"set_nodelay","","Sets the value of the `TCP_NODELAY` option on this socket.",0,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"nodelay","","Gets the value of the `TCP_NODELAY` option on this socket.",0,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"set_recv_buffer_size","","Sets the value of the `SO_RCVBUF` option on this socket.",0,{"inputs":[{"name":"self"},{"name":"usize"}],"output":{"name":"result"}}],[11,"recv_buffer_size","","Gets the value of the `SO_RCVBUF` option on this socket.",0,{"inputs":[{"name":"self"}],"output":{"generics":["usize"],"name":"result"}}],[11,"set_send_buffer_size","","Sets the value of the `SO_SNDBUF` option on this socket.",0,{"inputs":[{"name":"self"},{"name":"usize"}],"output":{"name":"result"}}],[11,"send_buffer_size","","Gets the value of the `SO_SNDBUF` option on this socket.",0,{"inputs":[{"name":"self"}],"output":{"generics":["usize"],"name":"result"}}],[11,"set_keepalive","","Sets whether keepalive messages are enabled to be sent on this socket.",0,{"inputs":[{"name":"self"},{"generics":["duration"],"name":"option"}],"output":{"name":"result"}}],[11,"keepalive","","Returns whether keepalive messages are enabled on this socket, and if so the duration of time between them.",0,{"inputs":[{"name":"self"}],"output":{"generics":["option"],"name":"result"}}],[11,"set_ttl","","Sets the value for the `IP_TTL` option on this socket.",0,{"inputs":[{"name":"self"},{"name":"u32"}],"output":{"name":"result"}}],[11,"ttl","","Gets the value of the `IP_TTL` option for this socket.",0,{"inputs":[{"name":"self"}],"output":{"generics":["u32"],"name":"result"}}],[11,"set_only_v6","","Sets the value for the `IPV6_V6ONLY` option on this socket.",0,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"only_v6","","Gets the value of the `IPV6_V6ONLY` option for this socket.",0,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"set_linger","","Sets the linger duration of this socket by setting the SO_LINGER option",0,{"inputs":[{"name":"self"},{"generics":["duration"],"name":"option"}],"output":{"name":"result"}}],[11,"linger","","reads the linger duration for this socket by getting the SO_LINGER option",0,{"inputs":[{"name":"self"}],"output":{"generics":["option"],"name":"result"}}],[11,"read","","",0,null],[11,"write","","",0,null],[11,"flush","","",0,{"inputs":[{"name":"self"}],"output":{"name":"result"}}],[11,"prepare_uninitialized_buffer","","",0,null],[11,"read_buf","","",0,{"inputs":[{"name":"self"},{"name":"b"}],"output":{"generics":["usize","error"],"name":"poll"}}],[11,"shutdown","","",0,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"write_buf","","",0,{"inputs":[{"name":"self"},{"name":"b"}],"output":{"generics":["usize","error"],"name":"poll"}}],[11,"fmt","","",0,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"poll","","",3,{"inputs":[{"name":"self"}],"output":{"generics":["tcpstream","error"],"name":"poll"}}],[11,"poll","","",4,{"inputs":[{"name":"self"}],"output":{"generics":["option","error"],"name":"poll"}}],[11,"start_send","","",4,null],[11,"poll_complete","","",4,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"close","","",4,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"get_ref","","Returns a reference to the underlying I/O stream wrapped by `Framed`.",4,{"inputs":[{"name":"self"}],"output":{"name":"udpsocket"}}],[11,"get_mut","","Returns a mutable reference to the underlying I/O stream wrapped by `Framed`.",4,{"inputs":[{"name":"self"}],"output":{"name":"udpsocket"}}],[11,"into_inner","","Consumes the `Framed`, returning its underlying I/O stream.",4,{"inputs":[{"name":"self"}],"output":{"name":"udpsocket"}}],[11,"as_raw_fd","","",5,{"inputs":[{"name":"self"}],"output":{"name":"rawfd"}}],[11,"bind","","Create a new UDP socket bound to the specified address.",5,{"inputs":[{"name":"socketaddr"},{"name":"handle"}],"output":{"generics":["udpsocket"],"name":"result"}}],[11,"from_socket","","Creates a new `UdpSocket` from the previously bound socket provided.",5,{"inputs":[{"name":"udpsocket"},{"name":"handle"}],"output":{"generics":["udpsocket"],"name":"result"}}],[11,"framed","","Provides a `Stream` and `Sink` interface for reading and writing to this `UdpSocket` object, using the provided `UdpCodec` to read and write the raw data.",5,{"inputs":[{"name":"self"},{"name":"c"}],"output":{"name":"udpframed"}}],[11,"local_addr","","Returns the local address that this stream is bound to.",5,{"inputs":[{"name":"self"}],"output":{"generics":["socketaddr"],"name":"result"}}],[11,"connect","","Connects the UDP socket setting the default destination for send() and limiting packets that are read via recv from the address specified in addr.",5,{"inputs":[{"name":"self"},{"name":"socketaddr"}],"output":{"name":"result"}}],[11,"send","","Sends data on the socket to the address previously bound via connect(). On success, returns the number of bytes written.",5,null],[11,"recv","","Receives data from the socket previously bound with connect(). On success, returns the number of bytes read.",5,null],[11,"poll_read","","Test whether this socket is ready to be read or not.",5,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"poll_write","","Test whether this socket is ready to be written to or not.",5,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"send_to","","Sends data on the socket to the given address. On success, returns the number of bytes written.",5,null],[11,"send_dgram","","Creates a future that will write the entire contents of the buffer `buf` provided as a datagram to this socket.",5,{"inputs":[{"name":"self"},{"name":"t"},{"name":"socketaddr"}],"output":{"name":"senddgram"}}],[11,"recv_from","","Receives data from the socket. On success, returns the number of bytes read and the address from whence the data came.",5,null],[11,"recv_dgram","","Creates a future that receive a datagram to be written to the buffer provided.",5,{"inputs":[{"name":"self"},{"name":"t"}],"output":{"name":"recvdgram"}}],[11,"broadcast","","Gets the value of the `SO_BROADCAST` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"set_broadcast","","Sets the value of the `SO_BROADCAST` option for this socket.",5,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"multicast_loop_v4","","Gets the value of the `IP_MULTICAST_LOOP` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"set_multicast_loop_v4","","Sets the value of the `IP_MULTICAST_LOOP` option for this socket.",5,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"multicast_ttl_v4","","Gets the value of the `IP_MULTICAST_TTL` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["u32"],"name":"result"}}],[11,"set_multicast_ttl_v4","","Sets the value of the `IP_MULTICAST_TTL` option for this socket.",5,{"inputs":[{"name":"self"},{"name":"u32"}],"output":{"name":"result"}}],[11,"multicast_loop_v6","","Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"set_multicast_loop_v6","","Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket.",5,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"ttl","","Gets the value of the `IP_TTL` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["u32"],"name":"result"}}],[11,"set_ttl","","Sets the value for the `IP_TTL` option on this socket.",5,{"inputs":[{"name":"self"},{"name":"u32"}],"output":{"name":"result"}}],[11,"join_multicast_v4","","Executes an operation of the `IP_ADD_MEMBERSHIP` type.",5,{"inputs":[{"name":"self"},{"name":"ipv4addr"},{"name":"ipv4addr"}],"output":{"name":"result"}}],[11,"join_multicast_v6","","Executes an operation of the `IPV6_ADD_MEMBERSHIP` type.",5,{"inputs":[{"name":"self"},{"name":"ipv6addr"},{"name":"u32"}],"output":{"name":"result"}}],[11,"leave_multicast_v4","","Executes an operation of the `IP_DROP_MEMBERSHIP` type.",5,{"inputs":[{"name":"self"},{"name":"ipv4addr"},{"name":"ipv4addr"}],"output":{"name":"result"}}],[11,"leave_multicast_v6","","Executes an operation of the `IPV6_DROP_MEMBERSHIP` type.",5,{"inputs":[{"name":"self"},{"name":"ipv6addr"},{"name":"u32"}],"output":{"name":"result"}}],[11,"set_only_v6","","Sets the value for the `IPV6_V6ONLY` option on this socket.",5,{"inputs":[{"name":"self"},{"name":"bool"}],"output":{"name":"result"}}],[11,"only_v6","","Gets the value of the `IPV6_V6ONLY` option for this socket.",5,{"inputs":[{"name":"self"}],"output":{"generics":["bool"],"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"poll","","",6,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"poll","","",7,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[8,"UdpCodec","","Encoding of frames via buffers.",null,null],[16,"In","","The type of decoded frames.",8,null],[16,"Out","","The type of frames to be encoded.",8,null],[10,"decode","","Attempts to decode a frame from the provided buffer of bytes.",8,null],[10,"encode","","Encodes a frame into the buffer provided.",8,null],[0,"reactor","tokio_core","The core reactor driving all I/O",null,null],[3,"PollEvented","tokio_core::reactor","A concrete implementation of a stream of readiness notifications for I/O objects that originates from an event loop.",null,null],[3,"Timeout","","A future representing the notification that a timeout has occurred.",null,null],[3,"Interval","","A stream representing notifications at fixed interval",null,null],[3,"Core","","An event loop.",null,null],[3,"CoreId","","An unique ID for a Core",null,null],[3,"Remote","","Handle to an event loop, used to construct I/O objects, send messages, and otherwise interact indirectly with the event loop itself.",null,null],[3,"Handle","","A non-sendable handle to an event loop, useful for manufacturing instances of `LoopData`.",null,null],[11,"fmt","","",9,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new readiness stream associated with the provided `loop_handle` and for the given `source`.",9,{"inputs":[{"name":"e"},{"name":"handle"}],"output":{"generics":["pollevented"],"name":"result"}}],[11,"deregister","","Deregisters this source of events from the reactor core specified.",9,{"inputs":[{"name":"self"},{"name":"handle"}],"output":{"name":"result"}}],[11,"poll_read","","Tests to see if this source is ready to be read from or not.",9,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"poll_write","","Tests to see if this source is ready to be written to or not.",9,{"inputs":[{"name":"self"}],"output":{"name":"async"}}],[11,"poll_ready","","Test to see whether this source fulfills any condition listed in `mask` provided.",9,{"inputs":[{"name":"self"},{"name":"ready"}],"output":{"generics":["ready"],"name":"async"}}],[11,"need_read","","Indicates to this source of events that the corresponding I/O object is no longer readable, but it needs to be.",9,{"inputs":[{"name":"self"}],"output":null}],[11,"need_write","","Indicates to this source of events that the corresponding I/O object is no longer writable, but it needs to be.",9,{"inputs":[{"name":"self"}],"output":null}],[11,"remote","","Returns a reference to the event loop handle that this readiness stream is associated with.",9,{"inputs":[{"name":"self"}],"output":{"name":"remote"}}],[11,"get_ref","","Returns a shared reference to the underlying I/O object this readiness stream is wrapping.",9,{"inputs":[{"name":"self"}],"output":{"name":"e"}}],[11,"get_mut","","Returns a mutable reference to the underlying I/O object this readiness stream is wrapping.",9,{"inputs":[{"name":"self"}],"output":{"name":"e"}}],[11,"read","","",9,null],[11,"write","","",9,null],[11,"flush","","",9,{"inputs":[{"name":"self"}],"output":{"name":"result"}}],[11,"shutdown","","",9,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"drop","","",9,{"inputs":[{"name":"self"}],"output":null}],[11,"fmt","","",10,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new timeout which will fire at `dur` time into the future.",10,{"inputs":[{"name":"duration"},{"name":"handle"}],"output":{"generics":["timeout"],"name":"result"}}],[11,"new_at","","Creates a new timeout which will fire at the time specified by `at`.",10,{"inputs":[{"name":"instant"},{"name":"handle"}],"output":{"generics":["timeout"],"name":"result"}}],[11,"reset","","Resets this timeout to an new timeout which will fire at the time specified by `at`.",10,{"inputs":[{"name":"self"},{"name":"instant"}],"output":null}],[11,"poll","","",10,{"inputs":[{"name":"self"}],"output":{"generics":["error"],"name":"poll"}}],[11,"drop","","",10,{"inputs":[{"name":"self"}],"output":null}],[11,"new","","Creates a new interval which will fire at `dur` time into the future, and will repeat every `dur` interval after",11,{"inputs":[{"name":"duration"},{"name":"handle"}],"output":{"generics":["interval"],"name":"result"}}],[11,"new_at","","Creates a new interval which will fire at the time specified by `at`, and then will repeat every `dur` interval after",11,{"inputs":[{"name":"instant"},{"name":"duration"},{"name":"handle"}],"output":{"generics":["interval"],"name":"result"}}],[11,"poll","","",11,{"inputs":[{"name":"self"}],"output":{"generics":["option","error"],"name":"poll"}}],[11,"drop","","",11,{"inputs":[{"name":"self"}],"output":null}],[11,"clone","","",12,{"inputs":[{"name":"self"}],"output":{"name":"coreid"}}],[11,"eq","","",12,{"inputs":[{"name":"self"},{"name":"coreid"}],"output":{"name":"bool"}}],[11,"ne","","",12,{"inputs":[{"name":"self"},{"name":"coreid"}],"output":{"name":"bool"}}],[11,"hash","","",12,null],[11,"fmt","","",12,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",13,{"inputs":[{"name":"self"}],"output":{"name":"remote"}}],[11,"clone","","",14,{"inputs":[{"name":"self"}],"output":{"name":"handle"}}],[11,"new","","Creates a new event loop, returning any error that happened during the creation.",15,{"inputs":[],"output":{"generics":["core"],"name":"result"}}],[11,"handle","","Returns a handle to this event loop which cannot be sent across threads but can be used as a proxy to the event loop itself.",15,{"inputs":[{"name":"self"}],"output":{"name":"handle"}}],[11,"remote","","Generates a remote handle to this event loop which can be used to spawn tasks from other threads into this event loop.",15,{"inputs":[{"name":"self"}],"output":{"name":"remote"}}],[11,"run","","Runs a future until completion, driving the event loop while we're otherwise waiting for the future to complete.",15,{"inputs":[{"name":"self"},{"name":"f"}],"output":{"name":"result"}}],[11,"turn","","Performs one iteration of the event loop, blocking on waiting for events for at most `max_wait` (forever if `None`).",15,{"inputs":[{"name":"self"},{"generics":["duration"],"name":"option"}],"output":null}],[11,"id","","Get the ID of this loop",15,{"inputs":[{"name":"self"}],"output":{"name":"coreid"}}],[11,"execute","","",15,{"inputs":[{"name":"self"},{"name":"f"}],"output":{"generics":["executeerror"],"name":"result"}}],[11,"fmt","","",15,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"spawn","","Spawns a new future into the event loop this remote is associated with.",13,{"inputs":[{"name":"self"},{"name":"f"}],"output":null}],[11,"id","","Return the ID of the represented Core",13,{"inputs":[{"name":"self"}],"output":{"name":"coreid"}}],[11,"handle","","Attempts to \"promote\" this remote to a handle, if possible.",13,{"inputs":[{"name":"self"}],"output":{"generics":["handle"],"name":"option"}}],[11,"execute","","",13,{"inputs":[{"name":"self"},{"name":"f"}],"output":{"generics":["executeerror"],"name":"result"}}],[11,"fmt","","",13,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"remote","","Returns a reference to the underlying remote handle to the event loop.",14,{"inputs":[{"name":"self"}],"output":{"name":"remote"}}],[11,"spawn","","Spawns a new future on the event loop this handle is associated with.",14,{"inputs":[{"name":"self"},{"name":"f"}],"output":null}],[11,"spawn_fn","","Spawns a closure on this event loop.",14,{"inputs":[{"name":"self"},{"name":"f"}],"output":null}],[11,"id","","Return the ID of the represented Core",14,{"inputs":[{"name":"self"}],"output":{"name":"coreid"}}],[11,"execute","","",14,{"inputs":[{"name":"self"},{"name":"f"}],"output":{"generics":["executeerror"],"name":"result"}}],[11,"fmt","","",14,{"inputs":[{"name":"self"},{"name":"formatter"}],"output":{"name":"result"}}],[14,"try_nb","tokio_core","A convenience macro for working with `io::Result<T>` from the `Read` and `Write` traits.",null,null]],"paths":[[3,"TcpStream"],[3,"TcpListener"],[3,"Incoming"],[3,"TcpStreamNew"],[3,"UdpFramed"],[3,"UdpSocket"],[3,"SendDgram"],[3,"RecvDgram"],[8,"UdpCodec"],[3,"PollEvented"],[3,"Timeout"],[3,"Interval"],[3,"CoreId"],[3,"Remote"],[3,"Handle"],[3,"Core"]]};
+initSearch(searchIndex);
diff --git a/src/tokio_core/heap.rs.html b/src/tokio_core/heap.rs.html
new file mode 100644
index 0000000..8a0d798
--- /dev/null
+++ b/src/tokio_core/heap.rs.html
@@ -0,0 +1,733 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/heap.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>heap.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! A simple binary heap with support for removal of arbitrary elements</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This heap is used to manage timer state in the event loop. All timeouts go</span>
+<span class="doccomment">//! into this heap and we also cancel timeouts from this heap. The crucial</span>
+<span class="doccomment">//! feature of this heap over the standard library's `BinaryHeap` is the ability</span>
+<span class="doccomment">//! to remove arbitrary elements. (e.g. when a timer is canceled)</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! Note that this heap is not at all optimized right now, it should hopefully</span>
+<span class="doccomment">//! just work.</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">slab</span>::<span class="ident">Slab</span>;
+
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Heap</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="comment">// Binary heap of items, plus the slab index indicating what position in the</span>
+ <span class="comment">// list they're in.</span>
+ <span class="ident">items</span>: <span class="ident">Vec</span><span class="op"><</span>(<span class="ident">T</span>, <span class="ident">usize</span>)<span class="op">></span>,
+
+ <span class="comment">// A map from a slab index (assigned to an item above) to the actual index</span>
+ <span class="comment">// in the array the item appears at.</span>
+ <span class="ident">index</span>: <span class="ident">Slab</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span>,
+}
+
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Slot</span> {
+ <span class="ident">idx</span>: <span class="ident">usize</span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Ord</span><span class="op">></span> <span class="ident">Heap</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">Heap</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="ident">Heap</span> {
+ <span class="ident">items</span>: <span class="ident">Vec</span>::<span class="ident">new</span>(),
+ <span class="ident">index</span>: <span class="ident">Slab</span>::<span class="ident">with_capacity</span>(<span class="number">128</span>),
+ }
+ }
+
+ <span class="doccomment">/// Pushes an element onto this heap, returning a slot token indicating</span>
+ <span class="doccomment">/// where it was pushed on to.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The slot can later get passed to `remove` to remove the element from the</span>
+ <span class="doccomment">/// heap, but only if the element was previously not removed from the heap.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">push</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">t</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">Slot</span> {
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="kw">let</span> <span class="ident">len</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">len</span>();
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">capacity</span>() {
+ <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">reserve_exact</span>(<span class="ident">len</span>);
+ }
+ <span class="kw">let</span> <span class="ident">slot_idx</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">insert</span>(<span class="ident">len</span>);
+ <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">push</span>((<span class="ident">t</span>, <span class="ident">slot_idx</span>));
+ <span class="self">self</span>.<span class="ident">percolate_up</span>(<span class="ident">len</span>);
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="ident">Slot</span> { <span class="ident">idx</span>: <span class="ident">slot_idx</span> }
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">peek</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">T</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">get</span>(<span class="number">0</span>).<span class="ident">map</span>(<span class="op">|</span><span class="ident">i</span><span class="op">|</span> <span class="kw-2">&</span><span class="ident">i</span>.<span class="number">0</span>)
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">pop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="number">0</span> {
+ <span class="kw">return</span> <span class="prelude-val">None</span>
+ }
+ <span class="kw">let</span> <span class="ident">slot</span> <span class="op">=</span> <span class="ident">Slot</span> { <span class="ident">idx</span>: <span class="self">self</span>.<span class="ident">items</span>[<span class="number">0</span>].<span class="number">1</span> };
+ <span class="prelude-val">Some</span>(<span class="self">self</span>.<span class="ident">remove</span>(<span class="ident">slot</span>))
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">remove</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">slot</span>: <span class="ident">Slot</span>) <span class="op">-></span> <span class="ident">T</span> {
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="kw">let</span> <span class="ident">idx</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">remove</span>(<span class="ident">slot</span>.<span class="ident">idx</span>);
+ <span class="kw">let</span> (<span class="ident">item</span>, <span class="ident">slot_idx</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">swap_remove</span>(<span class="ident">idx</span>);
+ <span class="macro">debug_assert_eq</span><span class="macro">!</span>(<span class="ident">slot</span>.<span class="ident">idx</span>, <span class="ident">slot_idx</span>);
+ <span class="kw">if</span> <span class="ident">idx</span> <span class="op"><</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">len</span>() {
+ <span class="self">self</span>.<span class="ident">index</span>[<span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">1</span>] <span class="op">=</span> <span class="ident">idx</span>;
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">0</span> <span class="op"><</span> <span class="ident">item</span> {
+ <span class="self">self</span>.<span class="ident">percolate_up</span>(<span class="ident">idx</span>);
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">percolate_down</span>(<span class="ident">idx</span>);
+ }
+ }
+ <span class="self">self</span>.<span class="ident">assert_consistent</span>();
+ <span class="kw">return</span> <span class="ident">item</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">percolate_up</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="kw-2">mut</span> <span class="ident">idx</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="kw">while</span> <span class="ident">idx</span> <span class="op">></span> <span class="number">0</span> {
+ <span class="kw">let</span> <span class="ident">parent</span> <span class="op">=</span> (<span class="ident">idx</span> <span class="op">-</span> <span class="number">1</span>) <span class="op">/</span> <span class="number">2</span>;
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">0</span> <span class="op">>=</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">parent</span>].<span class="number">0</span> {
+ <span class="kw">break</span>
+ }
+ <span class="kw">let</span> (<span class="ident">a</span>, <span class="ident">b</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">split_at_mut</span>(<span class="ident">idx</span>);
+ <span class="ident">mem</span>::<span class="ident">swap</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">a</span>[<span class="ident">parent</span>], <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">b</span>[<span class="number">0</span>]);
+ <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">a</span>[<span class="ident">parent</span>].<span class="number">1</span>] <span class="op">=</span> <span class="ident">parent</span>;
+ <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">b</span>[<span class="number">0</span>].<span class="number">1</span>] <span class="op">=</span> <span class="ident">idx</span>;
+ <span class="ident">idx</span> <span class="op">=</span> <span class="ident">parent</span>;
+ }
+ <span class="kw">return</span> <span class="ident">idx</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">percolate_down</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="kw-2">mut</span> <span class="ident">idx</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="kw">loop</span> {
+ <span class="kw">let</span> <span class="ident">left</span> <span class="op">=</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">idx</span> <span class="op">+</span> <span class="number">1</span>;
+ <span class="kw">let</span> <span class="ident">right</span> <span class="op">=</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">idx</span> <span class="op">+</span> <span class="number">2</span>;
+
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">swap_left</span> <span class="op">=</span> <span class="bool-val">true</span>;
+ <span class="kw">match</span> (<span class="self">self</span>.<span class="ident">items</span>.<span class="ident">get</span>(<span class="ident">left</span>), <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">get</span>(<span class="ident">right</span>)) {
+ (<span class="prelude-val">Some</span>(<span class="ident">left</span>), <span class="prelude-val">None</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">left</span>.<span class="number">0</span> <span class="op">>=</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">0</span> {
+ <span class="kw">break</span>
+ }
+ }
+ (<span class="prelude-val">Some</span>(<span class="ident">left</span>), <span class="prelude-val">Some</span>(<span class="ident">right</span>)) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">left</span>.<span class="number">0</span> <span class="op"><</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">0</span> {
+ <span class="kw">if</span> <span class="ident">right</span>.<span class="number">0</span> <span class="op"><</span> <span class="ident">left</span>.<span class="number">0</span> {
+ <span class="ident">swap_left</span> <span class="op">=</span> <span class="bool-val">false</span>;
+ }
+ } <span class="kw">else</span> <span class="kw">if</span> <span class="ident">right</span>.<span class="number">0</span> <span class="op"><</span> <span class="self">self</span>.<span class="ident">items</span>[<span class="ident">idx</span>].<span class="number">0</span> {
+ <span class="ident">swap_left</span> <span class="op">=</span> <span class="bool-val">false</span>;
+ } <span class="kw">else</span> {
+ <span class="kw">break</span>
+ }
+ }
+
+ (<span class="prelude-val">None</span>, <span class="prelude-val">None</span>) <span class="op">=></span> <span class="kw">break</span>,
+ (<span class="prelude-val">None</span>, <span class="prelude-val">Some</span>(<span class="ident">_right</span>)) <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"not possible"</span>),
+ }
+
+ <span class="kw">let</span> (<span class="ident">a</span>, <span class="ident">b</span>) <span class="op">=</span> <span class="kw">if</span> <span class="ident">swap_left</span> {
+ <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">split_at_mut</span>(<span class="ident">left</span>)
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">split_at_mut</span>(<span class="ident">right</span>)
+ };
+ <span class="ident">mem</span>::<span class="ident">swap</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">a</span>[<span class="ident">idx</span>], <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">b</span>[<span class="number">0</span>]);
+ <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">a</span>[<span class="ident">idx</span>].<span class="number">1</span>] <span class="op">=</span> <span class="ident">idx</span>;
+ <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">b</span>[<span class="number">0</span>].<span class="number">1</span>] <span class="op">=</span> <span class="ident">a</span>.<span class="ident">len</span>();
+ <span class="ident">idx</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">len</span>();
+ }
+ <span class="kw">return</span> <span class="ident">idx</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">assert_consistent</span>(<span class="kw-2">&</span><span class="self">self</span>) {
+ <span class="kw">if</span> <span class="op">!</span><span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">assert_timer_heap_consistent</span>) {
+ <span class="kw">return</span>
+ }
+
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">items</span>.<span class="ident">len</span>(), <span class="self">self</span>.<span class="ident">index</span>.<span class="ident">len</span>());
+
+ <span class="kw">for</span> (<span class="ident">i</span>, <span class="kw-2">&</span>(_, <span class="ident">j</span>)) <span class="kw">in</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">iter</span>().<span class="ident">enumerate</span>() {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">j</span>] <span class="op">!=</span> <span class="ident">i</span> {
+ <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"self.index[j] != i : i={} j={} self.index[j]={}"</span>,
+ <span class="ident">i</span>, <span class="ident">j</span>, <span class="self">self</span>.<span class="ident">index</span>[<span class="ident">j</span>]);
+ }
+ }
+
+ <span class="kw">for</span> (<span class="ident">i</span>, <span class="kw-2">&</span>(<span class="kw-2">ref</span> <span class="ident">item</span>, _)) <span class="kw">in</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">iter</span>().<span class="ident">enumerate</span>() {
+ <span class="kw">if</span> <span class="ident">i</span> <span class="op">></span> <span class="number">0</span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">item</span> <span class="op">>=</span> <span class="self">self</span>.<span class="ident">items</span>[(<span class="ident">i</span> <span class="op">-</span> <span class="number">1</span>) <span class="op">/</span> <span class="number">2</span>].<span class="number">0</span>, <span class="string">"bad at index: {}"</span>, <span class="ident">i</span>);
+ }
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">left</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">get</span>(<span class="number">2</span> <span class="op">*</span> <span class="ident">i</span> <span class="op">+</span> <span class="number">1</span>) {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">item</span> <span class="op"><=</span> <span class="ident">left</span>.<span class="number">0</span>, <span class="string">"bad left at index: {}"</span>, <span class="ident">i</span>);
+ }
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">right</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">items</span>.<span class="ident">get</span>(<span class="number">2</span> <span class="op">*</span> <span class="ident">i</span> <span class="op">+</span> <span class="number">2</span>) {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">item</span> <span class="op"><=</span> <span class="ident">right</span>.<span class="number">0</span>, <span class="string">"bad right at index: {}"</span>, <span class="ident">i</span>);
+ }
+ }
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">test</span>)]</span>
+<span class="kw">mod</span> <span class="ident">tests</span> {
+ <span class="kw">use</span> <span class="kw">super</span>::<span class="ident">Heap</span>;
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">simple</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">h</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">1</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">2</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">8</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">4</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">2</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">4</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">8</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">None</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">None</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">simple2</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">h</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">5</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">4</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">3</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">2</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">1</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">8</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">2</span>));
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">1</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">3</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">4</span>));
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">5</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">8</span>));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">remove</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">h</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">5</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">4</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">3</span>);
+ <span class="kw">let</span> <span class="ident">two</span> <span class="op">=</span> <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">2</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">1</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">remove</span>(<span class="ident">two</span>), <span class="number">2</span>);
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="number">1</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">h</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="number">3</span>));
+ }
+
+ <span class="kw">fn</span> <span class="ident">vec2heap</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Ord</span><span class="op">></span>(<span class="ident">v</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>) <span class="op">-></span> <span class="ident">Heap</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">h</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="kw">for</span> <span class="ident">t</span> <span class="kw">in</span> <span class="ident">v</span> {
+ <span class="ident">h</span>.<span class="ident">push</span>(<span class="ident">t</span>);
+ }
+ <span class="kw">return</span> <span class="ident">h</span>
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">test_peek_and_pop</span>() {
+ <span class="kw">let</span> <span class="ident">data</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">2</span>, <span class="number">4</span>, <span class="number">6</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">10</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">7</span>, <span class="number">0</span>, <span class="number">9</span>, <span class="number">1</span>];
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sorted</span> <span class="op">=</span> <span class="ident">data</span>.<span class="ident">clone</span>();
+ <span class="ident">sorted</span>.<span class="ident">sort</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">heap</span> <span class="op">=</span> <span class="ident">vec2heap</span>(<span class="ident">data</span>);
+ <span class="kw">while</span> <span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">is_some</span>() {
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>(), <span class="ident">sorted</span>.<span class="ident">first</span>().<span class="ident">unwrap</span>());
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">heap</span>.<span class="ident">pop</span>().<span class="ident">unwrap</span>(), <span class="ident">sorted</span>.<span class="ident">remove</span>(<span class="number">0</span>));
+ }
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">test_push</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">heap</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">2</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">4</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">9</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">9</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">11</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">11</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">5</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">11</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">27</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">27</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">3</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">27</span>);
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="op">-</span><span class="number">103</span>);
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">heap</span>.<span class="ident">peek</span>().<span class="ident">unwrap</span>() <span class="op">==</span> <span class="op">-</span><span class="number">103</span>);
+ }
+
+ <span class="kw">fn</span> <span class="ident">check_to_vec</span>(<span class="kw-2">mut</span> <span class="ident">data</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">i32</span><span class="op">></span>) {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">heap</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="ident">new</span>();
+ <span class="kw">for</span> <span class="ident">data</span> <span class="kw">in</span> <span class="ident">data</span>.<span class="ident">iter</span>() {
+ <span class="ident">heap</span>.<span class="ident">push</span>(<span class="kw-2">*</span><span class="ident">data</span>);
+ }
+ <span class="ident">data</span>.<span class="ident">sort</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">new</span>();
+ <span class="kw">while</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">i</span>) <span class="op">=</span> <span class="ident">heap</span>.<span class="ident">pop</span>() {
+ <span class="ident">v</span>.<span class="ident">push</span>(<span class="ident">i</span>);
+ }
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">v</span>, <span class="ident">data</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">test_to_vec</span>() {
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">5</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">3</span>, <span class="number">2</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">2</span>, <span class="number">3</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">5</span>, <span class="number">1</span>, <span class="number">2</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">100</span>, <span class="number">2</span>, <span class="number">3</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">7</span>, <span class="number">9</span>, <span class="number">2</span>, <span class="number">4</span>, <span class="number">6</span>, <span class="number">8</span>, <span class="number">0</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">2</span>, <span class="number">4</span>, <span class="number">6</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">10</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">7</span>, <span class="number">0</span>, <span class="number">9</span>, <span class="number">1</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">9</span>, <span class="number">11</span>, <span class="number">9</span>, <span class="number">9</span>, <span class="number">9</span>, <span class="number">9</span>, <span class="number">11</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">11</span>, <span class="number">9</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">10</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">10</span>, <span class="number">9</span>, <span class="number">8</span>, <span class="number">7</span>, <span class="number">6</span>, <span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">0</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>]);
+ <span class="ident">check_to_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>]);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">test_empty_pop</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">heap</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="op"><</span><span class="ident">i32</span><span class="op">></span>::<span class="ident">new</span>();
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">heap</span>.<span class="ident">pop</span>().<span class="ident">is_none</span>());
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">test_empty_peek</span>() {
+ <span class="kw">let</span> <span class="ident">empty</span> <span class="op">=</span> <span class="ident">Heap</span>::<span class="op"><</span><span class="ident">i32</span><span class="op">></span>::<span class="ident">new</span>();
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">empty</span>.<span class="ident">peek</span>().<span class="ident">is_none</span>());
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/copy.rs.html b/src/tokio_core/io/copy.rs.html
new file mode 100644
index 0000000..9140791
--- /dev/null
+++ b/src/tokio_core/io/copy.rs.html
@@ -0,0 +1,293 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/copy.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>copy.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+<span id="66">66</span>
+<span id="67">67</span>
+<span id="68">68</span>
+<span id="69">69</span>
+<span id="70">70</span>
+<span id="71">71</span>
+<span id="72">72</span>
+<span id="73">73</span>
+<span id="74">74</span>
+<span id="75">75</span>
+<span id="76">76</span>
+<span id="77">77</span>
+<span id="78">78</span>
+<span id="79">79</span>
+<span id="80">80</span>
+<span id="81">81</span>
+<span id="82">82</span>
+<span id="83">83</span>
+<span id="84">84</span>
+<span id="85">85</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>, <span class="ident">Write</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">Poll</span>};
+
+<span class="doccomment">/// A future which will copy all data from a reader into a writer.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`copy`] function, this future will resolve to the number of</span>
+<span class="doccomment">/// bytes copied or an error if one happens.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`copy`]: fn.copy.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Copy</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">W</span><span class="op">></span> {
+ <span class="ident">reader</span>: <span class="ident">R</span>,
+ <span class="ident">read_done</span>: <span class="ident">bool</span>,
+ <span class="ident">writer</span>: <span class="ident">W</span>,
+ <span class="ident">pos</span>: <span class="ident">usize</span>,
+ <span class="ident">cap</span>: <span class="ident">usize</span>,
+ <span class="ident">amt</span>: <span class="ident">u64</span>,
+ <span class="ident">buf</span>: <span class="ident">Box</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+}
+
+<span class="doccomment">/// Creates a future which represents copying all the bytes from one object to</span>
+<span class="doccomment">/// another.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The returned future will copy all the bytes read from `reader` into the</span>
+<span class="doccomment">/// `writer` specified. This future will only complete once the `reader` has hit</span>
+<span class="doccomment">/// EOF and all bytes have been written to and flushed from the `writer`</span>
+<span class="doccomment">/// provided.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// On success the number of bytes is returned and the `reader` and `writer` are</span>
+<span class="doccomment">/// consumed. On error the error is returned and the I/O objects are consumed as</span>
+<span class="doccomment">/// well.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">copy</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">W</span><span class="op">></span>(<span class="ident">reader</span>: <span class="ident">R</span>, <span class="ident">writer</span>: <span class="ident">W</span>) <span class="op">-></span> <span class="ident">Copy</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">W</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">R</span>: <span class="ident">Read</span>,
+ <span class="ident">W</span>: <span class="ident">Write</span>,
+{
+ <span class="ident">Copy</span> {
+ <span class="ident">reader</span>: <span class="ident">reader</span>,
+ <span class="ident">read_done</span>: <span class="bool-val">false</span>,
+ <span class="ident">writer</span>: <span class="ident">writer</span>,
+ <span class="ident">amt</span>: <span class="number">0</span>,
+ <span class="ident">pos</span>: <span class="number">0</span>,
+ <span class="ident">cap</span>: <span class="number">0</span>,
+ <span class="ident">buf</span>: <span class="ident">Box</span>::<span class="ident">new</span>([<span class="number">0</span>; <span class="number">2048</span>]),
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">W</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">Copy</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">W</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">R</span>: <span class="ident">Read</span>,
+ <span class="ident">W</span>: <span class="ident">Write</span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">u64</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">u64</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">loop</span> {
+ <span class="comment">// If our buffer is empty, then we need to read some data to</span>
+ <span class="comment">// continue.</span>
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">pos</span> <span class="op">==</span> <span class="self">self</span>.<span class="ident">cap</span> <span class="op">&&</span> <span class="op">!</span><span class="self">self</span>.<span class="ident">read_done</span> {
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">reader</span>.<span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">buf</span>));
+ <span class="kw">if</span> <span class="ident">n</span> <span class="op">==</span> <span class="number">0</span> {
+ <span class="self">self</span>.<span class="ident">read_done</span> <span class="op">=</span> <span class="bool-val">true</span>;
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">pos</span> <span class="op">=</span> <span class="number">0</span>;
+ <span class="self">self</span>.<span class="ident">cap</span> <span class="op">=</span> <span class="ident">n</span>;
+ }
+ }
+
+ <span class="comment">// If our buffer has some data, let's write it out!</span>
+ <span class="kw">while</span> <span class="self">self</span>.<span class="ident">pos</span> <span class="op"><</span> <span class="self">self</span>.<span class="ident">cap</span> {
+ <span class="kw">let</span> <span class="ident">i</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">writer</span>.<span class="ident">write</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">buf</span>[<span class="self">self</span>.<span class="ident">pos</span>..<span class="self">self</span>.<span class="ident">cap</span>]));
+ <span class="self">self</span>.<span class="ident">pos</span> <span class="op">+=</span> <span class="ident">i</span>;
+ <span class="self">self</span>.<span class="ident">amt</span> <span class="op">+=</span> <span class="ident">i</span> <span class="kw">as</span> <span class="ident">u64</span>;
+ }
+
+ <span class="comment">// If we've written all the data and we've seen EOF, flush out the</span>
+ <span class="comment">// data and finish the transfer.</span>
+ <span class="comment">// done with the entire transfer.</span>
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">pos</span> <span class="op">==</span> <span class="self">self</span>.<span class="ident">cap</span> <span class="op">&&</span> <span class="self">self</span>.<span class="ident">read_done</span> {
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">writer</span>.<span class="ident">flush</span>());
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="self">self</span>.<span class="ident">amt</span>.<span class="ident">into</span>())
+ }
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/flush.rs.html b/src/tokio_core/io/flush.rs.html
new file mode 100644
index 0000000..fc47f9d
--- /dev/null
+++ b/src/tokio_core/io/flush.rs.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/flush.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>flush.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Write</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Future</span>, <span class="ident">Async</span>};
+
+<span class="doccomment">/// A future used to fully flush an I/O object.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Resolves to the underlying I/O object once the flush operation is complete.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`flush`] function.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`flush`]: fn.flush.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Flush</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> {
+ <span class="ident">a</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>,
+}
+
+<span class="doccomment">/// Creates a future which will entirely flush an I/O object and then yield the</span>
+<span class="doccomment">/// object itself.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This function will consume the object provided if an error happens, and</span>
+<span class="doccomment">/// otherwise it will repeatedly call `flush` until it sees `Ok(())`, scheduling</span>
+<span class="doccomment">/// a retry if `WouldBlock` is seen along the way.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">flush</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>(<span class="ident">a</span>: <span class="ident">A</span>) <span class="op">-></span> <span class="ident">Flush</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Write</span>,
+{
+ <span class="ident">Flush</span> {
+ <span class="ident">a</span>: <span class="prelude-val">Some</span>(<span class="ident">a</span>),
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">Flush</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Write</span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">A</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">a</span>.<span class="ident">as_mut</span>().<span class="ident">unwrap</span>().<span class="ident">flush</span>());
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="self">self</span>.<span class="ident">a</span>.<span class="ident">take</span>().<span class="ident">unwrap</span>()))
+ }
+}
+
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/frame.rs.html b/src/tokio_core/io/frame.rs.html
new file mode 100644
index 0000000..a03658e
--- /dev/null
+++ b/src/tokio_core/io/frame.rs.html
@@ -0,0 +1,1299 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/frame.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>frame.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+<span id="410">410</span>
+<span id="411">411</span>
+<span id="412">412</span>
+<span id="413">413</span>
+<span id="414">414</span>
+<span id="415">415</span>
+<span id="416">416</span>
+<span id="417">417</span>
+<span id="418">418</span>
+<span id="419">419</span>
+<span id="420">420</span>
+<span id="421">421</span>
+<span id="422">422</span>
+<span id="423">423</span>
+<span id="424">424</span>
+<span id="425">425</span>
+<span id="426">426</span>
+<span id="427">427</span>
+<span id="428">428</span>
+<span id="429">429</span>
+<span id="430">430</span>
+<span id="431">431</span>
+<span id="432">432</span>
+<span id="433">433</span>
+<span id="434">434</span>
+<span id="435">435</span>
+<span id="436">436</span>
+<span id="437">437</span>
+<span id="438">438</span>
+<span id="439">439</span>
+<span id="440">440</span>
+<span id="441">441</span>
+<span id="442">442</span>
+<span id="443">443</span>
+<span id="444">444</span>
+<span id="445">445</span>
+<span id="446">446</span>
+<span id="447">447</span>
+<span id="448">448</span>
+<span id="449">449</span>
+<span id="450">450</span>
+<span id="451">451</span>
+<span id="452">452</span>
+<span id="453">453</span>
+<span id="454">454</span>
+<span id="455">455</span>
+<span id="456">456</span>
+<span id="457">457</span>
+<span id="458">458</span>
+<span id="459">459</span>
+<span id="460">460</span>
+<span id="461">461</span>
+<span id="462">462</span>
+<span id="463">463</span>
+<span id="464">464</span>
+<span id="465">465</span>
+<span id="466">466</span>
+<span id="467">467</span>
+<span id="468">468</span>
+<span id="469">469</span>
+<span id="470">470</span>
+<span id="471">471</span>
+<span id="472">472</span>
+<span id="473">473</span>
+<span id="474">474</span>
+<span id="475">475</span>
+<span id="476">476</span>
+<span id="477">477</span>
+<span id="478">478</span>
+<span id="479">479</span>
+<span id="480">480</span>
+<span id="481">481</span>
+<span id="482">482</span>
+<span id="483">483</span>
+<span id="484">484</span>
+<span id="485">485</span>
+<span id="486">486</span>
+<span id="487">487</span>
+<span id="488">488</span>
+<span id="489">489</span>
+<span id="490">490</span>
+<span id="491">491</span>
+<span id="492">492</span>
+<span id="493">493</span>
+<span id="494">494</span>
+<span id="495">495</span>
+<span id="496">496</span>
+<span id="497">497</span>
+<span id="498">498</span>
+<span id="499">499</span>
+<span id="500">500</span>
+<span id="501">501</span>
+<span id="502">502</span>
+<span id="503">503</span>
+<span id="504">504</span>
+<span id="505">505</span>
+<span id="506">506</span>
+<span id="507">507</span>
+<span id="508">508</span>
+<span id="509">509</span>
+<span id="510">510</span>
+<span id="511">511</span>
+<span id="512">512</span>
+<span id="513">513</span>
+<span id="514">514</span>
+<span id="515">515</span>
+<span id="516">516</span>
+<span id="517">517</span>
+<span id="518">518</span>
+<span id="519">519</span>
+<span id="520">520</span>
+<span id="521">521</span>
+<span id="522">522</span>
+<span id="523">523</span>
+<span id="524">524</span>
+<span id="525">525</span>
+<span id="526">526</span>
+<span id="527">527</span>
+<span id="528">528</span>
+<span id="529">529</span>
+<span id="530">530</span>
+<span id="531">531</span>
+<span id="532">532</span>
+<span id="533">533</span>
+<span id="534">534</span>
+<span id="535">535</span>
+<span id="536">536</span>
+<span id="537">537</span>
+<span id="538">538</span>
+<span id="539">539</span>
+<span id="540">540</span>
+<span id="541">541</span>
+<span id="542">542</span>
+<span id="543">543</span>
+<span id="544">544</span>
+<span id="545">545</span>
+<span id="546">546</span>
+<span id="547">547</span>
+<span id="548">548</span>
+<span id="549">549</span>
+<span id="550">550</span>
+<span id="551">551</span>
+<span id="552">552</span>
+<span id="553">553</span>
+<span id="554">554</span>
+<span id="555">555</span>
+<span id="556">556</span>
+<span id="557">557</span>
+<span id="558">558</span>
+<span id="559">559</span>
+<span id="560">560</span>
+<span id="561">561</span>
+<span id="562">562</span>
+<span id="563">563</span>
+<span id="564">564</span>
+<span id="565">565</span>
+<span id="566">566</span>
+<span id="567">567</span>
+<span id="568">568</span>
+<span id="569">569</span>
+<span id="570">570</span>
+<span id="571">571</span>
+<span id="572">572</span>
+<span id="573">573</span>
+<span id="574">574</span>
+<span id="575">575</span>
+<span id="576">576</span>
+<span id="577">577</span>
+<span id="578">578</span>
+<span id="579">579</span>
+<span id="580">580</span>
+<span id="581">581</span>
+<span id="582">582</span>
+<span id="583">583</span>
+<span id="584">584</span>
+<span id="585">585</span>
+<span id="586">586</span>
+<span id="587">587</span>
+<span id="588">588</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">hash</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ops</span>::{<span class="ident">Deref</span>, <span class="ident">DerefMut</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Async</span>, <span class="ident">Poll</span>, <span class="ident">Stream</span>, <span class="ident">Sink</span>, <span class="ident">StartSend</span>, <span class="ident">AsyncSink</span>};
+
+<span class="kw">use</span> <span class="ident">io</span>::<span class="ident">Io</span>;
+
+<span class="kw">const</span> <span class="ident">INITIAL_CAPACITY</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">8</span> <span class="op">*</span> <span class="number">1024</span>;
+
+<span class="doccomment">/// A reference counted buffer of bytes.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// An `EasyBuf` is a representation of a byte buffer where sub-slices of it can</span>
+<span class="doccomment">/// be handed out efficiently, each with a `'static` lifetime which keeps the</span>
+<span class="doccomment">/// data alive. The buffer also supports mutation but may require bytes to be</span>
+<span class="doccomment">/// copied to complete the operation.</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">Eq</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">EasyBuf</span> {
+ <span class="ident">buf</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">>></span>,
+ <span class="ident">start</span>: <span class="ident">usize</span>,
+ <span class="ident">end</span>: <span class="ident">usize</span>,
+}
+
+<span class="doccomment">/// An RAII object returned from `get_mut` which provides mutable access to the</span>
+<span class="doccomment">/// underlying `Vec<u8>`.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">EasyBufMut</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> {
+ <span class="ident">buf</span>: <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="kw-2">mut</span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+ <span class="ident">end</span>: <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="kw-2">mut</span> <span class="ident">usize</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">EasyBuf</span> {
+ <span class="doccomment">/// Creates a new EasyBuf with no data and the default capacity.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">EasyBuf</span> {
+ <span class="ident">EasyBuf</span>::<span class="ident">with_capacity</span>(<span class="ident">INITIAL_CAPACITY</span>)
+ }
+
+ <span class="doccomment">/// Creates a new EasyBuf with `cap` capacity.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">with_capacity</span>(<span class="ident">cap</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">EasyBuf</span> {
+ <span class="ident">EasyBuf</span> {
+ <span class="ident">buf</span>: <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="ident">cap</span>)),
+ <span class="ident">start</span>: <span class="number">0</span>,
+ <span class="ident">end</span>: <span class="number">0</span>,
+ }
+ }
+
+ <span class="doccomment">/// Changes the starting index of this window to the index specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Returns the windows back to chain multiple calls to this method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if `start` is out of bounds for the underlying</span>
+ <span class="doccomment">/// slice or if it comes after the `end` configured in this window.</span>
+ <span class="kw">fn</span> <span class="ident">set_start</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">start</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">EasyBuf</span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">start</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>());
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">start</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">end</span>);
+ <span class="self">self</span>.<span class="ident">start</span> <span class="op">=</span> <span class="ident">start</span>;
+ <span class="self">self</span>
+ }
+
+ <span class="doccomment">/// Changes the end index of this window to the index specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Returns the windows back to chain multiple calls to this method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if `end` is out of bounds for the underlying</span>
+ <span class="doccomment">/// slice or if it comes after the `end` configured in this window.</span>
+ <span class="kw">fn</span> <span class="ident">set_end</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">end</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">EasyBuf</span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">end</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">len</span>());
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">start</span> <span class="op"><=</span> <span class="ident">end</span>);
+ <span class="self">self</span>.<span class="ident">end</span> <span class="op">=</span> <span class="ident">end</span>;
+ <span class="self">self</span>
+ }
+
+ <span class="doccomment">/// Returns the number of bytes contained in this `EasyBuf`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">len</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="self">self</span>.<span class="ident">end</span> <span class="op">-</span> <span class="self">self</span>.<span class="ident">start</span>
+ }
+
+ <span class="doccomment">/// Returns the inner contents of this `EasyBuf` as a slice.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">as_slice</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span>[<span class="ident">u8</span>] {
+ <span class="self">self</span>.<span class="ident">as_ref</span>()
+ }
+
+ <span class="doccomment">/// Splits the buffer into two at the given index.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Afterwards `self` contains elements `[0, at)`, and the returned `EasyBuf`</span>
+ <span class="doccomment">/// contains elements `[at, len)`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This is an O(1) operation that just increases the reference count and</span>
+ <span class="doccomment">/// sets a few indexes.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Panics if `at > len`</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">split_off</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">at</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">EasyBuf</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">other</span> <span class="op">=</span> <span class="ident">EasyBuf</span> { <span class="ident">buf</span>: <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">clone</span>(), ..<span class="kw-2">*</span><span class="self">self</span> };
+ <span class="kw">let</span> <span class="ident">idx</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">start</span> <span class="op">+</span> <span class="ident">at</span>;
+ <span class="ident">other</span>.<span class="ident">set_start</span>(<span class="ident">idx</span>);
+ <span class="self">self</span>.<span class="ident">set_end</span>(<span class="ident">idx</span>);
+ <span class="kw">return</span> <span class="ident">other</span>
+ }
+
+ <span class="doccomment">/// Splits the buffer into two at the given index.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Afterwards `self` contains elements `[at, len)`, and the returned `EasyBuf`</span>
+ <span class="doccomment">/// contains elements `[0, at)`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This is an O(1) operation that just increases the reference count and</span>
+ <span class="doccomment">/// sets a few indexes.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Panics if `at > len`</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">drain_to</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">at</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">EasyBuf</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">other</span> <span class="op">=</span> <span class="ident">EasyBuf</span> { <span class="ident">buf</span>: <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">clone</span>(), ..<span class="kw-2">*</span><span class="self">self</span> };
+ <span class="kw">let</span> <span class="ident">idx</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">start</span> <span class="op">+</span> <span class="ident">at</span>;
+ <span class="ident">other</span>.<span class="ident">set_end</span>(<span class="ident">idx</span>);
+ <span class="self">self</span>.<span class="ident">set_start</span>(<span class="ident">idx</span>);
+ <span class="kw">return</span> <span class="ident">other</span>
+ }
+
+ <span class="doccomment">/// Returns a mutable reference to the underlying growable buffer of bytes.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this `EasyBuf` is the only instance pointing at the underlying buffer</span>
+ <span class="doccomment">/// of bytes, a direct mutable reference will be returned. Otherwise the</span>
+ <span class="doccomment">/// contents of this `EasyBuf` will be reallocated in a fresh `Vec<u8>`</span>
+ <span class="doccomment">/// allocation with the same capacity as an `EasyBuf` created with `EasyBuf::new()`,</span>
+ <span class="doccomment">/// and that allocation will be returned.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This operation **is not O(1)** as it may clone the entire contents of</span>
+ <span class="doccomment">/// this buffer.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The returned `EasyBufMut` type implement `Deref` and `DerefMut` to</span>
+ <span class="doccomment">/// `Vec<u8>` can the byte buffer can be manipulated using the standard</span>
+ <span class="doccomment">/// `Vec<u8>` methods.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">EasyBufMut</span> {
+ <span class="comment">// Fast path if we can get mutable access to our own current</span>
+ <span class="comment">// buffer.</span>
+ <span class="comment">//</span>
+ <span class="comment">// TODO: this should be a match or an if-let</span>
+ <span class="kw">if</span> <span class="ident">Arc</span>::<span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">buf</span>).<span class="ident">is_some</span>() {
+ <span class="kw">let</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">buf</span>).<span class="ident">unwrap</span>();
+ <span class="ident">buf</span>.<span class="ident">drain</span>(<span class="self">self</span>.<span class="ident">end</span>..);
+ <span class="ident">buf</span>.<span class="ident">drain</span>(..<span class="self">self</span>.<span class="ident">start</span>);
+ <span class="self">self</span>.<span class="ident">start</span> <span class="op">=</span> <span class="number">0</span>;
+ <span class="kw">return</span> <span class="ident">EasyBufMut</span> { <span class="ident">buf</span>: <span class="ident">buf</span>, <span class="ident">end</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">end</span> }
+ }
+
+ <span class="comment">// If we couldn't get access above then we give ourself a new buffer</span>
+ <span class="comment">// here.</span>
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="ident">cmp</span>::<span class="ident">max</span>(<span class="ident">INITIAL_CAPACITY</span>, <span class="self">self</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>()));
+ <span class="ident">v</span>.<span class="ident">extend_from_slice</span>(<span class="self">self</span>.<span class="ident">as_ref</span>());
+ <span class="self">self</span>.<span class="ident">start</span> <span class="op">=</span> <span class="number">0</span>;
+ <span class="self">self</span>.<span class="ident">buf</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">v</span>);
+ <span class="ident">EasyBufMut</span> {
+ <span class="ident">buf</span>: <span class="ident">Arc</span>::<span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">buf</span>).<span class="ident">unwrap</span>(),
+ <span class="ident">end</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">end</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">as_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span>[<span class="ident">u8</span>] {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">buf</span>[<span class="self">self</span>.<span class="ident">start</span>..<span class="self">self</span>.<span class="ident">end</span>]
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">Deref</span> <span class="kw">for</span> <span class="ident">EasyBufMut</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> {
+ <span class="kw">type</span> <span class="ident">Target</span> <span class="op">=</span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>;
+
+ <span class="kw">fn</span> <span class="ident">deref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">buf</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">DerefMut</span> <span class="kw">for</span> <span class="ident">EasyBufMut</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">deref_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">buf</span>
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">From</span><span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">>></span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>) <span class="op">-></span> <span class="ident">EasyBuf</span> {
+ <span class="kw">let</span> <span class="ident">end</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">len</span>();
+ <span class="ident">EasyBuf</span> {
+ <span class="ident">buf</span>: <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">vec</span>),
+ <span class="ident">start</span>: <span class="number">0</span>,
+ <span class="ident">end</span>: <span class="ident">end</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">>></span> <span class="ident">PartialEq</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">eq</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&</span><span class="ident">T</span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="self">self</span>.<span class="ident">as_slice</span>().<span class="ident">eq</span>(<span class="ident">other</span>.<span class="ident">as_ref</span>())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Ord</span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">cmp</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&</span><span class="self">Self</span>) <span class="op">-></span> <span class="ident">cmp</span>::<span class="ident">Ordering</span> {
+ <span class="self">self</span>.<span class="ident">as_slice</span>().<span class="ident">cmp</span>(<span class="ident">other</span>.<span class="ident">as_slice</span>())
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">>></span> <span class="ident">PartialOrd</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">partial_cmp</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&</span><span class="ident">T</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">cmp</span>::<span class="ident">Ordering</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">as_slice</span>().<span class="ident">partial_cmp</span>(<span class="ident">other</span>.<span class="ident">as_ref</span>())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">hash</span>::<span class="ident">Hash</span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">hash</span><span class="op"><</span><span class="ident">H</span>: <span class="ident">hash</span>::<span class="ident">Hasher</span><span class="op">></span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">state</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">H</span>) {
+ <span class="self">self</span>.<span class="ident">as_slice</span>().<span class="ident">hash</span>(<span class="ident">state</span>)
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">Drop</span> <span class="kw">for</span> <span class="ident">EasyBufMut</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">drop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) {
+ <span class="kw-2">*</span><span class="self">self</span>.<span class="ident">end</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">len</span>();
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">formatter</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">as_ref</span>();
+ <span class="kw">let</span> <span class="ident">len</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">len</span>();
+ <span class="kw">if</span> <span class="ident">len</span> <span class="op"><</span> <span class="number">10</span> {
+ <span class="macro">write</span><span class="macro">!</span>(<span class="ident">formatter</span>, <span class="string">"EasyBuf{{len={}/{} {:?}}}"</span>, <span class="self">self</span>.<span class="ident">len</span>(), <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">len</span>(), <span class="ident">bytes</span>)
+ } <span class="kw">else</span> { <span class="comment">// choose a more compact representation</span>
+ <span class="macro">write</span><span class="macro">!</span>(<span class="ident">formatter</span>, <span class="string">"EasyBuf{{len={}/{} [{}, {}, {}, {}, ..., {}, {}, {}, {}]}}"</span>, <span class="self">self</span>.<span class="ident">len</span>(), <span class="self">self</span>.<span class="ident">buf</span>.<span class="ident">len</span>(), <span class="ident">bytes</span>[<span class="number">0</span>], <span class="ident">bytes</span>[<span class="number">1</span>], <span class="ident">bytes</span>[<span class="number">2</span>], <span class="ident">bytes</span>[<span class="number">3</span>], <span class="ident">bytes</span>[<span class="ident">len</span><span class="op">-</span><span class="number">4</span>], <span class="ident">bytes</span>[<span class="ident">len</span><span class="op">-</span><span class="number">3</span>], <span class="ident">bytes</span>[<span class="ident">len</span><span class="op">-</span><span class="number">2</span>], <span class="ident">bytes</span>[<span class="ident">len</span><span class="op">-</span><span class="number">1</span>])
+ }
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Into</span><span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">>></span> <span class="kw">for</span> <span class="ident">EasyBuf</span> {
+ <span class="kw">fn</span> <span class="ident">into</span>(<span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> {
+ <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="self">self</span>.<span class="ident">get_mut</span>().<span class="ident">buf</span>, <span class="macro">vec</span><span class="macro">!</span>[])
+ }
+}
+
+<span class="doccomment">/// Encoding and decoding of frames via buffers.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This trait is used when constructing an instance of `Framed`. It provides</span>
+<span class="doccomment">/// two types: `In`, for decoded input frames, and `Out`, for outgoing frames</span>
+<span class="doccomment">/// that need to be encoded. It also provides methods to actually perform the</span>
+<span class="doccomment">/// encoding and decoding, which work with corresponding buffer types.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The trait itself is implemented on a type that can track state for decoding</span>
+<span class="doccomment">/// or encoding, which is particularly useful for streaming parsers. In many</span>
+<span class="doccomment">/// cases, though, this type will simply be a unit struct (e.g. `struct</span>
+<span class="doccomment">/// HttpCodec`).</span>
+<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">Codec</span> {
+ <span class="doccomment">/// The type of decoded frames.</span>
+ <span class="kw">type</span> <span class="ident">In</span>;
+
+ <span class="doccomment">/// The type of frames to be encoded.</span>
+ <span class="kw">type</span> <span class="ident">Out</span>;
+
+ <span class="doccomment">/// Attempts to decode a frame from the provided buffer of bytes.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method is called by `Framed` whenever bytes are ready to be parsed.</span>
+ <span class="doccomment">/// The provided buffer of bytes is what's been read so far, and this</span>
+ <span class="doccomment">/// instance of `Decode` can determine whether an entire frame is in the</span>
+ <span class="doccomment">/// buffer and is ready to be returned.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If an entire frame is available, then this instance will remove those</span>
+ <span class="doccomment">/// bytes from the buffer provided and return them as a decoded</span>
+ <span class="doccomment">/// frame. Note that removing bytes from the provided buffer doesn't always</span>
+ <span class="doccomment">/// necessarily copy the bytes, so this should be an efficient operation in</span>
+ <span class="doccomment">/// most circumstances.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If the bytes look valid, but a frame isn't fully available yet, then</span>
+ <span class="doccomment">/// `Ok(None)` is returned. This indicates to the `Framed` instance that</span>
+ <span class="doccomment">/// it needs to read some more bytes before calling this method again.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Finally, if the bytes in the buffer are malformed then an error is</span>
+ <span class="doccomment">/// returned indicating why. This informs `Framed` that the stream is now</span>
+ <span class="doccomment">/// corrupt and should be terminated.</span>
+ <span class="kw">fn</span> <span class="ident">decode</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">EasyBuf</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">In</span><span class="op">>></span>;
+
+ <span class="doccomment">/// A default method available to be called when there are no more bytes</span>
+ <span class="doccomment">/// available to be read from the underlying I/O.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method defaults to calling `decode` and returns an error if</span>
+ <span class="doccomment">/// `Ok(None)` is returned. Typically this doesn't need to be implemented</span>
+ <span class="doccomment">/// unless the framing protocol differs near the end of the stream.</span>
+ <span class="kw">fn</span> <span class="ident">decode_eof</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">EasyBuf</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">In</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">decode</span>(<span class="ident">buf</span>)) {
+ <span class="prelude-val">Some</span>(<span class="ident">frame</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">frame</span>),
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">Other</span>,
+ <span class="string">"bytes remaining on stream"</span>)),
+ }
+ }
+
+ <span class="doccomment">/// Encodes a frame into the buffer provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will encode `msg` into the byte buffer provided by `buf`.</span>
+ <span class="doccomment">/// The `buf` provided is an internal buffer of the `Framed` instance and</span>
+ <span class="doccomment">/// will be written out when possible.</span>
+ <span class="kw">fn</span> <span class="ident">encode</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">msg</span>: <span class="self">Self</span>::<span class="ident">Out</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span>;
+}
+
+<span class="doccomment">/// A unified `Stream` and `Sink` interface to an underlying `Io` object, using</span>
+<span class="doccomment">/// the `Codec` trait to encode and decode frames.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// You can acquire a `Framed` instance by using the `Io::framed` adapter.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"streams do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> {
+ <span class="ident">upstream</span>: <span class="ident">T</span>,
+ <span class="ident">codec</span>: <span class="ident">C</span>,
+ <span class="ident">eof</span>: <span class="ident">bool</span>,
+ <span class="ident">is_readable</span>: <span class="ident">bool</span>,
+ <span class="ident">rd</span>: <span class="ident">EasyBuf</span>,
+ <span class="ident">wr</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Io</span>, <span class="ident">C</span>: <span class="ident">Codec</span><span class="op">></span> <span class="ident">Stream</span> <span class="kw">for</span> <span class="ident">Framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">C</span>::<span class="ident">In</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">C</span>::<span class="ident">In</span><span class="op">></span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">loop</span> {
+ <span class="comment">// If the read buffer has any pending data, then it could be</span>
+ <span class="comment">// possible that `decode` will return a new frame. We leave it to</span>
+ <span class="comment">// the decoder to optimize detecting that more data is required.</span>
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">is_readable</span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">eof</span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">rd</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="number">0</span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="prelude-val">None</span>.<span class="ident">into</span>())
+ } <span class="kw">else</span> {
+ <span class="kw">let</span> <span class="ident">frame</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">codec</span>.<span class="ident">decode_eof</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">rd</span>));
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(<span class="ident">frame</span>)))
+ }
+ }
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"attempting to decode a frame"</span>);
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">frame</span>) <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">codec</span>.<span class="ident">decode</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">rd</span>)) {
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"frame decoded from buffer"</span>);
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(<span class="ident">frame</span>)));
+ }
+ <span class="self">self</span>.<span class="ident">is_readable</span> <span class="op">=</span> <span class="bool-val">false</span>;
+ }
+
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="self">self</span>.<span class="ident">eof</span>);
+
+ <span class="comment">// Otherwise, try to read more data and try again</span>
+ <span class="comment">//</span>
+ <span class="comment">// TODO: shouldn't read_to_end, that may read a lot</span>
+ <span class="kw">let</span> <span class="ident">before</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">rd</span>.<span class="ident">len</span>();
+ <span class="kw">let</span> <span class="ident">ret</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">upstream</span>.<span class="ident">read_to_end</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">rd</span>.<span class="ident">get_mut</span>());
+ <span class="kw">match</span> <span class="ident">ret</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">_n</span>) <span class="op">=></span> <span class="self">self</span>.<span class="ident">eof</span> <span class="op">=</span> <span class="bool-val">true</span>,
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> <span class="op">=></span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">rd</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="ident">before</span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>),
+ }
+ <span class="self">self</span>.<span class="ident">is_readable</span> <span class="op">=</span> <span class="bool-val">true</span>;
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Io</span>, <span class="ident">C</span>: <span class="ident">Codec</span><span class="op">></span> <span class="ident">Sink</span> <span class="kw">for</span> <span class="ident">Framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> {
+ <span class="kw">type</span> <span class="ident">SinkItem</span> <span class="op">=</span> <span class="ident">C</span>::<span class="ident">Out</span>;
+ <span class="kw">type</span> <span class="ident">SinkError</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">start_send</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">item</span>: <span class="ident">C</span>::<span class="ident">Out</span>) <span class="op">-></span> <span class="ident">StartSend</span><span class="op"><</span><span class="ident">C</span>::<span class="ident">Out</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="comment">// If the buffer is already over 8KiB, then attempt to flush it. If after flushing it's</span>
+ <span class="comment">// *still* over 8KiB, then apply backpressure (reject the send).</span>
+ <span class="kw">const</span> <span class="ident">BACKPRESSURE_BOUNDARY</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="ident">INITIAL_CAPACITY</span>;
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>() <span class="op">></span> <span class="ident">BACKPRESSURE_BOUNDARY</span> {
+ <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">poll_complete</span>());
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>() <span class="op">></span> <span class="ident">BACKPRESSURE_BOUNDARY</span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">AsyncSink</span>::<span class="ident">NotReady</span>(<span class="ident">item</span>));
+ }
+ }
+
+ <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">codec</span>.<span class="ident">encode</span>(<span class="ident">item</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">wr</span>));
+ <span class="prelude-val">Ok</span>(<span class="ident">AsyncSink</span>::<span class="ident">Ready</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_complete</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"flushing framed transport"</span>);
+
+ <span class="kw">while</span> <span class="op">!</span><span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">is_empty</span>() {
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"writing; remaining={}"</span>, <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>());
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">upstream</span>.<span class="ident">write</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">wr</span>));
+ <span class="kw">if</span> <span class="ident">n</span> <span class="op">==</span> <span class="number">0</span> {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WriteZero</span>,
+ <span class="string">"failed to write frame to transport"</span>));
+ }
+ <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">drain</span>(..<span class="ident">n</span>);
+ }
+
+ <span class="comment">// Try flushing the underlying IO</span>
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">upstream</span>.<span class="ident">flush</span>());
+
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"framed transport flushed"</span>);
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(()));
+ }
+
+ <span class="kw">fn</span> <span class="ident">close</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="macro">try_ready</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">poll_complete</span>());
+ <span class="prelude-val">Ok</span>(().<span class="ident">into</span>())
+ }
+}
+
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span>(<span class="ident">io</span>: <span class="ident">T</span>, <span class="ident">codec</span>: <span class="ident">C</span>) <span class="op">-></span> <span class="ident">Framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> {
+ <span class="ident">Framed</span> {
+ <span class="ident">upstream</span>: <span class="ident">io</span>,
+ <span class="ident">codec</span>: <span class="ident">codec</span>,
+ <span class="ident">eof</span>: <span class="bool-val">false</span>,
+ <span class="ident">is_readable</span>: <span class="bool-val">false</span>,
+ <span class="ident">rd</span>: <span class="ident">EasyBuf</span>::<span class="ident">new</span>(),
+ <span class="ident">wr</span>: <span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="ident">INITIAL_CAPACITY</span>),
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> <span class="ident">Framed</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">C</span><span class="op">></span> {
+
+ <span class="doccomment">/// Returns a reference to the underlying I/O stream wrapped by `Framed`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">T</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">upstream</span>
+ }
+
+ <span class="doccomment">/// Returns a mutable reference to the underlying I/O stream wrapped by</span>
+ <span class="doccomment">/// `Framed`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">T</span> {
+ <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">upstream</span>
+ }
+
+ <span class="doccomment">/// Consumes the `Framed`, returning its underlying I/O stream.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">into_inner</span>(<span class="self">self</span>) <span class="op">-></span> <span class="ident">T</span> {
+ <span class="self">self</span>.<span class="ident">upstream</span>
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">test</span>)]</span>
+<span class="kw">mod</span> <span class="ident">tests</span> {
+ <span class="kw">use</span> <span class="kw">super</span>::{<span class="ident">INITIAL_CAPACITY</span>, <span class="ident">EasyBuf</span>};
+ <span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">debug_empty_easybuf</span>() {
+ <span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[].<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">"EasyBuf{len=0/0 []}"</span>, <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">buf</span>));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">debug_small_easybuf</span>() {
+ <span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>].<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">"EasyBuf{len=6/6 [1, 2, 3, 4, 5, 6]}"</span>, <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">buf</span>));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">debug_small_easybuf_split</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>].<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">split</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">4</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">"EasyBuf{len=4/6 [1, 2, 3, 4]}"</span>, <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">buf</span>));
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">"EasyBuf{len=2/6 [5, 6]}"</span>, <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">split</span>));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">debug_large_easybuf</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">255u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">"EasyBuf{len=255/255 [0, 1, 2, 3, ..., 251, 252, 253, 254]}"</span>, <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">buf</span>));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_get_mut_sliced</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">9</span>);
+ <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">3</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">buf</span>.<span class="ident">get_mut</span>(), [<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>]);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_get_mut_sliced_allocating_at_least_initial_capacity</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">9</span>);
+ <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">3</span>);
+ <span class="comment">// Clone to make shared</span>
+ <span class="kw">let</span> <span class="ident">clone</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">clone</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">buf</span>.<span class="ident">get_mut</span>(), [<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>]);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">get_mut</span>().<span class="ident">buf</span>.<span class="ident">capacity</span>(), <span class="ident">INITIAL_CAPACITY</span>);
+ <span class="ident">mem</span>::<span class="ident">drop</span>(<span class="ident">clone</span>); <span class="comment">// prevent unused warning</span>
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_get_mut_sliced_allocating_required_capacity</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0</span>..<span class="ident">INITIAL_CAPACITY</span> <span class="op">*</span> <span class="number">2</span>).<span class="ident">map</span>(<span class="op">|</span>_<span class="op">|</span><span class="number">0u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="ident">INITIAL_CAPACITY</span> <span class="op">/</span> <span class="number">2</span>);
+ <span class="kw">let</span> <span class="ident">clone</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">clone</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">get_mut</span>().<span class="ident">buf</span>.<span class="ident">capacity</span>(), <span class="ident">INITIAL_CAPACITY</span> <span class="op">+</span> <span class="ident">INITIAL_CAPACITY</span> <span class="op">/</span> <span class="number">2</span>);
+ <span class="ident">mem</span>::<span class="ident">drop</span>(<span class="ident">clone</span>)
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_into_vec_simple</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="ident">reference</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">clone</span>();
+ <span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">original_pointer</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">buf</span>.<span class="ident">as_ref</span>().<span class="ident">as_ptr</span>();
+ <span class="kw">let</span> <span class="ident">result</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="ident">reference</span>);
+ <span class="kw">let</span> <span class="ident">new_pointer</span> <span class="op">=</span> <span class="ident">result</span>.<span class="ident">as_ptr</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">original_pointer</span>, <span class="ident">new_pointer</span>, <span class="string">"Into<Vec<u8>> should reuse the exclusive Vec"</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_into_vec_sliced</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">original_pointer</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">buf</span>.<span class="ident">as_ref</span>().<span class="ident">as_ptr</span>();
+ <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">9</span>);
+ <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">3</span>);
+ <span class="kw">let</span> <span class="ident">result</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">reference</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">3u8</span>..<span class="number">9u8</span>).<span class="ident">collect</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="ident">reference</span>);
+ <span class="kw">let</span> <span class="ident">new_pointer</span> <span class="op">=</span> <span class="ident">result</span>.<span class="ident">as_ptr</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">original_pointer</span>, <span class="ident">new_pointer</span>, <span class="string">"Into<Vec<u8>> should reuse the exclusive Vec"</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_into_vec_sliced_allocating</span>() {
+ <span class="kw">let</span> <span class="ident">vec</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> <span class="ident">vec</span>.<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">original_pointer</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">buf</span>.<span class="ident">as_ref</span>().<span class="ident">as_ptr</span>();
+ <span class="comment">// Create a clone to create second reference to this EasyBuf and force allocation</span>
+ <span class="kw">let</span> <span class="ident">original</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">clone</span>();
+ <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">9</span>);
+ <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">3</span>);
+ <span class="kw">let</span> <span class="ident">result</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="ident">reference</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> (<span class="number">3u8</span>..<span class="number">9u8</span>).<span class="ident">collect</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="ident">reference</span>);
+ <span class="kw">let</span> <span class="ident">original_reference</span>: <span class="ident">EasyBuf</span> <span class="op">=</span>(<span class="number">0u8</span>..<span class="number">10u8</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">>></span>().<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">original</span>.<span class="ident">as_ref</span>(), <span class="ident">original_reference</span>.<span class="ident">as_ref</span>());
+ <span class="kw">let</span> <span class="ident">new_pointer</span> <span class="op">=</span> <span class="ident">result</span>.<span class="ident">as_ptr</span>();
+ <span class="macro">assert_ne</span><span class="macro">!</span>(<span class="ident">original_pointer</span>, <span class="ident">new_pointer</span>, <span class="string">"A new vec should be allocated"</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_equality_same_underlying_vec</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span>_<span class="op">>></span>().<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">buf</span>);
+ <span class="kw">let</span> <span class="ident">other</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">5</span>);
+ <span class="macro">assert_ne</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">other</span>);
+
+ <span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">5</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span>_<span class="op">>></span>().<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">other</span>);
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">easybuf_equality_different_underlying_vec</span>() {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span>_<span class="op">>></span>().<span class="ident">into</span>();
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">other</span>: <span class="ident">EasyBuf</span> <span class="op">=</span> (<span class="number">0u8</span>..<span class="number">10</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span>_<span class="op">>></span>().<span class="ident">into</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">other</span>);
+
+ <span class="ident">buf</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">drain_to</span>(<span class="number">5</span>);
+ <span class="macro">assert_ne</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">other</span>);
+
+ <span class="ident">other</span> <span class="op">=</span> <span class="ident">other</span>.<span class="ident">drain_to</span>(<span class="number">5</span>);
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="ident">other</span>);
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/mod.rs.html b/src/tokio_core/io/mod.rs.html
new file mode 100644
index 0000000..b389c86
--- /dev/null
+++ b/src/tokio_core/io/mod.rs.html
@@ -0,0 +1,633 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/mod.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>mod.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! I/O conveniences when working with primitives in `tokio-core`</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! Contains various combinators to work with I/O objects and type definitions</span>
+<span class="doccomment">//! as well.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! A description of the high-level I/O combinators can be [found online] in</span>
+<span class="doccomment">//! addition to a description of the [low level details].</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! [found online]: https://tokio.rs/docs/getting-started/core/</span>
+<span class="doccomment">//! [low level details]: https://tokio.rs/docs/going-deeper-tokio/core-low-level/</span>
+
+<span class="attribute">#![<span class="ident">deprecated</span>(<span class="ident">note</span> <span class="op">=</span> <span class="string">"moved to the `tokio-io` crate"</span>)]</span>
+<span class="attribute">#![<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Async</span>, <span class="ident">Poll</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">future</span>::<span class="ident">BoxFuture</span>;
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">stream</span>::<span class="ident">BoxStream</span>;
+<span class="kw">use</span> <span class="ident">iovec</span>::<span class="ident">IoVec</span>;
+
+<span class="doccomment">/// A convenience typedef around a `Future` whose error component is `io::Error`</span>
+<span class="kw">pub</span> <span class="kw">type</span> <span class="ident">IoFuture</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="op">=</span> <span class="ident">BoxFuture</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span>;
+
+<span class="doccomment">/// A convenience typedef around a `Stream` whose error component is `io::Error`</span>
+<span class="kw">pub</span> <span class="kw">type</span> <span class="ident">IoStream</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="op">=</span> <span class="ident">BoxStream</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span>;
+
+<span class="doccomment">/// A convenience macro for working with `io::Result<T>` from the `Read` and</span>
+<span class="doccomment">/// `Write` traits.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This macro takes `io::Result<T>` as input, and returns `T` as the output. If</span>
+<span class="doccomment">/// the input type is of the `Err` variant, then `Poll::NotReady` is returned if</span>
+<span class="doccomment">/// it indicates `WouldBlock` or otherwise `Err` is returned.</span>
+<span class="attribute">#[<span class="ident">macro_export</span>]</span>
+<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">try_nb</span> {
+ (<span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>) <span class="op">=></span> (<span class="kw">match</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">t</span>) <span class="op">=></span> <span class="ident">t</span>,
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> ::<span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> <span class="op">=></span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(::<span class="ident">futures</span>::<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>()),
+ })
+}
+
+<span class="kw">mod</span> <span class="ident">copy</span>;
+<span class="kw">mod</span> <span class="ident">frame</span>;
+<span class="kw">mod</span> <span class="ident">flush</span>;
+<span class="kw">mod</span> <span class="ident">read_exact</span>;
+<span class="kw">mod</span> <span class="ident">read_to_end</span>;
+<span class="kw">mod</span> <span class="ident">read</span>;
+<span class="kw">mod</span> <span class="ident">read_until</span>;
+<span class="kw">mod</span> <span class="ident">split</span>;
+<span class="kw">mod</span> <span class="ident">window</span>;
+<span class="kw">mod</span> <span class="ident">write_all</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">copy</span>::{<span class="ident">copy</span>, <span class="ident">Copy</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">frame</span>::{<span class="ident">EasyBuf</span>, <span class="ident">EasyBufMut</span>, <span class="ident">Framed</span>, <span class="ident">Codec</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">flush</span>::{<span class="ident">flush</span>, <span class="ident">Flush</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">read_exact</span>::{<span class="ident">read_exact</span>, <span class="ident">ReadExact</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">read_to_end</span>::{<span class="ident">read_to_end</span>, <span class="ident">ReadToEnd</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">read</span>::{<span class="ident">read</span>, <span class="ident">Read</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">read_until</span>::{<span class="ident">read_until</span>, <span class="ident">ReadUntil</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">split</span>::{<span class="ident">ReadHalf</span>, <span class="ident">WriteHalf</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">window</span>::<span class="ident">Window</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">write_all</span>::{<span class="ident">write_all</span>, <span class="ident">WriteAll</span>};
+
+<span class="doccomment">/// A trait for read/write I/O objects</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This trait represents I/O objects which are readable and writable.</span>
+<span class="doccomment">/// Additionally, they're associated with the ability to test whether they're</span>
+<span class="doccomment">/// readable or writable.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Importantly, the methods of this trait are intended to be used in conjunction</span>
+<span class="doccomment">/// with the current task of a future. Namely whenever any of them return a</span>
+<span class="doccomment">/// value that indicates "would block" the current future's task is arranged to</span>
+<span class="doccomment">/// receive a notification when the method would otherwise not indicate that it</span>
+<span class="doccomment">/// would block.</span>
+<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">Io</span>: <span class="ident">io</span>::<span class="ident">Read</span> <span class="op">+</span> <span class="ident">io</span>::<span class="ident">Write</span> {
+ <span class="doccomment">/// Tests to see if this I/O object may be readable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method returns an `Async<()>` indicating whether the object</span>
+ <span class="doccomment">/// **might** be readable. It is possible that even if this method returns</span>
+ <span class="doccomment">/// `Async::Ready` that a call to `read` would return a `WouldBlock` error.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// There is a default implementation for this function which always</span>
+ <span class="doccomment">/// indicates that an I/O object is readable, but objects which can</span>
+ <span class="doccomment">/// implement a finer grained version of this are recommended to do so.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this function returns `Async::NotReady` then the current future's</span>
+ <span class="doccomment">/// task is arranged to receive a notification when it might not return</span>
+ <span class="doccomment">/// `NotReady`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method is likely to panic if called from outside the context of a</span>
+ <span class="doccomment">/// future's task.</span>
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(())
+ }
+
+ <span class="doccomment">/// Tests to see if this I/O object may be writable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method returns an `Async<()>` indicating whether the object</span>
+ <span class="doccomment">/// **might** be writable. It is possible that even if this method returns</span>
+ <span class="doccomment">/// `Async::Ready` that a call to `write` would return a `WouldBlock` error.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// There is a default implementation for this function which always</span>
+ <span class="doccomment">/// indicates that an I/O object is writable, but objects which can</span>
+ <span class="doccomment">/// implement a finer grained version of this are recommended to do so.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this function returns `Async::NotReady` then the current future's</span>
+ <span class="doccomment">/// task is arranged to receive a notification when it might not return</span>
+ <span class="doccomment">/// `NotReady`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method is likely to panic if called from outside the context of a</span>
+ <span class="doccomment">/// future's task.</span>
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(())
+ }
+
+ <span class="doccomment">/// Read in a list of buffers all at once.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This operation will attempt to read bytes from this socket and place</span>
+ <span class="doccomment">/// them into the list of buffers provided. Note that each buffer is an</span>
+ <span class="doccomment">/// `IoVec` which can be created from a byte slice.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The buffers provided will be filled in sequentially. A buffer will be</span>
+ <span class="doccomment">/// entirely filled up before the next is written to.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The number of bytes read is returned, if successful, or an error is</span>
+ <span class="doccomment">/// returned otherwise. If no bytes are available to be read yet then</span>
+ <span class="doccomment">/// a "would block" error is returned. This operation should not block.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// There is a default implementation for this function which treats this</span>
+ <span class="doccomment">/// as a single read using the first buffer in the list, but objects which</span>
+ <span class="doccomment">/// can implement this as an atomic read using all the buffers are</span>
+ <span class="doccomment">/// recommended to do so. For example, `TcpStream` can implement this</span>
+ <span class="doccomment">/// using the `readv` syscall.</span>
+ <span class="kw">fn</span> <span class="ident">read_vec</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">bufs</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">IoVec</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="ident">bufs</span>.<span class="ident">is_empty</span>() {
+ <span class="prelude-val">Ok</span>(<span class="number">0</span>)
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">bufs</span>[<span class="number">0</span>])
+ }
+ }
+
+ <span class="doccomment">/// Write a list of buffers all at once.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This operation will attempt to write a list of byte buffers to this</span>
+ <span class="doccomment">/// socket. Note that each buffer is an `IoVec` which can be created from a</span>
+ <span class="doccomment">/// byte slice.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The buffers provided will be written sequentially. A buffer will be</span>
+ <span class="doccomment">/// entirely written before the next is written.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The number of bytes written is returned, if successful, or an error is</span>
+ <span class="doccomment">/// returned otherwise. If the socket is not currently writable then a</span>
+ <span class="doccomment">/// "would block" error is returned. This operation should not block.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// There is a default implementation for this function which writes the</span>
+ <span class="doccomment">/// first buffer only, but objects which can implement this as an atomic</span>
+ <span class="doccomment">/// write using all the buffers are recommended to do so. For example,</span>
+ <span class="doccomment">/// `TcpStream` can implement this using the `writev` syscall.</span>
+ <span class="kw">fn</span> <span class="ident">write_vec</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">bufs</span>: <span class="kw-2">&</span>[<span class="kw-2">&</span><span class="ident">IoVec</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="ident">bufs</span>.<span class="ident">is_empty</span>() {
+ <span class="prelude-val">Ok</span>(<span class="number">0</span>)
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">write</span>(<span class="kw-2">&</span><span class="ident">bufs</span>[<span class="number">0</span>])
+ }
+ }
+
+ <span class="doccomment">/// Provides a `Stream` and `Sink` interface for reading and writing to this</span>
+ <span class="doccomment">/// `Io` object, using `Decode` and `Encode` to read and write the raw data.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Raw I/O objects work with byte sequences, but higher-level code usually</span>
+ <span class="doccomment">/// wants to batch these into meaningful chunks, called "frames". This</span>
+ <span class="doccomment">/// method layers framing on top of an I/O object, by using the `Codec`</span>
+ <span class="doccomment">/// traits to handle encoding and decoding of messages frames. Note that</span>
+ <span class="doccomment">/// the incoming and outgoing frame types may be distinct.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function returns a *single* object that is both `Stream` and</span>
+ <span class="doccomment">/// `Sink`; grouping this into a single object is often useful for layering</span>
+ <span class="doccomment">/// things like gzip or TLS, which require both read and write access to the</span>
+ <span class="doccomment">/// underlying object.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If you want to work more directly with the streams and sink, consider</span>
+ <span class="doccomment">/// calling `split` on the `Framed` returned by this method, which will</span>
+ <span class="doccomment">/// break them into separate objects, allowing them to interact more easily.</span>
+ <span class="kw">fn</span> <span class="ident">framed</span><span class="op"><</span><span class="ident">C</span>: <span class="ident">Codec</span><span class="op">></span>(<span class="self">self</span>, <span class="ident">codec</span>: <span class="ident">C</span>) <span class="op">-></span> <span class="ident">Framed</span><span class="op"><</span><span class="self">Self</span>, <span class="ident">C</span><span class="op">></span>
+ <span class="kw">where</span> <span class="self">Self</span>: <span class="ident">Sized</span>,
+ {
+ <span class="ident">frame</span>::<span class="ident">framed</span>(<span class="self">self</span>, <span class="ident">codec</span>)
+ }
+
+ <span class="doccomment">/// Helper method for splitting this read/write object into two halves.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The two halves returned implement the `Read` and `Write` traits,</span>
+ <span class="doccomment">/// respectively.</span>
+ <span class="kw">fn</span> <span class="ident">split</span>(<span class="self">self</span>) <span class="op">-></span> (<span class="ident">ReadHalf</span><span class="op"><</span><span class="self">Self</span><span class="op">></span>, <span class="ident">WriteHalf</span><span class="op"><</span><span class="self">Self</span><span class="op">></span>)
+ <span class="kw">where</span> <span class="self">Self</span>: <span class="ident">Sized</span>
+ {
+ <span class="ident">split</span>::<span class="ident">split</span>(<span class="self">self</span>)
+ }
+}
+
+<span class="doccomment">/// A trait for framed reading and writing.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Most implementations of `FramedIo` are for doing protocol level</span>
+<span class="doccomment">/// serialization and deserialization.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Importantly, the methods of this trait are intended to be used in conjunction</span>
+<span class="doccomment">/// with the current task of a future. Namely whenever any of them return a</span>
+<span class="doccomment">/// value that indicates "would block" the current future's task is arranged to</span>
+<span class="doccomment">/// receive a notification when the method would otherwise not indicate that it</span>
+<span class="doccomment">/// would block.</span>
+<span class="comment">//</span>
+<span class="doccomment">/// For a sample implementation of `FramedIo` you can take a look at the</span>
+<span class="doccomment">/// `Framed` type in the `frame` module of this crate.</span>
+<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
+<span class="attribute">#[<span class="ident">deprecated</span>(<span class="ident">since</span> <span class="op">=</span> <span class="string">"0.1.1"</span>, <span class="ident">note</span> <span class="op">=</span> <span class="string">"replaced by Sink + Stream"</span>)]</span>
+<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">FramedIo</span> {
+ <span class="doccomment">/// Messages written</span>
+ <span class="kw">type</span> <span class="ident">In</span>;
+
+ <span class="doccomment">/// Messages read</span>
+ <span class="kw">type</span> <span class="ident">Out</span>;
+
+ <span class="doccomment">/// Tests to see if this `FramedIo` may be readable.</span>
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span>;
+
+ <span class="doccomment">/// Read a message frame from the `FramedIo`</span>
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">Out</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span>;
+
+ <span class="doccomment">/// Tests to see if this `FramedIo` may be writable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Unlike most other calls to poll readiness, it is important that when</span>
+ <span class="doccomment">/// `FramedIo::poll_write` returns `Async::Ready` that a write will</span>
+ <span class="doccomment">/// succeed.</span>
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span>;
+
+ <span class="doccomment">/// Write a message frame to the `FramedIo`</span>
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">req</span>: <span class="self">Self</span>::<span class="ident">In</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span>;
+
+ <span class="doccomment">/// Flush pending writes or do any other work not driven by reading /</span>
+ <span class="doccomment">/// writing.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Since the backing source is non-blocking, there is no guarantee that a</span>
+ <span class="doccomment">/// call to `FramedIo::write` is able to write the full message to the</span>
+ <span class="doccomment">/// backing source immediately. In this case, the `FramedIo` will need to</span>
+ <span class="doccomment">/// buffer the remaining data to write. Calls to `FramedIo:flush` attempt</span>
+ <span class="doccomment">/// to write any remaining data in the write buffer to the underlying</span>
+ <span class="doccomment">/// source.</span>
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span>;
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/read.rs.html b/src/tokio_core/io/read.rs.html
new file mode 100644
index 0000000..269562b
--- /dev/null
+++ b/src/tokio_core/io/read.rs.html
@@ -0,0 +1,227 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/read.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>read.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">Poll</span>};
+
+<span class="kw">enum</span> <span class="ident">State</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">Pending</span> {
+ <span class="ident">rd</span>: <span class="ident">R</span>,
+ <span class="ident">buf</span>: <span class="ident">T</span>,
+ },
+ <span class="ident">Empty</span>,
+}
+
+<span class="doccomment">/// Tries to read some bytes directly into the given `buf` in asynchronous</span>
+<span class="doccomment">/// manner, returning a future type.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The returned future will resolve to both the I/O stream and the buffer</span>
+<span class="doccomment">/// as well as the number of bytes read once the read operation is completed.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">read</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span>(<span class="ident">rd</span>: <span class="ident">R</span>, <span class="ident">buf</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">Read</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">R</span>: ::<span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">Read</span>,
+ <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>
+{
+ <span class="ident">Read</span> { <span class="ident">state</span>: <span class="ident">State</span>::<span class="ident">Pending</span> { <span class="ident">rd</span>: <span class="ident">rd</span>, <span class="ident">buf</span>: <span class="ident">buf</span> } }
+}
+
+<span class="doccomment">/// A future which can be used to easily read available number of bytes to fill</span>
+<span class="doccomment">/// a buffer.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`read`] function.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Read</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">state</span>: <span class="ident">State</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">Read</span><span class="op"><</span><span class="ident">R</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">R</span>: ::<span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">Read</span>,
+ <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">R</span>, <span class="ident">T</span>, <span class="ident">usize</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> ::<span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">R</span>, <span class="ident">T</span>, <span class="ident">usize</span>), ::<span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">nread</span> <span class="op">=</span> <span class="kw">match</span> <span class="self">self</span>.<span class="ident">state</span> {
+ <span class="ident">State</span>::<span class="ident">Pending</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">rd</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">buf</span> } <span class="op">=></span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">rd</span>.<span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">buf</span>.<span class="ident">as_mut</span>()[..])),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"poll a Read after it's done"</span>),
+ };
+
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">state</span>, <span class="ident">State</span>::<span class="ident">Empty</span>) {
+ <span class="ident">State</span>::<span class="ident">Pending</span> { <span class="ident">rd</span>, <span class="ident">buf</span> } <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">rd</span>, <span class="ident">buf</span>, <span class="ident">nread</span>).<span class="ident">into</span>()),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"invalid internal state"</span>),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/read_exact.rs.html b/src/tokio_core/io/read_exact.rs.html
new file mode 100644
index 0000000..c555e4d
--- /dev/null
+++ b/src/tokio_core/io/read_exact.rs.html
@@ -0,0 +1,283 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/read_exact.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>read_exact.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+<span id="66">66</span>
+<span id="67">67</span>
+<span id="68">68</span>
+<span id="69">69</span>
+<span id="70">70</span>
+<span id="71">71</span>
+<span id="72">72</span>
+<span id="73">73</span>
+<span id="74">74</span>
+<span id="75">75</span>
+<span id="76">76</span>
+<span id="77">77</span>
+<span id="78">78</span>
+<span id="79">79</span>
+<span id="80">80</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Future</span>};
+
+<span class="doccomment">/// A future which can be used to easily read exactly enough bytes to fill</span>
+<span class="doccomment">/// a buffer.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`read_exact`] function.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`read_exact`]: fn.read_exact.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ReadExact</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">state</span>: <span class="ident">State</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>,
+}
+
+<span class="kw">enum</span> <span class="ident">State</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">A</span>,
+ <span class="ident">buf</span>: <span class="ident">T</span>,
+ <span class="ident">pos</span>: <span class="ident">usize</span>,
+ },
+ <span class="ident">Empty</span>,
+}
+
+<span class="doccomment">/// Creates a future which will read exactly enough bytes to fill `buf`,</span>
+<span class="doccomment">/// returning an error if EOF is hit sooner.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The returned future will resolve to both the I/O stream as well as the</span>
+<span class="doccomment">/// buffer once the read operation is completed.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// In the case of an error the buffer and the object will be discarded, with</span>
+<span class="doccomment">/// the error yielded. In the case of success the object will be destroyed and</span>
+<span class="doccomment">/// the buffer will be returned, with all data read from the stream appended to</span>
+<span class="doccomment">/// the buffer.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">read_exact</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>(<span class="ident">a</span>: <span class="ident">A</span>, <span class="ident">buf</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">ReadExact</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Read</span>,
+ <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="ident">ReadExact</span> {
+ <span class="ident">state</span>: <span class="ident">State</span>::<span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">a</span>,
+ <span class="ident">buf</span>: <span class="ident">buf</span>,
+ <span class="ident">pos</span>: <span class="number">0</span>,
+ },
+ }
+}
+
+<span class="kw">fn</span> <span class="ident">eof</span>() <span class="op">-></span> <span class="ident">io</span>::<span class="ident">Error</span> {
+ <span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">UnexpectedEof</span>, <span class="string">"early eof"</span>)
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">ReadExact</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Read</span>,
+ <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">A</span>, <span class="ident">T</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">A</span>, <span class="ident">T</span>), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">state</span> {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">a</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">buf</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">pos</span> } <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">as_mut</span>();
+ <span class="kw">while</span> <span class="kw-2">*</span><span class="ident">pos</span> <span class="op"><</span> <span class="ident">buf</span>.<span class="ident">len</span>() {
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">buf</span>[<span class="kw-2">*</span><span class="ident">pos</span>..]));
+ <span class="kw-2">*</span><span class="ident">pos</span> <span class="op">+=</span> <span class="ident">n</span>;
+ <span class="kw">if</span> <span class="ident">n</span> <span class="op">==</span> <span class="number">0</span> {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">eof</span>())
+ }
+ }
+ }
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"poll a ReadExact after it's done"</span>),
+ }
+
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">state</span>, <span class="ident">State</span>::<span class="ident">Empty</span>) {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="ident">a</span>, <span class="ident">buf</span>, .. } <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">a</span>, <span class="ident">buf</span>).<span class="ident">into</span>()),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/read_to_end.rs.html b/src/tokio_core/io/read_to_end.rs.html
new file mode 100644
index 0000000..7f3722d
--- /dev/null
+++ b/src/tokio_core/io/read_to_end.rs.html
@@ -0,0 +1,253 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/read_to_end.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>read_to_end.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Future</span>};
+
+<span class="doccomment">/// A future which can be used to easily read the entire contents of a stream</span>
+<span class="doccomment">/// into a vector.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`read_to_end`] function.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`read_to_end`]: fn.read_to_end.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ReadToEnd</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> {
+ <span class="ident">state</span>: <span class="ident">State</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>,
+}
+
+<span class="kw">enum</span> <span class="ident">State</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> {
+ <span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">A</span>,
+ <span class="ident">buf</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+ },
+ <span class="ident">Empty</span>,
+}
+
+<span class="doccomment">/// Creates a future which will read all the bytes associated with the I/O</span>
+<span class="doccomment">/// object `A` into the buffer provided.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// In the case of an error the buffer and the object will be discarded, with</span>
+<span class="doccomment">/// the error yielded. In the case of success the object will be destroyed and</span>
+<span class="doccomment">/// the buffer will be returned, with all data read from the stream appended to</span>
+<span class="doccomment">/// the buffer.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">read_to_end</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>(<span class="ident">a</span>: <span class="ident">A</span>, <span class="ident">buf</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>) <span class="op">-></span> <span class="ident">ReadToEnd</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Read</span>,
+{
+ <span class="ident">ReadToEnd</span> {
+ <span class="ident">state</span>: <span class="ident">State</span>::<span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">a</span>,
+ <span class="ident">buf</span>: <span class="ident">buf</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">ReadToEnd</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Read</span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">A</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">A</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">state</span> {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">a</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">buf</span> } <span class="op">=></span> {
+ <span class="comment">// If we get `Ok`, then we know the stream hit EOF and we're done. If we</span>
+ <span class="comment">// hit "would block" then all the read data so far is in our buffer, and</span>
+ <span class="comment">// otherwise we propagate errors</span>
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">read_to_end</span>(<span class="ident">buf</span>));
+ },
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"poll ReadToEnd after it's done"</span>),
+ }
+
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">state</span>, <span class="ident">State</span>::<span class="ident">Empty</span>) {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="ident">a</span>, <span class="ident">buf</span> } <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">a</span>, <span class="ident">buf</span>).<span class="ident">into</span>()),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">unreachable</span><span class="macro">!</span>(),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/read_until.rs.html b/src/tokio_core/io/read_until.rs.html
new file mode 100644
index 0000000..05bfacd
--- /dev/null
+++ b/src/tokio_core/io/read_until.rs.html
@@ -0,0 +1,265 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/read_until.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>read_until.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+<span id="66">66</span>
+<span id="67">67</span>
+<span id="68">68</span>
+<span id="69">69</span>
+<span id="70">70</span>
+<span id="71">71</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>, <span class="ident">BufRead</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Future</span>};
+
+<span class="doccomment">/// A future which can be used to easily read the contents of a stream into a </span>
+<span class="doccomment">/// vector until the delimiter is reached.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the [`read_until`] function.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`read_until`]: fn.read_until.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ReadUntil</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> {
+ <span class="ident">state</span>: <span class="ident">State</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>,
+}
+
+<span class="kw">enum</span> <span class="ident">State</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> {
+ <span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">A</span>,
+ <span class="ident">byte</span>: <span class="ident">u8</span>,
+ <span class="ident">buf</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+ },
+ <span class="ident">Empty</span>,
+}
+
+<span class="doccomment">/// Creates a future which will read all the bytes associated with the I/O</span>
+<span class="doccomment">/// object `A` into the buffer provided until the delimiter `byte` is reached.</span>
+<span class="doccomment">/// This method is the async equivalent to [`BufRead::read_until`].</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// In case of an error the buffer and the object will be discarded, with</span>
+<span class="doccomment">/// the error yielded. In the case of success the object will be destroyed and</span>
+<span class="doccomment">/// the buffer will be returned, with all bytes up to, and including, the delimiter</span>
+<span class="doccomment">/// (if found).</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`BufRead::read_until`]: https://doc.rust-lang.org/std/io/trait.BufRead.html#method.read_until</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">read_until</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>(<span class="ident">a</span>: <span class="ident">A</span>, <span class="ident">byte</span>: <span class="ident">u8</span>, <span class="ident">buf</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>) <span class="op">-></span> <span class="ident">ReadUntil</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">BufRead</span>
+{
+ <span class="ident">ReadUntil</span> {
+ <span class="ident">state</span>: <span class="ident">State</span>::<span class="ident">Reading</span> {
+ <span class="ident">a</span>: <span class="ident">a</span>,
+ <span class="ident">byte</span>: <span class="ident">byte</span>,
+ <span class="ident">buf</span>: <span class="ident">buf</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">A</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">ReadUntil</span><span class="op"><</span><span class="ident">A</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Read</span> <span class="op">+</span> <span class="ident">BufRead</span>
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">A</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">A</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">state</span> {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">a</span>, <span class="ident">byte</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">buf</span> } <span class="op">=></span> {
+ <span class="comment">// If we get `Ok(n)`, then we know the stream hit EOF or the delimiter.</span>
+ <span class="comment">// and just return it, as we are finished.</span>
+ <span class="comment">// If we hit "would block" then all the read data so far</span>
+ <span class="comment">// is in our buffer, and otherwise we propagate errors.</span>
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">read_until</span>(<span class="ident">byte</span>, <span class="ident">buf</span>));
+ },
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"poll ReadUntil after it's done"</span>),
+ }
+
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">state</span>, <span class="ident">State</span>::<span class="ident">Empty</span>) {
+ <span class="ident">State</span>::<span class="ident">Reading</span> { <span class="ident">a</span>, <span class="ident">byte</span>: _, <span class="ident">buf</span> } <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">a</span>, <span class="ident">buf</span>).<span class="ident">into</span>()),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">unreachable</span><span class="macro">!</span>(),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/split.rs.html b/src/tokio_core/io/split.rs.html
new file mode 100644
index 0000000..206ce66
--- /dev/null
+++ b/src/tokio_core/io/split.rs.html
@@ -0,0 +1,259 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/split.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>split.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+<span id="66">66</span>
+<span id="67">67</span>
+<span id="68">68</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>, <span class="ident">Write</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">Async</span>;
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">sync</span>::<span class="ident">BiLock</span>;
+
+<span class="kw">use</span> <span class="ident">io</span>::<span class="ident">Io</span>;
+
+<span class="doccomment">/// The readable half of an object returned from `Io::split`.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ReadHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="ident">handle</span>: <span class="ident">BiLock</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>,
+}
+
+<span class="doccomment">/// The writable half of an object returned from `Io::split`.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">WriteHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="ident">handle</span>: <span class="ident">BiLock</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>,
+}
+
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">split</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Io</span><span class="op">></span>(<span class="ident">t</span>: <span class="ident">T</span>) <span class="op">-></span> (<span class="ident">ReadHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>, <span class="ident">WriteHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>) {
+ <span class="kw">let</span> (<span class="ident">a</span>, <span class="ident">b</span>) <span class="op">=</span> <span class="ident">BiLock</span>::<span class="ident">new</span>(<span class="ident">t</span>);
+ (<span class="ident">ReadHalf</span> { <span class="ident">handle</span>: <span class="ident">a</span> }, <span class="ident">WriteHalf</span> { <span class="ident">handle</span>: <span class="ident">b</span> })
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Io</span><span class="op">></span> <span class="ident">ReadHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="doccomment">/// Calls the underlying `poll_read` function on this handling, testing to</span>
+ <span class="doccomment">/// see if it's ready to be read from.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">handle</span>.<span class="ident">poll_lock</span>() {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw-2">mut</span> <span class="ident">l</span>) <span class="op">=></span> <span class="ident">l</span>.<span class="ident">poll_read</span>(),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="ident">Async</span>::<span class="ident">NotReady</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Io</span><span class="op">></span> <span class="ident">WriteHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="doccomment">/// Calls the underlying `poll_write` function on this handling, testing to</span>
+ <span class="doccomment">/// see if it's ready to be written to.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">handle</span>.<span class="ident">poll_lock</span>() {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw-2">mut</span> <span class="ident">l</span>) <span class="op">=></span> <span class="ident">l</span>.<span class="ident">poll_write</span>(),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="ident">Async</span>::<span class="ident">NotReady</span>,
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Read</span><span class="op">></span> <span class="ident">Read</span> <span class="kw">for</span> <span class="ident">ReadHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">handle</span>.<span class="ident">poll_lock</span>() {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw-2">mut</span> <span class="ident">l</span>) <span class="op">=></span> <span class="ident">l</span>.<span class="ident">read</span>(<span class="ident">buf</span>),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>()),
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Write</span><span class="op">></span> <span class="ident">Write</span> <span class="kw">for</span> <span class="ident">WriteHalf</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">handle</span>.<span class="ident">poll_lock</span>() {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw-2">mut</span> <span class="ident">l</span>) <span class="op">=></span> <span class="ident">l</span>.<span class="ident">write</span>(<span class="ident">buf</span>),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>()),
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">handle</span>.<span class="ident">poll_lock</span>() {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw-2">mut</span> <span class="ident">l</span>) <span class="op">=></span> <span class="ident">l</span>.<span class="ident">flush</span>(),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>()),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/window.rs.html b/src/tokio_core/io/window.rs.html
new file mode 100644
index 0000000..e858cc4
--- /dev/null
+++ b/src/tokio_core/io/window.rs.html
@@ -0,0 +1,355 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/window.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>window.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ops</span>;
+
+<span class="doccomment">/// A owned window around an underlying buffer.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Normally slices work great for considering sub-portions of a buffer, but</span>
+<span class="doccomment">/// unfortunately a slice is a *borrowed* type in Rust which has an associated</span>
+<span class="doccomment">/// lifetime. When working with future and async I/O these lifetimes are not</span>
+<span class="doccomment">/// always appropriate, and are sometimes difficult to store in tasks. This</span>
+<span class="doccomment">/// type strives to fill this gap by providing an "owned slice" around an</span>
+<span class="doccomment">/// underlying buffer of bytes.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// A `Window<T>` wraps an underlying buffer, `T`, and has configurable</span>
+<span class="doccomment">/// start/end indexes to alter the behavior of the `AsRef<[u8]>` implementation</span>
+<span class="doccomment">/// that this type carries.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This type can be particularly useful when working with the `write_all`</span>
+<span class="doccomment">/// combinator in this crate. Data can be sliced via `Window`, consumed by</span>
+<span class="doccomment">/// `write_all`, and then earned back once the write operation finishes through</span>
+<span class="doccomment">/// the `into_inner` method on this type.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="ident">inner</span>: <span class="ident">T</span>,
+ <span class="ident">range</span>: <span class="ident">ops</span>::<span class="ident">Range</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">>></span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="doccomment">/// Creates a new window around the buffer `t` defaulting to the entire</span>
+ <span class="doccomment">/// slice.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Further methods can be called on the returned `Window<T>` to alter the</span>
+ <span class="doccomment">/// window into the data provided.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">t</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="ident">Window</span> {
+ <span class="ident">range</span>: <span class="number">0</span>..<span class="ident">t</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>(),
+ <span class="ident">inner</span>: <span class="ident">t</span>,
+ }
+ }
+
+ <span class="doccomment">/// Gets a shared reference to the underlying buffer inside of this</span>
+ <span class="doccomment">/// `Window`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">T</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">inner</span>
+ }
+
+ <span class="doccomment">/// Gets a mutable reference to the underlying buffer inside of this</span>
+ <span class="doccomment">/// `Window`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">T</span> {
+ <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">inner</span>
+ }
+
+ <span class="doccomment">/// Consumes this `Window`, returning the underlying buffer.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">into_inner</span>(<span class="self">self</span>) <span class="op">-></span> <span class="ident">T</span> {
+ <span class="self">self</span>.<span class="ident">inner</span>
+ }
+
+ <span class="doccomment">/// Returns the starting index of this window into the underlying buffer</span>
+ <span class="doccomment">/// `T`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">start</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="self">self</span>.<span class="ident">range</span>.<span class="ident">start</span>
+ }
+
+ <span class="doccomment">/// Returns the end index of this window into the underlying buffer</span>
+ <span class="doccomment">/// `T`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">end</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="self">self</span>.<span class="ident">range</span>.<span class="ident">end</span>
+ }
+
+ <span class="doccomment">/// Changes the starting index of this window to the index specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Returns the windows back to chain multiple calls to this method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if `start` is out of bounds for the underlying</span>
+ <span class="doccomment">/// slice or if it comes after the `end` configured in this window.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_start</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">start</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">start</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>());
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">start</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">range</span>.<span class="ident">end</span>);
+ <span class="self">self</span>.<span class="ident">range</span>.<span class="ident">start</span> <span class="op">=</span> <span class="ident">start</span>;
+ <span class="self">self</span>
+ }
+
+ <span class="doccomment">/// Changes the end index of this window to the index specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Returns the windows back to chain multiple calls to this method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if `end` is out of bounds for the underlying</span>
+ <span class="doccomment">/// slice or if it comes before the `start` configured in this window.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_end</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">end</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">end</span> <span class="op"><=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>());
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">range</span>.<span class="ident">start</span> <span class="op"><=</span> <span class="ident">end</span>);
+ <span class="self">self</span>.<span class="ident">range</span>.<span class="ident">end</span> <span class="op">=</span> <span class="ident">end</span>;
+ <span class="self">self</span>
+ }
+
+ <span class="comment">// TODO: how about a generic set() method along the lines of:</span>
+ <span class="comment">//</span>
+ <span class="comment">// buffer.set(..3)</span>
+ <span class="comment">// .set(0..2)</span>
+ <span class="comment">// .set(4..)</span>
+ <span class="comment">//</span>
+ <span class="comment">// etc.</span>
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">>></span> <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span> <span class="kw">for</span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">as_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span>[<span class="ident">u8</span>] {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">as_ref</span>()[<span class="self">self</span>.<span class="ident">range</span>.<span class="ident">start</span>..<span class="self">self</span>.<span class="ident">range</span>.<span class="ident">end</span>]
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">>></span> <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span> <span class="kw">for</span> <span class="ident">Window</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">as_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] {
+ <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">as_mut</span>()[<span class="self">self</span>.<span class="ident">range</span>.<span class="ident">start</span>..<span class="self">self</span>.<span class="ident">range</span>.<span class="ident">end</span>]
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/io/write_all.rs.html b/src/tokio_core/io/write_all.rs.html
new file mode 100644
index 0000000..7ef74d0
--- /dev/null
+++ b/src/tokio_core/io/write_all.rs.html
@@ -0,0 +1,289 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/io/write_all.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>write_all.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+<span id="58">58</span>
+<span id="59">59</span>
+<span id="60">60</span>
+<span id="61">61</span>
+<span id="62">62</span>
+<span id="63">63</span>
+<span id="64">64</span>
+<span id="65">65</span>
+<span id="66">66</span>
+<span id="67">67</span>
+<span id="68">68</span>
+<span id="69">69</span>
+<span id="70">70</span>
+<span id="71">71</span>
+<span id="72">72</span>
+<span id="73">73</span>
+<span id="74">74</span>
+<span id="75">75</span>
+<span id="76">76</span>
+<span id="77">77</span>
+<span id="78">78</span>
+<span id="79">79</span>
+<span id="80">80</span>
+<span id="81">81</span>
+<span id="82">82</span>
+<span id="83">83</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Write</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Future</span>};
+
+<span class="doccomment">/// A future used to write the entire contents of some data to a stream.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This is created by the [`write_all`] top-level method.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [`write_all`]: fn.write_all.html</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">WriteAll</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">state</span>: <span class="ident">State</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>,
+}
+
+<span class="kw">enum</span> <span class="ident">State</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> {
+ <span class="ident">Writing</span> {
+ <span class="ident">a</span>: <span class="ident">A</span>,
+ <span class="ident">buf</span>: <span class="ident">T</span>,
+ <span class="ident">pos</span>: <span class="ident">usize</span>,
+ },
+ <span class="ident">Empty</span>,
+}
+
+<span class="doccomment">/// Creates a future that will write the entire contents of the buffer `buf` to</span>
+<span class="doccomment">/// the stream `a` provided.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The returned future will not return until all the data has been written, and</span>
+<span class="doccomment">/// the future will resolve to the stream as well as the buffer (for reuse if</span>
+<span class="doccomment">/// needed).</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Any error which happens during writing will cause both the stream and the</span>
+<span class="doccomment">/// buffer to get destroyed.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The `buf` parameter here only requires the `AsRef<[u8]>` trait, which should</span>
+<span class="doccomment">/// be broadly applicable to accepting data which can be converted to a slice.</span>
+<span class="doccomment">/// The `Window` struct is also available in this crate to provide a different</span>
+<span class="doccomment">/// window into a slice if necessary.</span>
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">write_all</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>(<span class="ident">a</span>: <span class="ident">A</span>, <span class="ident">buf</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">WriteAll</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Write</span>,
+ <span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="ident">WriteAll</span> {
+ <span class="ident">state</span>: <span class="ident">State</span>::<span class="ident">Writing</span> {
+ <span class="ident">a</span>: <span class="ident">a</span>,
+ <span class="ident">buf</span>: <span class="ident">buf</span>,
+ <span class="ident">pos</span>: <span class="number">0</span>,
+ },
+ }
+}
+
+<span class="kw">fn</span> <span class="ident">zero_write</span>() <span class="op">-></span> <span class="ident">io</span>::<span class="ident">Error</span> {
+ <span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WriteZero</span>, <span class="string">"zero-length write"</span>)
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">WriteAll</span><span class="op"><</span><span class="ident">A</span>, <span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">A</span>: <span class="ident">Write</span>,
+ <span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">A</span>, <span class="ident">T</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">A</span>, <span class="ident">T</span>), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">state</span> {
+ <span class="ident">State</span>::<span class="ident">Writing</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">a</span>, <span class="kw-2">ref</span> <span class="ident">buf</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">pos</span> } <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">as_ref</span>();
+ <span class="kw">while</span> <span class="kw-2">*</span><span class="ident">pos</span> <span class="op"><</span> <span class="ident">buf</span>.<span class="ident">len</span>() {
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">write</span>(<span class="kw-2">&</span><span class="ident">buf</span>[<span class="kw-2">*</span><span class="ident">pos</span>..]));
+ <span class="kw-2">*</span><span class="ident">pos</span> <span class="op">+=</span> <span class="ident">n</span>;
+ <span class="kw">if</span> <span class="ident">n</span> <span class="op">==</span> <span class="number">0</span> {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">zero_write</span>())
+ }
+ }
+ }
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"poll a WriteAll after it's done"</span>),
+ }
+
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">state</span>, <span class="ident">State</span>::<span class="ident">Empty</span>) {
+ <span class="ident">State</span>::<span class="ident">Writing</span> { <span class="ident">a</span>, <span class="ident">buf</span>, .. } <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">a</span>, <span class="ident">buf</span>).<span class="ident">into</span>()),
+ <span class="ident">State</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(),
+ }
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/lib.rs.html b/src/tokio_core/lib.rs.html
new file mode 100644
index 0000000..8875a20
--- /dev/null
+++ b/src/tokio_core/lib.rs.html
@@ -0,0 +1,361 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/lib.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>lib.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! `Future`-powered I/O at the core of Tokio</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This crate uses the `futures` crate to provide an event loop ("reactor</span>
+<span class="doccomment">//! core") which can be used to drive I/O like TCP and UDP, spawned future</span>
+<span class="doccomment">//! tasks, and other events like channels/timeouts. All asynchronous I/O is</span>
+<span class="doccomment">//! powered by the `mio` crate.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! The concrete types provided in this crate are relatively bare bones but are</span>
+<span class="doccomment">//! intended to be the essential foundation for further projects needing an</span>
+<span class="doccomment">//! event loop. In this crate you'll find:</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! * TCP, both streams and listeners</span>
+<span class="doccomment">//! * UDP sockets</span>
+<span class="doccomment">//! * Timeouts</span>
+<span class="doccomment">//! * An event loop to run futures</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! More functionality is likely to be added over time, but otherwise the crate</span>
+<span class="doccomment">//! is intended to be flexible, with the `PollEvented` type accepting any</span>
+<span class="doccomment">//! type that implements `mio::Evented`. For example, the `tokio-uds` crate</span>
+<span class="doccomment">//! uses `PollEvented` to provide support for Unix domain sockets.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! Some other important tasks covered by this crate are:</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! * The ability to spawn futures into an event loop. The `Handle` and `Remote`</span>
+<span class="doccomment">//! types have a `spawn` method which allows executing a future on an event</span>
+<span class="doccomment">//! loop. The `Handle::spawn` method crucially does not require the future</span>
+<span class="doccomment">//! itself to be `Send`.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! * The `Io` trait serves as an abstraction for future crates to build on top</span>
+<span class="doccomment">//! of. This packages up `Read` and `Write` functionality as well as the</span>
+<span class="doccomment">//! ability to poll for readiness on both ends.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! * All I/O is futures-aware. If any action in this crate returns "not ready"</span>
+<span class="doccomment">//! or "would block", then the current future task is scheduled to receive a</span>
+<span class="doccomment">//! notification when it would otherwise make progress.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! You can find more extensive documentation in terms of tutorials at</span>
+<span class="doccomment">//! [https://tokio.rs](https://tokio.rs).</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! # Examples</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! A simple TCP echo server:</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! ```no_run</span>
+<span class="doccomment">//! extern crate futures;</span>
+<span class="doccomment">//! extern crate tokio_core;</span>
+<span class="doccomment">//! extern crate tokio_io;</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! use futures::{Future, Stream};</span>
+<span class="doccomment">//! use tokio_io::AsyncRead;</span>
+<span class="doccomment">//! use tokio_io::io::copy;</span>
+<span class="doccomment">//! use tokio_core::net::TcpListener;</span>
+<span class="doccomment">//! use tokio_core::reactor::Core;</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! fn main() {</span>
+<span class="doccomment">//! // Create the event loop that will drive this server</span>
+<span class="doccomment">//! let mut core = Core::new().unwrap();</span>
+<span class="doccomment">//! let handle = core.handle();</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // Bind the server's socket</span>
+<span class="doccomment">//! let addr = "127.0.0.1:12345".parse().unwrap();</span>
+<span class="doccomment">//! let listener = TcpListener::bind(&addr, &handle).unwrap();</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // Pull out a stream of sockets for incoming connections</span>
+<span class="doccomment">//! let server = listener.incoming().for_each(|(sock, _)| {</span>
+<span class="doccomment">//! // Split up the reading and writing parts of the</span>
+<span class="doccomment">//! // socket</span>
+<span class="doccomment">//! let (reader, writer) = sock.split();</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // A future that echos the data and returns how</span>
+<span class="doccomment">//! // many bytes were copied...</span>
+<span class="doccomment">//! let bytes_copied = copy(reader, writer);</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // ... after which we'll print what happened</span>
+<span class="doccomment">//! let handle_conn = bytes_copied.map(|amt| {</span>
+<span class="doccomment">//! println!("wrote {:?} bytes", amt)</span>
+<span class="doccomment">//! }).map_err(|err| {</span>
+<span class="doccomment">//! println!("IO error {:?}", err)</span>
+<span class="doccomment">//! });</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // Spawn the future as a concurrent task</span>
+<span class="doccomment">//! handle.spawn(handle_conn);</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! Ok(())</span>
+<span class="doccomment">//! });</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! // Spin up the server on the event loop</span>
+<span class="doccomment">//! core.run(server).unwrap();</span>
+<span class="doccomment">//! }</span>
+<span class="doccomment">//! ```</span>
+
+<span class="attribute">#![<span class="ident">doc</span>(<span class="ident">html_root_url</span> <span class="op">=</span> <span class="string">"https://docs.rs/tokio-core/0.1"</span>)]</span>
+<span class="attribute">#![<span class="ident">deny</span>(<span class="ident">missing_docs</span>)]</span>
+<span class="attribute">#![<span class="ident">deny</span>(<span class="ident">warnings</span>)]</span>
+<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">test</span>, <span class="ident">allow</span>(<span class="ident">deprecated</span>))]</span>
+
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">bytes</span>;
+<span class="attribute">#[<span class="ident">macro_use</span>]</span>
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">futures</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">iovec</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">mio</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">slab</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">tokio_io</span>;
+
+<span class="attribute">#[<span class="ident">macro_use</span>]</span>
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">scoped_tls</span>;
+
+<span class="attribute">#[<span class="ident">macro_use</span>]</span>
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">log</span>;
+
+<span class="attribute">#[<span class="ident">macro_use</span>]</span>
+<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
+<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">io</span>;
+
+<span class="kw">mod</span> <span class="ident">heap</span>;
+<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
+<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">channel</span>;
+<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">net</span>;
+<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">reactor</span>;
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/net/mod.rs.html b/src/tokio_core/net/mod.rs.html
new file mode 100644
index 0000000..66037c9
--- /dev/null
+++ b/src/tokio_core/net/mod.rs.html
@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/net/mod.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>mod.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! TCP/UDP bindings for `tokio-core`</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This module contains the TCP/UDP networking types, similar to the standard</span>
+<span class="doccomment">//! library, which can be used to implement networking protocols.</span>
+
+<span class="kw">mod</span> <span class="ident">tcp</span>;
+<span class="kw">mod</span> <span class="ident">udp</span>;
+
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">tcp</span>::{<span class="ident">TcpStream</span>, <span class="ident">TcpStreamNew</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">tcp</span>::{<span class="ident">TcpListener</span>, <span class="ident">Incoming</span>};
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">udp</span>::{<span class="ident">UdpSocket</span>, <span class="ident">UdpCodec</span>, <span class="ident">UdpFramed</span>, <span class="ident">SendDgram</span>, <span class="ident">RecvDgram</span>};
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/net/tcp.rs.html b/src/tokio_core/net/tcp.rs.html
new file mode 100644
index 0000000..5944f96
--- /dev/null
+++ b/src/tokio_core/net/tcp.rs.html
@@ -0,0 +1,1753 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/net/tcp.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>tcp.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+<span id="410">410</span>
+<span id="411">411</span>
+<span id="412">412</span>
+<span id="413">413</span>
+<span id="414">414</span>
+<span id="415">415</span>
+<span id="416">416</span>
+<span id="417">417</span>
+<span id="418">418</span>
+<span id="419">419</span>
+<span id="420">420</span>
+<span id="421">421</span>
+<span id="422">422</span>
+<span id="423">423</span>
+<span id="424">424</span>
+<span id="425">425</span>
+<span id="426">426</span>
+<span id="427">427</span>
+<span id="428">428</span>
+<span id="429">429</span>
+<span id="430">430</span>
+<span id="431">431</span>
+<span id="432">432</span>
+<span id="433">433</span>
+<span id="434">434</span>
+<span id="435">435</span>
+<span id="436">436</span>
+<span id="437">437</span>
+<span id="438">438</span>
+<span id="439">439</span>
+<span id="440">440</span>
+<span id="441">441</span>
+<span id="442">442</span>
+<span id="443">443</span>
+<span id="444">444</span>
+<span id="445">445</span>
+<span id="446">446</span>
+<span id="447">447</span>
+<span id="448">448</span>
+<span id="449">449</span>
+<span id="450">450</span>
+<span id="451">451</span>
+<span id="452">452</span>
+<span id="453">453</span>
+<span id="454">454</span>
+<span id="455">455</span>
+<span id="456">456</span>
+<span id="457">457</span>
+<span id="458">458</span>
+<span id="459">459</span>
+<span id="460">460</span>
+<span id="461">461</span>
+<span id="462">462</span>
+<span id="463">463</span>
+<span id="464">464</span>
+<span id="465">465</span>
+<span id="466">466</span>
+<span id="467">467</span>
+<span id="468">468</span>
+<span id="469">469</span>
+<span id="470">470</span>
+<span id="471">471</span>
+<span id="472">472</span>
+<span id="473">473</span>
+<span id="474">474</span>
+<span id="475">475</span>
+<span id="476">476</span>
+<span id="477">477</span>
+<span id="478">478</span>
+<span id="479">479</span>
+<span id="480">480</span>
+<span id="481">481</span>
+<span id="482">482</span>
+<span id="483">483</span>
+<span id="484">484</span>
+<span id="485">485</span>
+<span id="486">486</span>
+<span id="487">487</span>
+<span id="488">488</span>
+<span id="489">489</span>
+<span id="490">490</span>
+<span id="491">491</span>
+<span id="492">492</span>
+<span id="493">493</span>
+<span id="494">494</span>
+<span id="495">495</span>
+<span id="496">496</span>
+<span id="497">497</span>
+<span id="498">498</span>
+<span id="499">499</span>
+<span id="500">500</span>
+<span id="501">501</span>
+<span id="502">502</span>
+<span id="503">503</span>
+<span id="504">504</span>
+<span id="505">505</span>
+<span id="506">506</span>
+<span id="507">507</span>
+<span id="508">508</span>
+<span id="509">509</span>
+<span id="510">510</span>
+<span id="511">511</span>
+<span id="512">512</span>
+<span id="513">513</span>
+<span id="514">514</span>
+<span id="515">515</span>
+<span id="516">516</span>
+<span id="517">517</span>
+<span id="518">518</span>
+<span id="519">519</span>
+<span id="520">520</span>
+<span id="521">521</span>
+<span id="522">522</span>
+<span id="523">523</span>
+<span id="524">524</span>
+<span id="525">525</span>
+<span id="526">526</span>
+<span id="527">527</span>
+<span id="528">528</span>
+<span id="529">529</span>
+<span id="530">530</span>
+<span id="531">531</span>
+<span id="532">532</span>
+<span id="533">533</span>
+<span id="534">534</span>
+<span id="535">535</span>
+<span id="536">536</span>
+<span id="537">537</span>
+<span id="538">538</span>
+<span id="539">539</span>
+<span id="540">540</span>
+<span id="541">541</span>
+<span id="542">542</span>
+<span id="543">543</span>
+<span id="544">544</span>
+<span id="545">545</span>
+<span id="546">546</span>
+<span id="547">547</span>
+<span id="548">548</span>
+<span id="549">549</span>
+<span id="550">550</span>
+<span id="551">551</span>
+<span id="552">552</span>
+<span id="553">553</span>
+<span id="554">554</span>
+<span id="555">555</span>
+<span id="556">556</span>
+<span id="557">557</span>
+<span id="558">558</span>
+<span id="559">559</span>
+<span id="560">560</span>
+<span id="561">561</span>
+<span id="562">562</span>
+<span id="563">563</span>
+<span id="564">564</span>
+<span id="565">565</span>
+<span id="566">566</span>
+<span id="567">567</span>
+<span id="568">568</span>
+<span id="569">569</span>
+<span id="570">570</span>
+<span id="571">571</span>
+<span id="572">572</span>
+<span id="573">573</span>
+<span id="574">574</span>
+<span id="575">575</span>
+<span id="576">576</span>
+<span id="577">577</span>
+<span id="578">578</span>
+<span id="579">579</span>
+<span id="580">580</span>
+<span id="581">581</span>
+<span id="582">582</span>
+<span id="583">583</span>
+<span id="584">584</span>
+<span id="585">585</span>
+<span id="586">586</span>
+<span id="587">587</span>
+<span id="588">588</span>
+<span id="589">589</span>
+<span id="590">590</span>
+<span id="591">591</span>
+<span id="592">592</span>
+<span id="593">593</span>
+<span id="594">594</span>
+<span id="595">595</span>
+<span id="596">596</span>
+<span id="597">597</span>
+<span id="598">598</span>
+<span id="599">599</span>
+<span id="600">600</span>
+<span id="601">601</span>
+<span id="602">602</span>
+<span id="603">603</span>
+<span id="604">604</span>
+<span id="605">605</span>
+<span id="606">606</span>
+<span id="607">607</span>
+<span id="608">608</span>
+<span id="609">609</span>
+<span id="610">610</span>
+<span id="611">611</span>
+<span id="612">612</span>
+<span id="613">613</span>
+<span id="614">614</span>
+<span id="615">615</span>
+<span id="616">616</span>
+<span id="617">617</span>
+<span id="618">618</span>
+<span id="619">619</span>
+<span id="620">620</span>
+<span id="621">621</span>
+<span id="622">622</span>
+<span id="623">623</span>
+<span id="624">624</span>
+<span id="625">625</span>
+<span id="626">626</span>
+<span id="627">627</span>
+<span id="628">628</span>
+<span id="629">629</span>
+<span id="630">630</span>
+<span id="631">631</span>
+<span id="632">632</span>
+<span id="633">633</span>
+<span id="634">634</span>
+<span id="635">635</span>
+<span id="636">636</span>
+<span id="637">637</span>
+<span id="638">638</span>
+<span id="639">639</span>
+<span id="640">640</span>
+<span id="641">641</span>
+<span id="642">642</span>
+<span id="643">643</span>
+<span id="644">644</span>
+<span id="645">645</span>
+<span id="646">646</span>
+<span id="647">647</span>
+<span id="648">648</span>
+<span id="649">649</span>
+<span id="650">650</span>
+<span id="651">651</span>
+<span id="652">652</span>
+<span id="653">653</span>
+<span id="654">654</span>
+<span id="655">655</span>
+<span id="656">656</span>
+<span id="657">657</span>
+<span id="658">658</span>
+<span id="659">659</span>
+<span id="660">660</span>
+<span id="661">661</span>
+<span id="662">662</span>
+<span id="663">663</span>
+<span id="664">664</span>
+<span id="665">665</span>
+<span id="666">666</span>
+<span id="667">667</span>
+<span id="668">668</span>
+<span id="669">669</span>
+<span id="670">670</span>
+<span id="671">671</span>
+<span id="672">672</span>
+<span id="673">673</span>
+<span id="674">674</span>
+<span id="675">675</span>
+<span id="676">676</span>
+<span id="677">677</span>
+<span id="678">678</span>
+<span id="679">679</span>
+<span id="680">680</span>
+<span id="681">681</span>
+<span id="682">682</span>
+<span id="683">683</span>
+<span id="684">684</span>
+<span id="685">685</span>
+<span id="686">686</span>
+<span id="687">687</span>
+<span id="688">688</span>
+<span id="689">689</span>
+<span id="690">690</span>
+<span id="691">691</span>
+<span id="692">692</span>
+<span id="693">693</span>
+<span id="694">694</span>
+<span id="695">695</span>
+<span id="696">696</span>
+<span id="697">697</span>
+<span id="698">698</span>
+<span id="699">699</span>
+<span id="700">700</span>
+<span id="701">701</span>
+<span id="702">702</span>
+<span id="703">703</span>
+<span id="704">704</span>
+<span id="705">705</span>
+<span id="706">706</span>
+<span id="707">707</span>
+<span id="708">708</span>
+<span id="709">709</span>
+<span id="710">710</span>
+<span id="711">711</span>
+<span id="712">712</span>
+<span id="713">713</span>
+<span id="714">714</span>
+<span id="715">715</span>
+<span id="716">716</span>
+<span id="717">717</span>
+<span id="718">718</span>
+<span id="719">719</span>
+<span id="720">720</span>
+<span id="721">721</span>
+<span id="722">722</span>
+<span id="723">723</span>
+<span id="724">724</span>
+<span id="725">725</span>
+<span id="726">726</span>
+<span id="727">727</span>
+<span id="728">728</span>
+<span id="729">729</span>
+<span id="730">730</span>
+<span id="731">731</span>
+<span id="732">732</span>
+<span id="733">733</span>
+<span id="734">734</span>
+<span id="735">735</span>
+<span id="736">736</span>
+<span id="737">737</span>
+<span id="738">738</span>
+<span id="739">739</span>
+<span id="740">740</span>
+<span id="741">741</span>
+<span id="742">742</span>
+<span id="743">743</span>
+<span id="744">744</span>
+<span id="745">745</span>
+<span id="746">746</span>
+<span id="747">747</span>
+<span id="748">748</span>
+<span id="749">749</span>
+<span id="750">750</span>
+<span id="751">751</span>
+<span id="752">752</span>
+<span id="753">753</span>
+<span id="754">754</span>
+<span id="755">755</span>
+<span id="756">756</span>
+<span id="757">757</span>
+<span id="758">758</span>
+<span id="759">759</span>
+<span id="760">760</span>
+<span id="761">761</span>
+<span id="762">762</span>
+<span id="763">763</span>
+<span id="764">764</span>
+<span id="765">765</span>
+<span id="766">766</span>
+<span id="767">767</span>
+<span id="768">768</span>
+<span id="769">769</span>
+<span id="770">770</span>
+<span id="771">771</span>
+<span id="772">772</span>
+<span id="773">773</span>
+<span id="774">774</span>
+<span id="775">775</span>
+<span id="776">776</span>
+<span id="777">777</span>
+<span id="778">778</span>
+<span id="779">779</span>
+<span id="780">780</span>
+<span id="781">781</span>
+<span id="782">782</span>
+<span id="783">783</span>
+<span id="784">784</span>
+<span id="785">785</span>
+<span id="786">786</span>
+<span id="787">787</span>
+<span id="788">788</span>
+<span id="789">789</span>
+<span id="790">790</span>
+<span id="791">791</span>
+<span id="792">792</span>
+<span id="793">793</span>
+<span id="794">794</span>
+<span id="795">795</span>
+<span id="796">796</span>
+<span id="797">797</span>
+<span id="798">798</span>
+<span id="799">799</span>
+<span id="800">800</span>
+<span id="801">801</span>
+<span id="802">802</span>
+<span id="803">803</span>
+<span id="804">804</span>
+<span id="805">805</span>
+<span id="806">806</span>
+<span id="807">807</span>
+<span id="808">808</span>
+<span id="809">809</span>
+<span id="810">810</span>
+<span id="811">811</span>
+<span id="812">812</span>
+<span id="813">813</span>
+<span id="814">814</span>
+<span id="815">815</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>, <span class="ident">Write</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">net</span>::{<span class="self">self</span>, <span class="ident">SocketAddr</span>, <span class="ident">Shutdown</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::<span class="ident">Duration</span>;
+
+<span class="kw">use</span> <span class="ident">bytes</span>::{<span class="ident">Buf</span>, <span class="ident">BufMut</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">stream</span>::<span class="ident">Stream</span>;
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">sync</span>::<span class="ident">oneshot</span>;
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">Poll</span>, <span class="ident">Async</span>};
+<span class="kw">use</span> <span class="ident">iovec</span>::<span class="ident">IoVec</span>;
+<span class="kw">use</span> <span class="ident">mio</span>;
+<span class="kw">use</span> <span class="ident">tokio_io</span>::{<span class="ident">AsyncRead</span>, <span class="ident">AsyncWrite</span>};
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Handle</span>, <span class="ident">PollEvented</span>};
+
+<span class="doccomment">/// An I/O object representing a TCP socket listening for incoming connections.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This object can be converted into a stream of incoming connections for</span>
+<span class="doccomment">/// various forms of processing.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TcpListener</span> {
+ <span class="ident">io</span>: <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpListener</span><span class="op">></span>,
+ <span class="ident">pending_accept</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">oneshot</span>::<span class="ident">Receiver</span><span class="op"><</span><span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>(<span class="ident">TcpStream</span>, <span class="ident">SocketAddr</span>)<span class="op">>></span><span class="op">></span>,
+}
+
+<span class="doccomment">/// Stream returned by the `TcpListener::incoming` function representing the</span>
+<span class="doccomment">/// stream of sockets received from a listener.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"streams do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Incoming</span> {
+ <span class="ident">inner</span>: <span class="ident">TcpListener</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">TcpListener</span> {
+ <span class="doccomment">/// Create a new TCP listener associated with this event loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The TCP listener will bind to the provided `addr` address, if available.</span>
+ <span class="doccomment">/// If the result is `Ok`, the socket has successfully bound.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">bind</span>(<span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TcpListener</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">l</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpListener</span>::<span class="ident">bind</span>(<span class="ident">addr</span>));
+ <span class="ident">TcpListener</span>::<span class="ident">new</span>(<span class="ident">l</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Attempt to accept a connection and create a new connected `TcpStream` if</span>
+ <span class="doccomment">/// successful.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will attempt an accept operation, but will not block</span>
+ <span class="doccomment">/// waiting for it to complete. If the operation would block then a "would</span>
+ <span class="doccomment">/// block" error is returned. Additionally, if this method would block, it</span>
+ <span class="doccomment">/// registers the current task to receive a notification when it would</span>
+ <span class="doccomment">/// otherwise not block.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that typically for simple usage it's easier to treat incoming</span>
+ <span class="doccomment">/// connections as a `Stream` of `TcpStream`s with the `incoming` method</span>
+ <span class="doccomment">/// below.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if it is called outside the context of a</span>
+ <span class="doccomment">/// future's task. It's recommended to only call this from the</span>
+ <span class="doccomment">/// implementation of a `Future::poll`, if necessary.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">accept</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>(<span class="ident">TcpStream</span>, <span class="ident">SocketAddr</span>)<span class="op">></span> {
+ <span class="kw">loop</span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="kw-2">mut</span> <span class="ident">pending</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">pending_accept</span>.<span class="ident">take</span>() {
+ <span class="kw">match</span> <span class="ident">pending</span>.<span class="ident">poll</span>().<span class="ident">expect</span>(<span class="string">"shouldn't be canceled"</span>) {
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> {
+ <span class="self">self</span>.<span class="ident">pending_accept</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">pending</span>);
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ },
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="ident">r</span>) <span class="op">=></span> <span class="kw">return</span> <span class="ident">r</span>,
+ }
+ }
+
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>, <span class="string">"not ready"</span>))
+ }
+
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">accept</span>() {
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ },
+ <span class="prelude-val">Ok</span>((<span class="ident">sock</span>, <span class="ident">addr</span>)) <span class="op">=></span> {
+ <span class="comment">// Fast path if we haven't left the event loop</span>
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">handle</span>) <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">remote</span>().<span class="ident">handle</span>() {
+ <span class="kw">let</span> <span class="ident">io</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">sock</span>, <span class="kw-2">&</span><span class="ident">handle</span>));
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>((<span class="ident">TcpStream</span> { <span class="ident">io</span>: <span class="ident">io</span> }, <span class="ident">addr</span>))
+ }
+
+ <span class="comment">// If we're off the event loop then send the socket back</span>
+ <span class="comment">// over there to get registered and then we'll get it back</span>
+ <span class="comment">// eventually.</span>
+ <span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">oneshot</span>::<span class="ident">channel</span>();
+ <span class="kw">let</span> <span class="ident">remote</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">remote</span>().<span class="ident">clone</span>();
+ <span class="ident">remote</span>.<span class="ident">spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="ident">handle</span><span class="op">|</span> {
+ <span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">sock</span>, <span class="ident">handle</span>)
+ .<span class="ident">map</span>(<span class="kw">move</span> <span class="op">|</span><span class="ident">io</span><span class="op">|</span> {
+ (<span class="ident">TcpStream</span> { <span class="ident">io</span>: <span class="ident">io</span> }, <span class="ident">addr</span>)
+ });
+ <span class="ident">drop</span>(<span class="ident">tx</span>.<span class="ident">send</span>(<span class="ident">res</span>));
+ <span class="prelude-val">Ok</span>(())
+ });
+ <span class="self">self</span>.<span class="ident">pending_accept</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">rx</span>);
+ <span class="comment">// continue to polling the `rx` at the beginning of the loop</span>
+ }
+ }
+ }
+ }
+
+ <span class="doccomment">/// Like `accept`, except that it returns a raw `std::net::TcpStream`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The stream is *in blocking mode*, and is not associated with the Tokio</span>
+ <span class="doccomment">/// event loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">accept_std</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>(<span class="ident">net</span>::<span class="ident">TcpStream</span>, <span class="ident">SocketAddr</span>)<span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>, <span class="string">"not ready"</span>))
+ }
+
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">accept_std</span>() {
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ },
+ <span class="prelude-val">Ok</span>((<span class="ident">sock</span>, <span class="ident">addr</span>)) <span class="op">=></span> <span class="prelude-val">Ok</span>((<span class="ident">sock</span>, <span class="ident">addr</span>)),
+ }
+ }
+
+ <span class="doccomment">/// Create a new TCP listener from the standard library's TCP listener.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method can be used when the `Handle::tcp_listen` method isn't</span>
+ <span class="doccomment">/// sufficient because perhaps some more configuration is needed in terms of</span>
+ <span class="doccomment">/// before the calls to `bind` and `listen`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This API is typically paired with the `net2` crate and the `TcpBuilder`</span>
+ <span class="doccomment">/// type to build up and customize a listener before it's shipped off to the</span>
+ <span class="doccomment">/// backing event loop. This allows configuration of options like</span>
+ <span class="doccomment">/// `SO_REUSEPORT`, binding to multiple addresses, etc.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `addr` argument here is one of the addresses that `listener` is</span>
+ <span class="doccomment">/// bound to and the listener will only be guaranteed to accept connections</span>
+ <span class="doccomment">/// of the same address type currently.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Finally, the `handle` argument is the event loop that this listener will</span>
+ <span class="doccomment">/// be bound to.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The platform specific behavior of this function looks like:</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// * On Unix, the socket is placed into nonblocking mode and connections</span>
+ <span class="doccomment">/// can be accepted as normal</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// * On Windows, the address is stored internally and all future accepts</span>
+ <span class="doccomment">/// will only be for the same IP version as `addr` specified. That is, if</span>
+ <span class="doccomment">/// `addr` is an IPv4 address then all sockets accepted will be IPv4 as</span>
+ <span class="doccomment">/// well (same for IPv6).</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">from_listener</span>(<span class="ident">listener</span>: <span class="ident">net</span>::<span class="ident">TcpListener</span>,
+ <span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>,
+ <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TcpListener</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">l</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpListener</span>::<span class="ident">from_listener</span>(<span class="ident">listener</span>, <span class="ident">addr</span>));
+ <span class="ident">TcpListener</span>::<span class="ident">new</span>(<span class="ident">l</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">listener</span>: <span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpListener</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>)
+ <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TcpListener</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">io</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">listener</span>, <span class="ident">handle</span>));
+ <span class="prelude-val">Ok</span>(<span class="ident">TcpListener</span> { <span class="ident">io</span>: <span class="ident">io</span>, <span class="ident">pending_accept</span>: <span class="prelude-val">None</span> })
+ }
+
+ <span class="doccomment">/// Test whether this socket is ready to be read or not.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>()
+ }
+
+ <span class="doccomment">/// Returns the local address that this listener is bound to.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This can be useful, for example, when binding to port 0 to figure out</span>
+ <span class="doccomment">/// which port was actually bound.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">local_addr</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">SocketAddr</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">local_addr</span>()
+ }
+
+ <span class="doccomment">/// Consumes this listener, returning a stream of the sockets this listener</span>
+ <span class="doccomment">/// accepts.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method returns an implementation of the `Stream` trait which</span>
+ <span class="doccomment">/// resolves to the sockets the are accepted on this listener.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">incoming</span>(<span class="self">self</span>) <span class="op">-></span> <span class="ident">Incoming</span> {
+ <span class="ident">Incoming</span> { <span class="ident">inner</span>: <span class="self">self</span> }
+ }
+
+ <span class="doccomment">/// Sets the value for the `IP_TTL` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This value sets the time-to-live field that is used in every packet sent</span>
+ <span class="doccomment">/// from this socket.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_ttl</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">ttl</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_ttl</span>(<span class="ident">ttl</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IP_TTL` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_ttl`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_ttl</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ttl</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">ttl</span>()
+ }
+
+ <span class="doccomment">/// Sets the value for the `IPV6_V6ONLY` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `true` then the socket is restricted to sending and</span>
+ <span class="doccomment">/// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications</span>
+ <span class="doccomment">/// can bind the same port at the same time.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `false` then the socket can be used to send and</span>
+ <span class="doccomment">/// receive packets from an IPv4-mapped IPv6 address.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">only_v6</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_only_v6</span>(<span class="ident">only_v6</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IPV6_V6ONLY` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_only_v6`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_only_v6</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">only_v6</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">TcpListener</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">fmt</span>(<span class="ident">f</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Stream</span> <span class="kw">for</span> <span class="ident">Incoming</span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">TcpStream</span>, <span class="ident">SocketAddr</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">Item</span><span class="op">></span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(<span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">accept</span>()))))
+ }
+}
+
+<span class="doccomment">/// An I/O object representing a TCP stream connected to a remote endpoint.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// A TCP stream can either be created by connecting to an endpoint or by</span>
+<span class="doccomment">/// accepting a connection from a listener. Inside the stream is access to the</span>
+<span class="doccomment">/// raw underlying I/O object as well as streams for the read/write</span>
+<span class="doccomment">/// notifications on the stream itself.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TcpStream</span> {
+ <span class="ident">io</span>: <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpStream</span><span class="op">></span>,
+}
+
+<span class="doccomment">/// Future returned by `TcpStream::connect` which will resolve to a `TcpStream`</span>
+<span class="doccomment">/// when the stream is connected.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TcpStreamNew</span> {
+ <span class="ident">inner</span>: <span class="ident">TcpStreamNewState</span>,
+}
+
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">enum</span> <span class="ident">TcpStreamNewState</span> {
+ <span class="ident">Waiting</span>(<span class="ident">TcpStream</span>),
+ <span class="ident">Error</span>(<span class="ident">io</span>::<span class="ident">Error</span>),
+ <span class="ident">Empty</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">TcpStream</span> {
+ <span class="doccomment">/// Create a new TCP stream connected to the specified address.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will create a new TCP socket and attempt to connect it to</span>
+ <span class="doccomment">/// the `addr` provided. The returned future will be resolved once the</span>
+ <span class="doccomment">/// stream has successfully connected. If an error happens during the</span>
+ <span class="doccomment">/// connection or during the socket creation, that error will be returned to</span>
+ <span class="doccomment">/// the future instead.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">connect</span>(<span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">TcpStreamNew</span> {
+ <span class="kw">let</span> <span class="ident">inner</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpStream</span>::<span class="ident">connect</span>(<span class="ident">addr</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">tcp</span>) <span class="op">=></span> <span class="ident">TcpStream</span>::<span class="ident">new</span>(<span class="ident">tcp</span>, <span class="ident">handle</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="ident">TcpStreamNewState</span>::<span class="ident">Error</span>(<span class="ident">e</span>),
+ };
+ <span class="ident">TcpStreamNew</span> { <span class="ident">inner</span>: <span class="ident">inner</span> }
+ }
+
+ <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">connected_stream</span>: <span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpStream</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>)
+ <span class="op">-></span> <span class="ident">TcpStreamNewState</span> {
+ <span class="kw">match</span> <span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">connected_stream</span>, <span class="ident">handle</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">io</span>) <span class="op">=></span> <span class="ident">TcpStreamNewState</span>::<span class="ident">Waiting</span>(<span class="ident">TcpStream</span> { <span class="ident">io</span>: <span class="ident">io</span> }),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="ident">TcpStreamNewState</span>::<span class="ident">Error</span>(<span class="ident">e</span>),
+ }
+ }
+
+ <span class="doccomment">/// Create a new `TcpStream` from a `net::TcpStream`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will convert a TCP stream in the standard library to a TCP</span>
+ <span class="doccomment">/// stream ready to be used with the provided event loop handle. The object</span>
+ <span class="doccomment">/// returned is associated with the event loop and ready to perform I/O.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">from_stream</span>(<span class="ident">stream</span>: <span class="ident">net</span>::<span class="ident">TcpStream</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>)
+ <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">inner</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpStream</span>::<span class="ident">from_stream</span>(<span class="ident">stream</span>));
+ <span class="prelude-val">Ok</span>(<span class="ident">TcpStream</span> {
+ <span class="ident">io</span>: <span class="macro">try</span><span class="macro">!</span>(<span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">inner</span>, <span class="ident">handle</span>)),
+ })
+ }
+
+ <span class="doccomment">/// Creates a new `TcpStream` from the pending socket inside the given</span>
+ <span class="doccomment">/// `std::net::TcpStream`, connecting it to the address specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This constructor allows configuring the socket before it's actually</span>
+ <span class="doccomment">/// connected, and this function will transfer ownership to the returned</span>
+ <span class="doccomment">/// `TcpStream` if successful. An unconnected `TcpStream` can be created</span>
+ <span class="doccomment">/// with the `net2::TcpBuilder` type (and also configured via that route).</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The platform specific behavior of this function looks like:</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// * On Unix, the socket is placed into nonblocking mode and then a</span>
+ <span class="doccomment">/// `connect` call is issued.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// * On Windows, the address is stored internally and the connect operation</span>
+ <span class="doccomment">/// is issued when the returned `TcpStream` is registered with an event</span>
+ <span class="doccomment">/// loop. Note that on Windows you must `bind` a socket before it can be</span>
+ <span class="doccomment">/// connected, so if a custom `TcpBuilder` is used it should be bound</span>
+ <span class="doccomment">/// (perhaps to `INADDR_ANY`) before this method is called.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">connect_stream</span>(<span class="ident">stream</span>: <span class="ident">net</span>::<span class="ident">TcpStream</span>,
+ <span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>,
+ <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>)
+ <span class="op">-></span> <span class="ident">Box</span><span class="op"><</span><span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span><span class="ident">TcpStream</span>, <span class="ident">Error</span><span class="op">=</span><span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> <span class="op">+</span> <span class="ident">Send</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">state</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">TcpStream</span>::<span class="ident">connect_stream</span>(<span class="ident">stream</span>, <span class="ident">addr</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">tcp</span>) <span class="op">=></span> <span class="ident">TcpStream</span>::<span class="ident">new</span>(<span class="ident">tcp</span>, <span class="ident">handle</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="ident">TcpStreamNewState</span>::<span class="ident">Error</span>(<span class="ident">e</span>),
+ };
+ <span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">state</span>)
+ }
+
+ <span class="doccomment">/// Test whether this socket is ready to be read or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If the socket is *not* readable then the current task is scheduled to</span>
+ <span class="doccomment">/// get a notification when the socket does become readable. That is, this</span>
+ <span class="doccomment">/// is only suitable for calling in a `Future::poll` method and will</span>
+ <span class="doccomment">/// automatically handle ensuring a retry once the socket is readable again.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>()
+ }
+
+ <span class="doccomment">/// Test whether this socket is ready to be written to or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If the socket is *not* writable then the current task is scheduled to</span>
+ <span class="doccomment">/// get a notification when the socket does become writable. That is, this</span>
+ <span class="doccomment">/// is only suitable for calling in a `Future::poll` method and will</span>
+ <span class="doccomment">/// automatically handle ensuring a retry once the socket is writable again.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_write</span>()
+ }
+
+ <span class="doccomment">/// Returns the local address that this stream is bound to.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">local_addr</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">SocketAddr</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">local_addr</span>()
+ }
+
+ <span class="doccomment">/// Returns the remote address that this stream is connected to.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">peer_addr</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">SocketAddr</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">peer_addr</span>()
+ }
+
+ <span class="doccomment">/// Receives data on the socket from the remote address to which it is</span>
+ <span class="doccomment">/// connected, without removing that data from the queue. On success,</span>
+ <span class="doccomment">/// returns the number of bytes peeked.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Successive calls return the same data. This is accomplished by passing</span>
+ <span class="doccomment">/// `MSG_PEEK` as a flag to the underlying recv system call.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">peek</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">peek</span>(<span class="ident">buf</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+
+ }
+
+ <span class="doccomment">/// Shuts down the read, write, or both halves of this connection.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will cause all pending and future I/O on the specified</span>
+ <span class="doccomment">/// portions to return immediately with an appropriate value (see the</span>
+ <span class="doccomment">/// documentation of `Shutdown`).</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">how</span>: <span class="ident">Shutdown</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">shutdown</span>(<span class="ident">how</span>)
+ }
+
+ <span class="doccomment">/// Sets the value of the `TCP_NODELAY` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If set, this option disables the Nagle algorithm. This means that</span>
+ <span class="doccomment">/// segments are always sent as soon as possible, even if there is only a</span>
+ <span class="doccomment">/// small amount of data. When not set, data is buffered until there is a</span>
+ <span class="doccomment">/// sufficient amount to send out, thereby avoiding the frequent sending of</span>
+ <span class="doccomment">/// small packets.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_nodelay</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">nodelay</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_nodelay</span>(<span class="ident">nodelay</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `TCP_NODELAY` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_nodelay`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_nodelay</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">nodelay</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">nodelay</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `SO_RCVBUF` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Changes the size of the operating system's receive buffer associated</span>
+ <span class="doccomment">/// with the socket.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_recv_buffer_size</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">size</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_recv_buffer_size</span>(<span class="ident">size</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `SO_RCVBUF` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`set_recv_buffer_size`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #tymethod.set_recv_buffer_size</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">recv_buffer_size</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">recv_buffer_size</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `SO_SNDBUF` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Changes the size of the operating system's send buffer associated with</span>
+ <span class="doccomment">/// the socket.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_send_buffer_size</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">size</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_send_buffer_size</span>(<span class="ident">size</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `SO_SNDBUF` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_send_buffer`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #tymethod.set_send_buffer</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">send_buffer_size</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">send_buffer_size</span>()
+ }
+
+ <span class="doccomment">/// Sets whether keepalive messages are enabled to be sent on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// On Unix, this option will set the `SO_KEEPALIVE` as well as the</span>
+ <span class="doccomment">/// `TCP_KEEPALIVE` or `TCP_KEEPIDLE` option (depending on your platform).</span>
+ <span class="doccomment">/// On Windows, this will set the `SIO_KEEPALIVE_VALS` option.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If `None` is specified then keepalive messages are disabled, otherwise</span>
+ <span class="doccomment">/// the duration specified will be the time to remain idle before sending a</span>
+ <span class="doccomment">/// TCP keepalive probe.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Some platforms specify this value in seconds, so sub-second</span>
+ <span class="doccomment">/// specifications may be omitted.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_keepalive</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">keepalive</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_keepalive</span>(<span class="ident">keepalive</span>)
+ }
+
+ <span class="doccomment">/// Returns whether keepalive messages are enabled on this socket, and if so</span>
+ <span class="doccomment">/// the duration of time between them.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_keepalive`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #tymethod.set_keepalive</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">keepalive</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">>></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">keepalive</span>()
+ }
+
+ <span class="doccomment">/// Sets the value for the `IP_TTL` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This value sets the time-to-live field that is used in every packet sent</span>
+ <span class="doccomment">/// from this socket.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_ttl</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">ttl</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_ttl</span>(<span class="ident">ttl</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IP_TTL` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_ttl`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #tymethod.set_ttl</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ttl</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">ttl</span>()
+ }
+
+ <span class="doccomment">/// Sets the value for the `IPV6_V6ONLY` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `true` then the socket is restricted to sending and</span>
+ <span class="doccomment">/// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications</span>
+ <span class="doccomment">/// can bind the same port at the same time.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `false` then the socket can be used to send and</span>
+ <span class="doccomment">/// receive packets from an IPv4-mapped IPv6 address.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">only_v6</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_only_v6</span>(<span class="ident">only_v6</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IPV6_V6ONLY` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_only_v6`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #tymethod.set_only_v6</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">only_v6</span>()
+ }
+
+ <span class="doccomment">/// Sets the linger duration of this socket by setting the SO_LINGER option</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_linger</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">dur</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_linger</span>(<span class="ident">dur</span>)
+ }
+
+ <span class="doccomment">/// reads the linger duration for this socket by getting the SO_LINGER option</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">linger</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">>></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">linger</span>()
+ }
+
+ <span class="attribute">#[<span class="ident">deprecated</span>(<span class="ident">since</span> <span class="op">=</span> <span class="string">"0.1.8"</span>, <span class="ident">note</span> <span class="op">=</span> <span class="string">"use set_keepalive"</span>)]</span>
+ <span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_keepalive_ms</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">keepalive</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_keepalive_ms</span>(<span class="ident">keepalive</span>)
+ }
+
+ <span class="attribute">#[<span class="ident">deprecated</span>(<span class="ident">since</span> <span class="op">=</span> <span class="string">"0.1.8"</span>, <span class="ident">note</span> <span class="op">=</span> <span class="string">"use keepalive"</span>)]</span>
+ <span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">keepalive_ms</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">>></span> {
+ <span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">keepalive_ms</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Read</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">read</span>(<span class="ident">buf</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Write</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">write</span>(<span class="ident">buf</span>)
+ }
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="prelude-val">Ok</span>(())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">AsyncRead</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">unsafe</span> <span class="kw">fn</span> <span class="ident">prepare_uninitialized_buffer</span>(<span class="kw-2">&</span><span class="self">self</span>, _: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="bool-val">false</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">read_buf</span><span class="op"><</span><span class="ident">B</span>: <span class="ident">BufMut</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">B</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">usize</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="op"><</span><span class="kw-2">&</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">read_buf</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="self">self</span>, <span class="ident">buf</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">AsyncWrite</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="op"><</span><span class="kw-2">&</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">write_buf</span><span class="op"><</span><span class="ident">B</span>: <span class="ident">Buf</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">B</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">usize</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="op"><</span><span class="kw-2">&</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">write_buf</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="self">self</span>, <span class="ident">buf</span>)
+ }
+}
+
+<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+<span class="kw">impl</span> ::<span class="ident">io</span>::<span class="ident">Io</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_read</span>(<span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_write</span>(<span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">read_vec</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">bufs</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">IoVec</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_read</span>(<span class="self">self</span>) {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">read_bufs</span>(<span class="ident">bufs</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">write_vec</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">bufs</span>: <span class="kw-2">&</span>[<span class="kw-2">&</span><span class="ident">IoVec</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_write</span>(<span class="self">self</span>) {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">write_bufs</span>(<span class="ident">bufs</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_write</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+}
+
+<span class="kw">fn</span> <span class="ident">is_wouldblock</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="ident">r</span>: <span class="kw-2">&</span><span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="kw">match</span> <span class="kw-2">*</span><span class="ident">r</span> {
+ <span class="prelude-val">Ok</span>(_) <span class="op">=></span> <span class="bool-val">false</span>,
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="op">=></span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>,
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">Read</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ (<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>).<span class="ident">read</span>(<span class="ident">buf</span>)
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">Write</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ (<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>).<span class="ident">write</span>(<span class="ident">buf</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ (<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>).<span class="ident">flush</span>()
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">AsyncRead</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">TcpStream</span> {
+ <span class="kw">unsafe</span> <span class="kw">fn</span> <span class="ident">prepare_uninitialized_buffer</span>(<span class="kw-2">&</span><span class="self">self</span>, _: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="bool-val">false</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">read_buf</span><span class="op"><</span><span class="ident">B</span>: <span class="ident">BufMut</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">B</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">usize</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_read</span>(<span class="self">self</span>) {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="kw">unsafe</span> {
+ <span class="comment">// The `IoVec` type can't have a 0-length size, so we create a bunch</span>
+ <span class="comment">// of dummy versions on the stack with 1 length which we'll quickly</span>
+ <span class="comment">// overwrite.</span>
+ <span class="kw">let</span> <span class="ident">b1</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b2</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b3</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b4</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b5</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b6</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b7</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b8</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b9</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b10</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b11</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b12</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b13</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b14</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b15</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">b16</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0</span>];
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bufs</span>: [<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">IoVec</span>; <span class="number">16</span>] <span class="op">=</span> [
+ <span class="ident">b1</span>.<span class="ident">into</span>(), <span class="ident">b2</span>.<span class="ident">into</span>(), <span class="ident">b3</span>.<span class="ident">into</span>(), <span class="ident">b4</span>.<span class="ident">into</span>(),
+ <span class="ident">b5</span>.<span class="ident">into</span>(), <span class="ident">b6</span>.<span class="ident">into</span>(), <span class="ident">b7</span>.<span class="ident">into</span>(), <span class="ident">b8</span>.<span class="ident">into</span>(),
+ <span class="ident">b9</span>.<span class="ident">into</span>(), <span class="ident">b10</span>.<span class="ident">into</span>(), <span class="ident">b11</span>.<span class="ident">into</span>(), <span class="ident">b12</span>.<span class="ident">into</span>(),
+ <span class="ident">b13</span>.<span class="ident">into</span>(), <span class="ident">b14</span>.<span class="ident">into</span>(), <span class="ident">b15</span>.<span class="ident">into</span>(), <span class="ident">b16</span>.<span class="ident">into</span>(),
+ ];
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">bytes_vec_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">bufs</span>);
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">read_bufs</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">bufs</span>[..<span class="ident">n</span>])
+ };
+
+ <span class="kw">match</span> <span class="ident">r</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> {
+ <span class="kw">unsafe</span> { <span class="ident">buf</span>.<span class="ident">advance_mut</span>(<span class="ident">n</span>); }
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="ident">n</span>))
+ }
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> <span class="op">=></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">e</span>),
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> <span class="ident">AsyncWrite</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="prelude-val">Ok</span>(().<span class="ident">into</span>())
+ }
+
+ <span class="kw">fn</span> <span class="ident">write_buf</span><span class="op"><</span><span class="ident">B</span>: <span class="ident">Buf</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">B</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">usize</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_write</span>(<span class="self">self</span>) {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> {
+ <span class="comment">// The `IoVec` type can't have a zero-length size, so create a dummy</span>
+ <span class="comment">// version from a 1-length slice which we'll overwrite with the</span>
+ <span class="comment">// `bytes_vec` method.</span>
+ <span class="kw">static</span> <span class="ident">DUMMY</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>] <span class="op">=</span> <span class="kw-2">&</span>[<span class="number">0</span>];
+ <span class="kw">let</span> <span class="ident">iovec</span> <span class="op">=</span> <span class="op"><</span><span class="kw-2">&</span><span class="ident">IoVec</span><span class="op">></span>::<span class="ident">from</span>(<span class="ident">DUMMY</span>);
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bufs</span> <span class="op">=</span> [<span class="ident">iovec</span>; <span class="number">64</span>];
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">bytes_vec</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">bufs</span>);
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">write_bufs</span>(<span class="kw-2">&</span><span class="ident">bufs</span>[..<span class="ident">n</span>])
+ };
+ <span class="kw">match</span> <span class="ident">r</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> {
+ <span class="ident">buf</span>.<span class="ident">advance</span>(<span class="ident">n</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="ident">n</span>))
+ }
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> <span class="op">=></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_write</span>();
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">e</span>),
+ }
+ }
+}
+
+<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span><span class="op">></span> ::<span class="ident">io</span>::<span class="ident">Io</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_read</span>(<span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">TcpStream</span><span class="op">></span>::<span class="ident">poll_write</span>(<span class="self">self</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">fmt</span>(<span class="ident">f</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">TcpStreamNew</span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">TcpStream</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">TcpStream</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">poll</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">TcpStreamNewState</span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">TcpStream</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="ident">TcpStream</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ {
+ <span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
+ <span class="ident">TcpStreamNewState</span>::<span class="ident">Waiting</span>(<span class="kw-2">ref</span> <span class="ident">s</span>) <span class="op">=></span> <span class="ident">s</span>,
+ <span class="ident">TcpStreamNewState</span>::<span class="ident">Error</span>(_) <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">e</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="self">self</span>, <span class="ident">TcpStreamNewState</span>::<span class="ident">Empty</span>) {
+ <span class="ident">TcpStreamNewState</span>::<span class="ident">Error</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="ident">e</span>,
+ _ <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(),
+ };
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ <span class="ident">TcpStreamNewState</span>::<span class="ident">Empty</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"can't poll TCP stream twice"</span>),
+ };
+
+ <span class="comment">// Once we've connected, wait for the stream to be writable as</span>
+ <span class="comment">// that's when the actual connection has been initiated. Once we're</span>
+ <span class="comment">// writable we check for `take_socket_error` to see if the connect</span>
+ <span class="comment">// actually hit an error or not.</span>
+ <span class="comment">//</span>
+ <span class="comment">// If all that succeeded then we ship everything on up.</span>
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="ident">stream</span>.<span class="ident">io</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">e</span>) <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">stream</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">take_error</span>()) {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ }
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="self">self</span>, <span class="ident">TcpStreamNewState</span>::<span class="ident">Empty</span>) {
+ <span class="ident">TcpStreamNewState</span>::<span class="ident">Waiting</span>(<span class="ident">stream</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="ident">stream</span>)),
+ _ <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(),
+ }
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">unix</span>, <span class="ident">not</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"fuchsia"</span>)))]</span>
+<span class="kw">mod</span> <span class="ident">sys</span> {
+ <span class="kw">use</span> <span class="ident">std</span>::<span class="ident">os</span>::<span class="ident">unix</span>::<span class="ident">prelude</span>::<span class="kw-2">*</span>;
+ <span class="kw">use</span> <span class="kw">super</span>::{<span class="ident">TcpStream</span>, <span class="ident">TcpListener</span>};
+
+ <span class="kw">impl</span> <span class="ident">AsRawFd</span> <span class="kw">for</span> <span class="ident">TcpStream</span> {
+ <span class="kw">fn</span> <span class="ident">as_raw_fd</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">RawFd</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">as_raw_fd</span>()
+ }
+ }
+
+ <span class="kw">impl</span> <span class="ident">AsRawFd</span> <span class="kw">for</span> <span class="ident">TcpListener</span> {
+ <span class="kw">fn</span> <span class="ident">as_raw_fd</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">RawFd</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">as_raw_fd</span>()
+ }
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">windows</span>)]</span>
+<span class="kw">mod</span> <span class="ident">sys</span> {
+ <span class="comment">// TODO: let's land these upstream with mio and then we can add them here.</span>
+ <span class="comment">//</span>
+ <span class="comment">// use std::os::windows::prelude::*;</span>
+ <span class="comment">// use super::{TcpStream, TcpListener};</span>
+ <span class="comment">//</span>
+ <span class="comment">// impl AsRawHandle for TcpStream {</span>
+ <span class="comment">// fn as_raw_handle(&self) -> RawHandle {</span>
+ <span class="comment">// self.io.get_ref().as_raw_handle()</span>
+ <span class="comment">// }</span>
+ <span class="comment">// }</span>
+ <span class="comment">//</span>
+ <span class="comment">// impl AsRawHandle for TcpListener {</span>
+ <span class="comment">// fn as_raw_handle(&self) -> RawHandle {</span>
+ <span class="comment">// self.listener.io().as_raw_handle()</span>
+ <span class="comment">// }</span>
+ <span class="comment">// }</span>
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/net/udp/frame.rs.html b/src/tokio_core/net/udp/frame.rs.html
new file mode 100644
index 0000000..24ad767
--- /dev/null
+++ b/src/tokio_core/net/udp/frame.rs.html
@@ -0,0 +1,459 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/net/udp/frame.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>frame.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../../main.css" id="themeStyle">
+ <script src="../../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">net</span>::{<span class="ident">SocketAddr</span>, <span class="ident">Ipv4Addr</span>, <span class="ident">SocketAddrV4</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Async</span>, <span class="ident">Poll</span>, <span class="ident">Stream</span>, <span class="ident">Sink</span>, <span class="ident">StartSend</span>, <span class="ident">AsyncSink</span>};
+
+<span class="kw">use</span> <span class="ident">net</span>::<span class="ident">UdpSocket</span>;
+
+<span class="doccomment">/// Encoding of frames via buffers.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This trait is used when constructing an instance of `UdpFramed` and provides</span>
+<span class="doccomment">/// the `In` and `Out` types which are decoded and encoded from the socket,</span>
+<span class="doccomment">/// respectively.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Because UDP is a connectionless protocol, the `decode` method receives the</span>
+<span class="doccomment">/// address where data came from and the `encode` method is also responsible for</span>
+<span class="doccomment">/// determining the remote host to which the datagram should be sent</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The trait itself is implemented on a type that can track state for decoding</span>
+<span class="doccomment">/// or encoding, which is particularly useful for streaming parsers. In many</span>
+<span class="doccomment">/// cases, though, this type will simply be a unit struct (e.g. `struct</span>
+<span class="doccomment">/// HttpCodec`).</span>
+<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">UdpCodec</span> {
+ <span class="doccomment">/// The type of decoded frames.</span>
+ <span class="kw">type</span> <span class="ident">In</span>;
+
+ <span class="doccomment">/// The type of frames to be encoded.</span>
+ <span class="kw">type</span> <span class="ident">Out</span>;
+
+ <span class="doccomment">/// Attempts to decode a frame from the provided buffer of bytes.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method is called by `UdpFramed` on a single datagram which has been</span>
+ <span class="doccomment">/// read from a socket. The `buf` argument contains the data that was</span>
+ <span class="doccomment">/// received from the remote address, and `src` is the address the data came</span>
+ <span class="doccomment">/// from. Note that typically this method should require the entire contents</span>
+ <span class="doccomment">/// of `buf` to be valid or otherwise return an error with trailing data.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Finally, if the bytes in the buffer are malformed then an error is</span>
+ <span class="doccomment">/// returned indicating why. This informs `Framed` that the stream is now</span>
+ <span class="doccomment">/// corrupt and should be terminated.</span>
+ <span class="kw">fn</span> <span class="ident">decode</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">src</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">In</span><span class="op">></span>;
+
+ <span class="doccomment">/// Encodes a frame into the buffer provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will encode `msg` into the byte buffer provided by `buf`.</span>
+ <span class="doccomment">/// The `buf` provided is an internal buffer of the `Framed` instance and</span>
+ <span class="doccomment">/// will be written out when possible.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The encode method also determines the destination to which the buffer</span>
+ <span class="doccomment">/// should be directed, which will be returned as a `SocketAddr`.</span>
+ <span class="kw">fn</span> <span class="ident">encode</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">msg</span>: <span class="self">Self</span>::<span class="ident">Out</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>) <span class="op">-></span> <span class="ident">SocketAddr</span>;
+}
+
+<span class="doccomment">/// A unified `Stream` and `Sink` interface to an underlying `UdpSocket`, using</span>
+<span class="doccomment">/// the `UdpCodec` trait to encode and decode frames.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// You can acquire a `UdpFramed` instance by using the `UdpSocket::framed`</span>
+<span class="doccomment">/// adapter.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"sinks do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="ident">socket</span>: <span class="ident">UdpSocket</span>,
+ <span class="ident">codec</span>: <span class="ident">C</span>,
+ <span class="ident">rd</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+ <span class="ident">wr</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>,
+ <span class="ident">out_addr</span>: <span class="ident">SocketAddr</span>,
+ <span class="ident">flushed</span>: <span class="ident">bool</span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">C</span>: <span class="ident">UdpCodec</span><span class="op">></span> <span class="ident">Stream</span> <span class="kw">for</span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">C</span>::<span class="ident">In</span>;
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">C</span>::<span class="ident">In</span><span class="op">></span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">let</span> (<span class="ident">n</span>, <span class="ident">addr</span>) <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">socket</span>.<span class="ident">recv_from</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">rd</span>));
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"received {} bytes, decoding"</span>, <span class="ident">n</span>);
+ <span class="kw">let</span> <span class="ident">frame</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">codec</span>.<span class="ident">decode</span>(<span class="kw-2">&</span><span class="ident">addr</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">rd</span>[..<span class="ident">n</span>]));
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"frame decoded from buffer"</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(<span class="ident">frame</span>)))
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">C</span>: <span class="ident">UdpCodec</span><span class="op">></span> <span class="ident">Sink</span> <span class="kw">for</span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="kw">type</span> <span class="ident">SinkItem</span> <span class="op">=</span> <span class="ident">C</span>::<span class="ident">Out</span>;
+ <span class="kw">type</span> <span class="ident">SinkError</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">start_send</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">item</span>: <span class="ident">C</span>::<span class="ident">Out</span>) <span class="op">-></span> <span class="ident">StartSend</span><span class="op"><</span><span class="ident">C</span>::<span class="ident">Out</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"sending frame"</span>);
+
+ <span class="kw">if</span> <span class="op">!</span><span class="self">self</span>.<span class="ident">flushed</span> {
+ <span class="kw">match</span> <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">poll_complete</span>()) {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(()) <span class="op">=></span> {},
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">AsyncSink</span>::<span class="ident">NotReady</span>(<span class="ident">item</span>)),
+ }
+ }
+
+ <span class="self">self</span>.<span class="ident">out_addr</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">codec</span>.<span class="ident">encode</span>(<span class="ident">item</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">wr</span>);
+ <span class="self">self</span>.<span class="ident">flushed</span> <span class="op">=</span> <span class="bool-val">false</span>;
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"frame encoded; length={}"</span>, <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>());
+
+ <span class="prelude-val">Ok</span>(<span class="ident">AsyncSink</span>::<span class="ident">Ready</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_complete</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">flushed</span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(()))
+ }
+
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"flushing frame; length={}"</span>, <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>());
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">socket</span>.<span class="ident">send_to</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">wr</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">out_addr</span>));
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"written {}"</span>, <span class="ident">n</span>);
+
+ <span class="kw">let</span> <span class="ident">wrote_all</span> <span class="op">=</span> <span class="ident">n</span> <span class="op">==</span> <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">len</span>();
+ <span class="self">self</span>.<span class="ident">wr</span>.<span class="ident">clear</span>();
+ <span class="self">self</span>.<span class="ident">flushed</span> <span class="op">=</span> <span class="bool-val">true</span>;
+
+ <span class="kw">if</span> <span class="ident">wrote_all</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(()))
+ } <span class="kw">else</span> {
+ <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">Other</span>,
+ <span class="string">"failed to write entire datagram to socket"</span>))
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">close</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="macro">try_ready</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">poll_complete</span>());
+ <span class="prelude-val">Ok</span>(().<span class="ident">into</span>())
+ }
+}
+
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span><span class="op"><</span><span class="ident">C</span>: <span class="ident">UdpCodec</span><span class="op">></span>(<span class="ident">socket</span>: <span class="ident">UdpSocket</span>, <span class="ident">codec</span>: <span class="ident">C</span>) <span class="op">-></span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="ident">UdpFramed</span> {
+ <span class="ident">socket</span>: <span class="ident">socket</span>,
+ <span class="ident">codec</span>: <span class="ident">codec</span>,
+ <span class="ident">out_addr</span>: <span class="ident">SocketAddr</span>::<span class="ident">V4</span>(<span class="ident">SocketAddrV4</span>::<span class="ident">new</span>(<span class="ident">Ipv4Addr</span>::<span class="ident">new</span>(<span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>), <span class="number">0</span>)),
+ <span class="ident">rd</span>: <span class="macro">vec</span><span class="macro">!</span>[<span class="number">0</span>; <span class="number">64</span> <span class="op">*</span> <span class="number">1024</span>],
+ <span class="ident">wr</span>: <span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="number">8</span> <span class="op">*</span> <span class="number">1024</span>),
+ <span class="ident">flushed</span>: <span class="bool-val">true</span>,
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="doccomment">/// Returns a reference to the underlying I/O stream wrapped by `Framed`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">UdpSocket</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">socket</span>
+ }
+
+ <span class="doccomment">/// Returns a mutable reference to the underlying I/O stream wrapped by</span>
+ <span class="doccomment">/// `Framed`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">UdpSocket</span> {
+ <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">socket</span>
+ }
+
+ <span class="doccomment">/// Consumes the `Framed`, returning its underlying I/O stream.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that care should be taken to not tamper with the underlying stream</span>
+ <span class="doccomment">/// of data coming in as it may corrupt the stream of frames otherwise being</span>
+ <span class="doccomment">/// worked with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">into_inner</span>(<span class="self">self</span>) <span class="op">-></span> <span class="ident">UdpSocket</span> {
+ <span class="self">self</span>.<span class="ident">socket</span>
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../../main.js"></script>
+ <script defer src="../../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/net/udp/mod.rs.html b/src/tokio_core/net/udp/mod.rs.html
new file mode 100644
index 0000000..b07de1b
--- /dev/null
+++ b/src/tokio_core/net/udp/mod.rs.html
@@ -0,0 +1,1049 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/net/udp/mod.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>mod.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../../main.css" id="themeStyle">
+ <script src="../../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+<span id="410">410</span>
+<span id="411">411</span>
+<span id="412">412</span>
+<span id="413">413</span>
+<span id="414">414</span>
+<span id="415">415</span>
+<span id="416">416</span>
+<span id="417">417</span>
+<span id="418">418</span>
+<span id="419">419</span>
+<span id="420">420</span>
+<span id="421">421</span>
+<span id="422">422</span>
+<span id="423">423</span>
+<span id="424">424</span>
+<span id="425">425</span>
+<span id="426">426</span>
+<span id="427">427</span>
+<span id="428">428</span>
+<span id="429">429</span>
+<span id="430">430</span>
+<span id="431">431</span>
+<span id="432">432</span>
+<span id="433">433</span>
+<span id="434">434</span>
+<span id="435">435</span>
+<span id="436">436</span>
+<span id="437">437</span>
+<span id="438">438</span>
+<span id="439">439</span>
+<span id="440">440</span>
+<span id="441">441</span>
+<span id="442">442</span>
+<span id="443">443</span>
+<span id="444">444</span>
+<span id="445">445</span>
+<span id="446">446</span>
+<span id="447">447</span>
+<span id="448">448</span>
+<span id="449">449</span>
+<span id="450">450</span>
+<span id="451">451</span>
+<span id="452">452</span>
+<span id="453">453</span>
+<span id="454">454</span>
+<span id="455">455</span>
+<span id="456">456</span>
+<span id="457">457</span>
+<span id="458">458</span>
+<span id="459">459</span>
+<span id="460">460</span>
+<span id="461">461</span>
+<span id="462">462</span>
+<span id="463">463</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">net</span>::{<span class="self">self</span>, <span class="ident">SocketAddr</span>, <span class="ident">Ipv4Addr</span>, <span class="ident">Ipv6Addr</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Async</span>, <span class="ident">Future</span>, <span class="ident">Poll</span>};
+<span class="kw">use</span> <span class="ident">mio</span>;
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Handle</span>, <span class="ident">PollEvented</span>};
+
+<span class="doccomment">/// An I/O object representing a UDP socket.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">UdpSocket</span> {
+ <span class="ident">io</span>: <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">UdpSocket</span><span class="op">></span>,
+}
+
+<span class="kw">mod</span> <span class="ident">frame</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">frame</span>::{<span class="ident">UdpFramed</span>, <span class="ident">UdpCodec</span>};
+
+<span class="kw">impl</span> <span class="ident">UdpSocket</span> {
+ <span class="doccomment">/// Create a new UDP socket bound to the specified address.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will create a new UDP socket and attempt to bind it to the</span>
+ <span class="doccomment">/// `addr` provided. If the result is `Ok`, the socket has successfully bound.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">bind</span>(<span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">UdpSocket</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">udp</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">UdpSocket</span>::<span class="ident">bind</span>(<span class="ident">addr</span>));
+ <span class="ident">UdpSocket</span>::<span class="ident">new</span>(<span class="ident">udp</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">socket</span>: <span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">UdpSocket</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">UdpSocket</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">io</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">PollEvented</span>::<span class="ident">new</span>(<span class="ident">socket</span>, <span class="ident">handle</span>));
+ <span class="prelude-val">Ok</span>(<span class="ident">UdpSocket</span> { <span class="ident">io</span>: <span class="ident">io</span> })
+ }
+
+ <span class="doccomment">/// Creates a new `UdpSocket` from the previously bound socket provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The socket given will be registered with the event loop that `handle` is</span>
+ <span class="doccomment">/// associated with. This function requires that `socket` has previously</span>
+ <span class="doccomment">/// been bound to an address to work correctly.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This can be used in conjunction with net2's `UdpBuilder` interface to</span>
+ <span class="doccomment">/// configure a socket before it's handed off, such as setting options like</span>
+ <span class="doccomment">/// `reuse_address` or binding to multiple addresses.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">from_socket</span>(<span class="ident">socket</span>: <span class="ident">net</span>::<span class="ident">UdpSocket</span>,
+ <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">UdpSocket</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">udp</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">net</span>::<span class="ident">UdpSocket</span>::<span class="ident">from_socket</span>(<span class="ident">socket</span>));
+ <span class="ident">UdpSocket</span>::<span class="ident">new</span>(<span class="ident">udp</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Provides a `Stream` and `Sink` interface for reading and writing to this</span>
+ <span class="doccomment">/// `UdpSocket` object, using the provided `UdpCodec` to read and write the</span>
+ <span class="doccomment">/// raw data.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Raw UDP sockets work with datagrams, but higher-level code usually</span>
+ <span class="doccomment">/// wants to batch these into meaningful chunks, called "frames". This</span>
+ <span class="doccomment">/// method layers framing on top of this socket by using the `UdpCodec`</span>
+ <span class="doccomment">/// trait to handle encoding and decoding of messages frames. Note that</span>
+ <span class="doccomment">/// the incoming and outgoing frame types may be distinct.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function returns a *single* object that is both `Stream` and</span>
+ <span class="doccomment">/// `Sink`; grouping this into a single object is often useful for layering</span>
+ <span class="doccomment">/// things which require both read and write access to the underlying</span>
+ <span class="doccomment">/// object.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If you want to work more directly with the streams and sink, consider</span>
+ <span class="doccomment">/// calling `split` on the `UdpFramed` returned by this method, which will</span>
+ <span class="doccomment">/// break them into separate objects, allowing them to interact more</span>
+ <span class="doccomment">/// easily.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">framed</span><span class="op"><</span><span class="ident">C</span>: <span class="ident">UdpCodec</span><span class="op">></span>(<span class="self">self</span>, <span class="ident">codec</span>: <span class="ident">C</span>) <span class="op">-></span> <span class="ident">UdpFramed</span><span class="op"><</span><span class="ident">C</span><span class="op">></span> {
+ <span class="ident">frame</span>::<span class="ident">new</span>(<span class="self">self</span>, <span class="ident">codec</span>)
+ }
+
+ <span class="doccomment">/// Returns the local address that this stream is bound to.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">local_addr</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">SocketAddr</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">local_addr</span>()
+ }
+
+ <span class="doccomment">/// Connects the UDP socket setting the default destination for send() and</span>
+ <span class="doccomment">/// limiting packets that are read via recv from the address specified in addr.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">connect</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">addr</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">connect</span>(<span class="kw-2">*</span><span class="ident">addr</span>)
+ }
+
+ <span class="doccomment">/// Sends data on the socket to the address previously bound via connect().</span>
+ <span class="doccomment">/// On success, returns the number of bytes written.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">send</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">send</span>(<span class="ident">buf</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">n</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_write</span>();
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ }
+ }
+
+ <span class="doccomment">/// Receives data from the socket previously bound with connect().</span>
+ <span class="doccomment">/// On success, returns the number of bytes read.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">recv</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">recv</span>(<span class="ident">buf</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">n</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ }
+ }
+
+ <span class="doccomment">/// Test whether this socket is ready to be read or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If the socket is *not* readable then the current task is scheduled to</span>
+ <span class="doccomment">/// get a notification when the socket does become readable. That is, this</span>
+ <span class="doccomment">/// is only suitable for calling in a `Future::poll` method and will</span>
+ <span class="doccomment">/// automatically handle ensuring a retry once the socket is readable again.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>()
+ }
+
+ <span class="doccomment">/// Test whether this socket is ready to be written to or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If the socket is *not* writable then the current task is scheduled to</span>
+ <span class="doccomment">/// get a notification when the socket does become writable. That is, this</span>
+ <span class="doccomment">/// is only suitable for calling in a `Future::poll` method and will</span>
+ <span class="doccomment">/// automatically handle ensuring a retry once the socket is writable again.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_write</span>()
+ }
+
+ <span class="doccomment">/// Sends data on the socket to the given address. On success, returns the</span>
+ <span class="doccomment">/// number of bytes written.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Address type can be any implementer of `ToSocketAddrs` trait. See its</span>
+ <span class="doccomment">/// documentation for concrete examples.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">send_to</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>], <span class="ident">target</span>: <span class="kw-2">&</span><span class="ident">SocketAddr</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">send_to</span>(<span class="ident">buf</span>, <span class="ident">target</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">n</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_write</span>();
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ }
+ }
+
+ <span class="doccomment">/// Creates a future that will write the entire contents of the buffer</span>
+ <span class="doccomment">/// `buf` provided as a datagram to this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The returned future will return after data has been written to the</span>
+ <span class="doccomment">/// outbound socket. The future will resolve to the stream as well as the</span>
+ <span class="doccomment">/// buffer (for reuse if needed).</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Any error which happens during writing will cause both the stream and</span>
+ <span class="doccomment">/// the buffer to get destroyed. Note that failure to write the entire</span>
+ <span class="doccomment">/// buffer is considered an error for the purposes of sending a datagram.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `buf` parameter here only requires the `AsRef<[u8]>` trait, which</span>
+ <span class="doccomment">/// should be broadly applicable to accepting data which can be converted</span>
+ <span class="doccomment">/// to a slice. The `Window` struct is also available in this crate to</span>
+ <span class="doccomment">/// provide a different window into a slice if necessary.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">send_dgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="self">self</span>, <span class="ident">buf</span>: <span class="ident">T</span>, <span class="ident">addr</span>: <span class="ident">SocketAddr</span>) <span class="op">-></span> <span class="ident">SendDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+ {
+ <span class="ident">SendDgram</span>(<span class="prelude-val">Some</span>((<span class="self">self</span>, <span class="ident">buf</span>, <span class="ident">addr</span>)))
+ }
+
+ <span class="doccomment">/// Receives data from the socket. On success, returns the number of bytes</span>
+ <span class="doccomment">/// read and the address from whence the data came.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">recv_from</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>(<span class="ident">usize</span>, <span class="ident">SocketAddr</span>)<span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">recv_from</span>(<span class="ident">buf</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">n</span>),
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">need_read</span>();
+ }
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>)
+ }
+ }
+ }
+
+ <span class="doccomment">/// Creates a future that receive a datagram to be written to the buffer</span>
+ <span class="doccomment">/// provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The returned future will return after a datagram has been received on</span>
+ <span class="doccomment">/// this socket. The future will resolve to the socket, the buffer, the</span>
+ <span class="doccomment">/// amount of data read, and the address the data was received from.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// An error during reading will cause the socket and buffer to get</span>
+ <span class="doccomment">/// destroyed and the socket will be returned.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `buf` parameter here only requires the `AsMut<[u8]>` trait, which</span>
+ <span class="doccomment">/// should be broadly applicable to accepting data which can be converted</span>
+ <span class="doccomment">/// to a slice. The `Window` struct is also available in this crate to</span>
+ <span class="doccomment">/// provide a different window into a slice if necessary.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">recv_dgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="self">self</span>, <span class="ident">buf</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">RecvDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+ {
+ <span class="ident">RecvDgram</span>(<span class="prelude-val">Some</span>((<span class="self">self</span>, <span class="ident">buf</span>)))
+ }
+
+ <span class="doccomment">/// Gets the value of the `SO_BROADCAST` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`set_broadcast`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_broadcast</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">broadcast</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">broadcast</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `SO_BROADCAST` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// When enabled, this socket is allowed to send packets to a broadcast</span>
+ <span class="doccomment">/// address.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_broadcast</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">on</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_broadcast</span>(<span class="ident">on</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IP_MULTICAST_LOOP` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`set_multicast_loop_v4`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_multicast_loop_v4</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">multicast_loop_v4</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">multicast_loop_v4</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `IP_MULTICAST_LOOP` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If enabled, multicast packets will be looped back to the local socket.</span>
+ <span class="doccomment">/// Note that this may not have any affect on IPv6 sockets.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_multicast_loop_v4</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">on</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_multicast_loop_v4</span>(<span class="ident">on</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IP_MULTICAST_TTL` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`set_multicast_ttl_v4`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_multicast_ttl_v4</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">multicast_ttl_v4</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">multicast_ttl_v4</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `IP_MULTICAST_TTL` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Indicates the time-to-live value of outgoing multicast packets for</span>
+ <span class="doccomment">/// this socket. The default value is 1 which means that multicast packets</span>
+ <span class="doccomment">/// don't leave the local network unless explicitly requested.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that this may not have any affect on IPv6 sockets.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_multicast_ttl_v4</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">ttl</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_multicast_ttl_v4</span>(<span class="ident">ttl</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`set_multicast_loop_v6`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_multicast_loop_v6</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">multicast_loop_v6</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">multicast_loop_v6</span>()
+ }
+
+ <span class="doccomment">/// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Controls whether this socket sees the multicast packets it sends itself.</span>
+ <span class="doccomment">/// Note that this may not have any affect on IPv4 sockets.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_multicast_loop_v6</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">on</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_multicast_loop_v6</span>(<span class="ident">on</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IP_TTL` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_ttl`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_ttl</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ttl</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">ttl</span>()
+ }
+
+ <span class="doccomment">/// Sets the value for the `IP_TTL` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This value sets the time-to-live field that is used in every packet sent</span>
+ <span class="doccomment">/// from this socket.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_ttl</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">ttl</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_ttl</span>(<span class="ident">ttl</span>)
+ }
+
+ <span class="doccomment">/// Executes an operation of the `IP_ADD_MEMBERSHIP` type.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function specifies a new multicast group for this socket to join.</span>
+ <span class="doccomment">/// The address must be a valid multicast address, and `interface` is the</span>
+ <span class="doccomment">/// address of the local interface with which the system should join the</span>
+ <span class="doccomment">/// multicast group. If it's equal to `INADDR_ANY` then an appropriate</span>
+ <span class="doccomment">/// interface is chosen by the system.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">join_multicast_v4</span>(<span class="kw-2">&</span><span class="self">self</span>,
+ <span class="ident">multiaddr</span>: <span class="kw-2">&</span><span class="ident">Ipv4Addr</span>,
+ <span class="ident">interface</span>: <span class="kw-2">&</span><span class="ident">Ipv4Addr</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">join_multicast_v4</span>(<span class="ident">multiaddr</span>, <span class="ident">interface</span>)
+ }
+
+ <span class="doccomment">/// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function specifies a new multicast group for this socket to join.</span>
+ <span class="doccomment">/// The address must be a valid multicast address, and `interface` is the</span>
+ <span class="doccomment">/// index of the interface to join/leave (or 0 to indicate any interface).</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">join_multicast_v6</span>(<span class="kw-2">&</span><span class="self">self</span>,
+ <span class="ident">multiaddr</span>: <span class="kw-2">&</span><span class="ident">Ipv6Addr</span>,
+ <span class="ident">interface</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">join_multicast_v6</span>(<span class="ident">multiaddr</span>, <span class="ident">interface</span>)
+ }
+
+ <span class="doccomment">/// Executes an operation of the `IP_DROP_MEMBERSHIP` type.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`join_multicast_v4`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.join_multicast_v4</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">leave_multicast_v4</span>(<span class="kw-2">&</span><span class="self">self</span>,
+ <span class="ident">multiaddr</span>: <span class="kw-2">&</span><span class="ident">Ipv4Addr</span>,
+ <span class="ident">interface</span>: <span class="kw-2">&</span><span class="ident">Ipv4Addr</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">leave_multicast_v4</span>(<span class="ident">multiaddr</span>, <span class="ident">interface</span>)
+ }
+
+ <span class="doccomment">/// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see</span>
+ <span class="doccomment">/// [`join_multicast_v6`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.join_multicast_v6</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">leave_multicast_v6</span>(<span class="kw-2">&</span><span class="self">self</span>,
+ <span class="ident">multiaddr</span>: <span class="kw-2">&</span><span class="ident">Ipv6Addr</span>,
+ <span class="ident">interface</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">leave_multicast_v6</span>(<span class="ident">multiaddr</span>, <span class="ident">interface</span>)
+ }
+
+ <span class="doccomment">/// Sets the value for the `IPV6_V6ONLY` option on this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `true` then the socket is restricted to sending and</span>
+ <span class="doccomment">/// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications</span>
+ <span class="doccomment">/// can bind the same port at the same time.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this is set to `false` then the socket can be used to send and</span>
+ <span class="doccomment">/// receive packets from an IPv4-mapped IPv6 address.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">only_v6</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">set_only_v6</span>(<span class="ident">only_v6</span>)
+ }
+
+ <span class="doccomment">/// Gets the value of the `IPV6_V6ONLY` option for this socket.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// For more information about this option, see [`set_only_v6`][link].</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// [link]: #method.set_only_v6</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">only_v6</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">only_v6</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">UdpSocket</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">fmt</span>(<span class="ident">f</span>)
+ }
+}
+
+<span class="doccomment">/// A future used to write the entire contents of some data to a UDP socket.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This is created by the `UdpSocket::send_dgram` method.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">SendDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="prelude-ty">Option</span><span class="op"><</span>(<span class="ident">UdpSocket</span>, <span class="ident">T</span>, <span class="ident">SocketAddr</span>)<span class="op">></span>);
+
+<span class="kw">fn</span> <span class="ident">incomplete_write</span>(<span class="ident">reason</span>: <span class="kw-2">&</span><span class="ident">str</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="ident">Error</span> {
+ <span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">Other</span>, <span class="ident">reason</span>)
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">SendDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">T</span>: <span class="ident">AsRef</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">UdpSocket</span>, <span class="ident">T</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(<span class="ident">UdpSocket</span>, <span class="ident">T</span>), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ {
+ <span class="kw">let</span> (<span class="kw-2">ref</span> <span class="ident">sock</span>, <span class="kw-2">ref</span> <span class="ident">buf</span>, <span class="kw-2">ref</span> <span class="ident">addr</span>) <span class="op">=</span>
+ <span class="kw-2">*</span><span class="self">self</span>.<span class="number">0</span>.<span class="ident">as_ref</span>().<span class="ident">expect</span>(<span class="string">"SendDgram polled after completion"</span>);
+ <span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">sock</span>.<span class="ident">send_to</span>(<span class="ident">buf</span>.<span class="ident">as_ref</span>(), <span class="ident">addr</span>));
+ <span class="kw">if</span> <span class="ident">n</span> <span class="op">!=</span> <span class="ident">buf</span>.<span class="ident">as_ref</span>().<span class="ident">len</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">incomplete_write</span>(<span class="string">"failed to send entire message \
+ in datagram"</span>))
+ }
+ }
+
+ <span class="kw">let</span> (<span class="ident">sock</span>, <span class="ident">buf</span>, <span class="ident">_addr</span>) <span class="op">=</span> <span class="self">self</span>.<span class="number">0</span>.<span class="ident">take</span>().<span class="ident">unwrap</span>();
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>((<span class="ident">sock</span>, <span class="ident">buf</span>)))
+ }
+}
+
+<span class="doccomment">/// A future used to receive a datagram from a UDP socket.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This is created by the `UdpSocket::recv_dgram` method.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">RecvDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="prelude-ty">Option</span><span class="op"><</span>(<span class="ident">UdpSocket</span>, <span class="ident">T</span>)<span class="op">></span>);
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">RecvDgram</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">T</span>: <span class="ident">AsMut</span><span class="op"><</span>[<span class="ident">u8</span>]<span class="op">></span>,
+{
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">UdpSocket</span>, <span class="ident">T</span>, <span class="ident">usize</span>, <span class="ident">SocketAddr</span>);
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="self">Self</span>::<span class="ident">Item</span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">let</span> (<span class="ident">n</span>, <span class="ident">addr</span>) <span class="op">=</span> {
+ <span class="kw">let</span> (<span class="kw-2">ref</span> <span class="ident">socket</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">buf</span>) <span class="op">=</span>
+ <span class="kw-2">*</span><span class="self">self</span>.<span class="number">0</span>.<span class="ident">as_mut</span>().<span class="ident">expect</span>(<span class="string">"RecvDgram polled after completion"</span>);
+
+ <span class="macro">try_nb</span><span class="macro">!</span>(<span class="ident">socket</span>.<span class="ident">recv_from</span>(<span class="ident">buf</span>.<span class="ident">as_mut</span>()))
+ };
+
+ <span class="kw">let</span> (<span class="ident">socket</span>, <span class="ident">buf</span>) <span class="op">=</span> <span class="self">self</span>.<span class="number">0</span>.<span class="ident">take</span>().<span class="ident">unwrap</span>();
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>((<span class="ident">socket</span>, <span class="ident">buf</span>, <span class="ident">n</span>, <span class="ident">addr</span>)))
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">unix</span>, <span class="ident">not</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"fuchsia"</span>)))]</span>
+<span class="kw">mod</span> <span class="ident">sys</span> {
+ <span class="kw">use</span> <span class="ident">std</span>::<span class="ident">os</span>::<span class="ident">unix</span>::<span class="ident">prelude</span>::<span class="kw-2">*</span>;
+ <span class="kw">use</span> <span class="kw">super</span>::<span class="ident">UdpSocket</span>;
+
+ <span class="kw">impl</span> <span class="ident">AsRawFd</span> <span class="kw">for</span> <span class="ident">UdpSocket</span> {
+ <span class="kw">fn</span> <span class="ident">as_raw_fd</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">RawFd</span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">get_ref</span>().<span class="ident">as_raw_fd</span>()
+ }
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">windows</span>)]</span>
+<span class="kw">mod</span> <span class="ident">sys</span> {
+ <span class="comment">// TODO: let's land these upstream with mio and then we can add them here.</span>
+ <span class="comment">//</span>
+ <span class="comment">// use std::os::windows::prelude::*;</span>
+ <span class="comment">// use super::UdpSocket;</span>
+ <span class="comment">//</span>
+ <span class="comment">// impl AsRawHandle for UdpSocket {</span>
+ <span class="comment">// fn as_raw_handle(&self) -> RawHandle {</span>
+ <span class="comment">// self.io.get_ref().as_raw_handle()</span>
+ <span class="comment">// }</span>
+ <span class="comment">// }</span>
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../../main.js"></script>
+ <script defer src="../../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/interval.rs.html b/src/tokio_core/reactor/interval.rs.html
new file mode 100644
index 0000000..90c6450
--- /dev/null
+++ b/src/tokio_core/reactor/interval.rs.html
@@ -0,0 +1,523 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/interval.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>interval.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! Support for creating futures that represent intervals.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This module contains the `Interval` type which is a stream that will</span>
+<span class="doccomment">//! resolve at a fixed intervals in future</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::{<span class="ident">Duration</span>, <span class="ident">Instant</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Poll</span>, <span class="ident">Async</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">stream</span>::{<span class="ident">Stream</span>};
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Remote</span>, <span class="ident">Handle</span>};
+<span class="kw">use</span> <span class="ident">reactor</span>::<span class="ident">timeout_token</span>::<span class="ident">TimeoutToken</span>;
+
+<span class="doccomment">/// A stream representing notifications at fixed interval</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Intervals are created through the `Interval::new` or</span>
+<span class="doccomment">/// `Interval::new_at` methods indicating when a first notification</span>
+<span class="doccomment">/// should be triggered and when it will be repeated.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Note that timeouts are not intended for high resolution timers, but rather</span>
+<span class="doccomment">/// they will likely fire some granularity after the exact instant that they're</span>
+<span class="doccomment">/// otherwise indicated to fire at.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"streams do nothing unless polled"</span>]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Interval</span> {
+ <span class="ident">token</span>: <span class="ident">TimeoutToken</span>,
+ <span class="ident">next</span>: <span class="ident">Instant</span>,
+ <span class="ident">interval</span>: <span class="ident">Duration</span>,
+ <span class="ident">handle</span>: <span class="ident">Remote</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">Interval</span> {
+ <span class="doccomment">/// Creates a new interval which will fire at `dur` time into the future,</span>
+ <span class="doccomment">/// and will repeat every `dur` interval after</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will return a future that will resolve to the actual</span>
+ <span class="doccomment">/// interval object. The interval object itself is then a stream which will</span>
+ <span class="doccomment">/// be set to fire at the specified intervals</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">dur</span>: <span class="ident">Duration</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">Interval</span><span class="op">></span> {
+ <span class="ident">Interval</span>::<span class="ident">new_at</span>(<span class="ident">Instant</span>::<span class="ident">now</span>() <span class="op">+</span> <span class="ident">dur</span>, <span class="ident">dur</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Creates a new interval which will fire at the time specified by `at`,</span>
+ <span class="doccomment">/// and then will repeat every `dur` interval after</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will return a future that will resolve to the actual</span>
+ <span class="doccomment">/// timeout object. The timeout object itself is then a future which will be</span>
+ <span class="doccomment">/// set to fire at the specified point in the future.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new_at</span>(<span class="ident">at</span>: <span class="ident">Instant</span>, <span class="ident">dur</span>: <span class="ident">Duration</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>)
+ <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">Interval</span><span class="op">></span>
+ {
+ <span class="prelude-val">Ok</span>(<span class="ident">Interval</span> {
+ <span class="ident">token</span>: <span class="macro">try</span><span class="macro">!</span>(<span class="ident">TimeoutToken</span>::<span class="ident">new</span>(<span class="ident">at</span>, <span class="kw-2">&</span><span class="ident">handle</span>)),
+ <span class="ident">next</span>: <span class="ident">at</span>,
+ <span class="ident">interval</span>: <span class="ident">dur</span>,
+ <span class="ident">handle</span>: <span class="ident">handle</span>.<span class="ident">remote</span>().<span class="ident">clone</span>(),
+ })
+ }
+
+ <span class="doccomment">/// Polls this `Interval` instance to see if it's elapsed, assuming the</span>
+ <span class="doccomment">/// current time is specified by `now`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `Future::poll` implementation for `Interval` will call `Instant::now`</span>
+ <span class="doccomment">/// each time it's invoked, but in some contexts this can be a costly</span>
+ <span class="doccomment">/// operation. This method is provided to amortize the cost by avoiding</span>
+ <span class="doccomment">/// usage of `Instant::now`, assuming that it's been called elsewhere.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function takes the assumed current time as the first parameter and</span>
+ <span class="doccomment">/// otherwise functions as this future's `poll` function. This will block a</span>
+ <span class="doccomment">/// task if one isn't already blocked or update a previous one if already</span>
+ <span class="doccomment">/// blocked.</span>
+ <span class="kw">fn</span> <span class="ident">poll_at</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">now</span>: <span class="ident">Instant</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span>()<span class="op">></span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">next</span> <span class="op"><=</span> <span class="ident">now</span> {
+ <span class="self">self</span>.<span class="ident">next</span> <span class="op">=</span> <span class="ident">next_interval</span>(<span class="self">self</span>.<span class="ident">next</span>, <span class="ident">now</span>, <span class="self">self</span>.<span class="ident">interval</span>);
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">reset_timeout</span>(<span class="self">self</span>.<span class="ident">next</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(())))
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">update_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Stream</span> <span class="kw">for</span> <span class="ident">Interval</span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> ();
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span>()<span class="op">></span>, <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="comment">// TODO: is this fast enough?</span>
+ <span class="self">self</span>.<span class="ident">poll_at</span>(<span class="ident">Instant</span>::<span class="ident">now</span>())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Drop</span> <span class="kw">for</span> <span class="ident">Interval</span> {
+ <span class="kw">fn</span> <span class="ident">drop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) {
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">cancel_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ }
+}
+
+<span class="doccomment">/// Converts Duration object to raw nanoseconds if possible</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// This is useful to divide intervals.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// While technically for large duration it's impossible to represent any</span>
+<span class="doccomment">/// duration as nanoseconds, the largest duration we can represent is about</span>
+<span class="doccomment">/// 427_000 years. Large enough for any interval we would use or calculate in</span>
+<span class="doccomment">/// tokio.</span>
+<span class="kw">fn</span> <span class="ident">duration_to_nanos</span>(<span class="ident">dur</span>: <span class="ident">Duration</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u64</span><span class="op">></span> {
+ <span class="ident">dur</span>.<span class="ident">as_secs</span>()
+ .<span class="ident">checked_mul</span>(<span class="number">1_000_000_000</span>)
+ .<span class="ident">and_then</span>(<span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">checked_add</span>(<span class="ident">dur</span>.<span class="ident">subsec_nanos</span>() <span class="kw">as</span> <span class="ident">u64</span>))
+}
+
+<span class="kw">fn</span> <span class="ident">next_interval</span>(<span class="ident">prev</span>: <span class="ident">Instant</span>, <span class="ident">now</span>: <span class="ident">Instant</span>, <span class="ident">interval</span>: <span class="ident">Duration</span>) <span class="op">-></span> <span class="ident">Instant</span> {
+ <span class="kw">let</span> <span class="ident">new</span> <span class="op">=</span> <span class="ident">prev</span> <span class="op">+</span> <span class="ident">interval</span>;
+ <span class="kw">if</span> <span class="ident">new</span> <span class="op">></span> <span class="ident">now</span> {
+ <span class="kw">return</span> <span class="ident">new</span>;
+ } <span class="kw">else</span> {
+ <span class="kw">let</span> <span class="ident">spent_ns</span> <span class="op">=</span> <span class="ident">duration_to_nanos</span>(<span class="ident">now</span>.<span class="ident">duration_since</span>(<span class="ident">prev</span>))
+ .<span class="ident">expect</span>(<span class="string">"interval should be expired"</span>);
+ <span class="kw">let</span> <span class="ident">interval_ns</span> <span class="op">=</span> <span class="ident">duration_to_nanos</span>(<span class="ident">interval</span>)
+ .<span class="ident">expect</span>(<span class="string">"interval is less that 427 thousand years"</span>);
+ <span class="kw">let</span> <span class="ident">mult</span> <span class="op">=</span> <span class="ident">spent_ns</span><span class="op">/</span><span class="ident">interval_ns</span> <span class="op">+</span> <span class="number">1</span>;
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">mult</span> <span class="op"><</span> (<span class="number">1</span> <span class="op"><<</span> <span class="number">32</span>),
+ <span class="string">"can't skip more than 4 billion intervals of {:?} \
+ (trying to skip {})"</span>, <span class="ident">interval</span>, <span class="ident">mult</span>);
+ <span class="kw">return</span> <span class="ident">prev</span> <span class="op">+</span> <span class="ident">interval</span> <span class="op">*</span> (<span class="ident">mult</span> <span class="kw">as</span> <span class="ident">u32</span>);
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">test</span>)]</span>
+<span class="kw">mod</span> <span class="ident">test</span> {
+ <span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::{<span class="ident">Instant</span>, <span class="ident">Duration</span>};
+ <span class="kw">use</span> <span class="kw">super</span>::<span class="ident">next_interval</span>;
+
+ <span class="kw">struct</span> <span class="ident">Timeline</span>(<span class="ident">Instant</span>);
+
+ <span class="kw">impl</span> <span class="ident">Timeline</span> {
+ <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">Timeline</span> {
+ <span class="ident">Timeline</span>(<span class="ident">Instant</span>::<span class="ident">now</span>())
+ }
+ <span class="kw">fn</span> <span class="ident">at</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">millis</span>: <span class="ident">u64</span>) <span class="op">-></span> <span class="ident">Instant</span> {
+ <span class="self">self</span>.<span class="number">0</span> <span class="op">+</span> <span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="ident">millis</span>)
+ }
+ <span class="kw">fn</span> <span class="ident">at_ns</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">sec</span>: <span class="ident">u64</span>, <span class="ident">nanos</span>: <span class="ident">u32</span>) <span class="op">-></span> <span class="ident">Instant</span> {
+ <span class="self">self</span>.<span class="number">0</span> <span class="op">+</span> <span class="ident">Duration</span>::<span class="ident">new</span>(<span class="ident">sec</span>, <span class="ident">nanos</span>)
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">dur</span>(<span class="ident">millis</span>: <span class="ident">u64</span>) <span class="op">-></span> <span class="ident">Duration</span> {
+ <span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="ident">millis</span>)
+ }
+
+ <span class="comment">// The math around Instant/Duration isn't 100% precise due to rounding</span>
+ <span class="comment">// errors, see #249 for more info</span>
+ <span class="kw">fn</span> <span class="ident">almost_eq</span>(<span class="ident">a</span>: <span class="ident">Instant</span>, <span class="ident">b</span>: <span class="ident">Instant</span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="kw">if</span> <span class="ident">a</span> <span class="op">==</span> <span class="ident">b</span> {
+ <span class="bool-val">true</span>
+ } <span class="kw">else</span> <span class="kw">if</span> <span class="ident">a</span> <span class="op">></span> <span class="ident">b</span> {
+ <span class="ident">a</span> <span class="op">-</span> <span class="ident">b</span> <span class="op"><</span> <span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="number">1</span>)
+ } <span class="kw">else</span> {
+ <span class="ident">b</span> <span class="op">-</span> <span class="ident">a</span> <span class="op"><</span> <span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="number">1</span>)
+ }
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">norm_next</span>() {
+ <span class="kw">let</span> <span class="ident">tm</span> <span class="op">=</span> <span class="ident">Timeline</span>::<span class="ident">new</span>();
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">2</span>), <span class="ident">dur</span>(<span class="number">10</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">11</span>)));
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">7777</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">7788</span>), <span class="ident">dur</span>(<span class="number">100</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">7877</span>)));
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1000</span>), <span class="ident">dur</span>(<span class="number">2100</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">2101</span>)));
+ }
+
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="kw">fn</span> <span class="ident">fast_forward</span>() {
+ <span class="kw">let</span> <span class="ident">tm</span> <span class="op">=</span> <span class="ident">Timeline</span>::<span class="ident">new</span>();
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1000</span>), <span class="ident">dur</span>(<span class="number">10</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1001</span>)));
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">7777</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">8888</span>), <span class="ident">dur</span>(<span class="number">100</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">8977</span>)));
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">almost_eq</span>(<span class="ident">next_interval</span>(<span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">1</span>), <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">10000</span>), <span class="ident">dur</span>(<span class="number">2100</span>)),
+ <span class="ident">tm</span>.<span class="ident">at</span>(<span class="number">10501</span>)));
+ }
+
+ <span class="doccomment">/// TODO: this test actually should be successful, but since we can't</span>
+ <span class="doccomment">/// multiply Duration on anything larger than u32 easily we decided</span>
+ <span class="doccomment">/// to allow it to fail for now</span>
+ <span class="attribute">#[<span class="ident">test</span>]</span>
+ <span class="attribute">#[<span class="ident">should_panic</span>(<span class="ident">expected</span> <span class="op">=</span> <span class="string">"can't skip more than 4 billion intervals"</span>)]</span>
+ <span class="kw">fn</span> <span class="ident">large_skip</span>() {
+ <span class="kw">let</span> <span class="ident">tm</span> <span class="op">=</span> <span class="ident">Timeline</span>::<span class="ident">new</span>();
+ <span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">next_interval</span>(
+ <span class="ident">tm</span>.<span class="ident">at_ns</span>(<span class="number">0</span>, <span class="number">1</span>), <span class="ident">tm</span>.<span class="ident">at_ns</span>(<span class="number">25</span>, <span class="number">0</span>), <span class="ident">Duration</span>::<span class="ident">new</span>(<span class="number">0</span>, <span class="number">2</span>)),
+ <span class="ident">tm</span>.<span class="ident">at_ns</span>(<span class="number">25</span>, <span class="number">1</span>));
+ }
+
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/io_token.rs.html b/src/tokio_core/reactor/io_token.rs.html
new file mode 100644
index 0000000..066381d
--- /dev/null
+++ b/src/tokio_core/reactor/io_token.rs.html
@@ -0,0 +1,405 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/io_token.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>io_token.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::{<span class="ident">AtomicUsize</span>, <span class="ident">Ordering</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">task</span>;
+<span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">event</span>::<span class="ident">Evented</span>;
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Message</span>, <span class="ident">Remote</span>, <span class="ident">Handle</span>, <span class="ident">Direction</span>};
+
+<span class="doccomment">/// A token that identifies an active timeout.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">IoToken</span> {
+ <span class="ident">token</span>: <span class="ident">usize</span>,
+ <span class="comment">// TODO: can we avoid this allocation? It's kind of a bummer...</span>
+ <span class="ident">readiness</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">AtomicUsize</span><span class="op">></span>,
+}
+
+<span class="kw">impl</span> <span class="ident">IoToken</span> {
+ <span class="doccomment">/// Add a new source to an event loop, returning a future which will resolve</span>
+ <span class="doccomment">/// to the token that can be used to identify this source.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// When a new I/O object is created it needs to be communicated to the</span>
+ <span class="doccomment">/// event loop to ensure that it's registered and ready to receive</span>
+ <span class="doccomment">/// notifications. The event loop will then respond back with the I/O object</span>
+ <span class="doccomment">/// and a token which can be used to send more messages to the event loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The token returned is then passed in turn to each of the methods below</span>
+ <span class="doccomment">/// to interact with notifications on the I/O object itself.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The returned future will panic if the event loop this handle is</span>
+ <span class="doccomment">/// associated with has gone away, or if there is an error communicating</span>
+ <span class="doccomment">/// with the event loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">source</span>: <span class="kw-2">&</span><span class="ident">Evented</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">IoToken</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="ident">handle</span>.<span class="ident">inner</span>.<span class="ident">upgrade</span>() {
+ <span class="prelude-val">Some</span>(<span class="ident">inner</span>) <span class="op">=></span> {
+ <span class="kw">let</span> (<span class="ident">ready</span>, <span class="ident">token</span>) <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">add_source</span>(<span class="ident">source</span>));
+ <span class="prelude-val">Ok</span>(<span class="ident">IoToken</span> { <span class="ident">token</span>: <span class="ident">token</span>, <span class="ident">readiness</span>: <span class="ident">ready</span> })
+ }
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">Other</span>, <span class="string">"event loop gone"</span>)),
+ }
+ }
+
+ <span class="doccomment">/// Consumes the last readiness notification the token this source is for</span>
+ <span class="doccomment">/// registered.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Currently sources receive readiness notifications on an edge-basis. That</span>
+ <span class="doccomment">/// is, once you receive a notification that an object can be read, you</span>
+ <span class="doccomment">/// won't receive any more notifications until all of that data has been</span>
+ <span class="doccomment">/// read.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The event loop will fill in this information and then inform futures</span>
+ <span class="doccomment">/// that they're ready to go with the `schedule` method, and then the `poll`</span>
+ <span class="doccomment">/// method can use this to figure out what happened.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// > **Note**: This method should generally not be used directly, but</span>
+ <span class="doccomment">/// > rather the `ReadinessStream` type should be used instead.</span>
+ <span class="comment">// TODO: this should really return a proper newtype/enum, not a usize</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">take_readiness</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">swap</span>(<span class="number">0</span>, <span class="ident">Ordering</span>::<span class="ident">SeqCst</span>)
+ }
+
+ <span class="doccomment">/// Schedule the current future task to receive a notification when the</span>
+ <span class="doccomment">/// corresponding I/O object is readable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Once an I/O object has been registered with the event loop through the</span>
+ <span class="doccomment">/// `add_source` method, this method can be used with the assigned token to</span>
+ <span class="doccomment">/// notify the current future task when the next read notification comes in.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The current task will only receive a notification **once** and to</span>
+ <span class="doccomment">/// receive further notifications it will need to call `schedule_read`</span>
+ <span class="doccomment">/// again.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// > **Note**: This method should generally not be used directly, but</span>
+ <span class="doccomment">/// > rather the `ReadinessStream` type should be used instead.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if the event loop this handle is associated</span>
+ <span class="doccomment">/// with has gone away, or if there is an error communicating with the event</span>
+ <span class="doccomment">/// loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will also panic if there is not a currently running future</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">schedule_read</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">Schedule</span>(<span class="self">self</span>.<span class="ident">token</span>, <span class="ident">task</span>::<span class="ident">current</span>(), <span class="ident">Direction</span>::<span class="ident">Read</span>));
+ }
+
+ <span class="doccomment">/// Schedule the current future task to receive a notification when the</span>
+ <span class="doccomment">/// corresponding I/O object is writable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Once an I/O object has been registered with the event loop through the</span>
+ <span class="doccomment">/// `add_source` method, this method can be used with the assigned token to</span>
+ <span class="doccomment">/// notify the current future task when the next write notification comes</span>
+ <span class="doccomment">/// in.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The current task will only receive a notification **once** and to</span>
+ <span class="doccomment">/// receive further notifications it will need to call `schedule_write`</span>
+ <span class="doccomment">/// again.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// > **Note**: This method should generally not be used directly, but</span>
+ <span class="doccomment">/// > rather the `ReadinessStream` type should be used instead.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if the event loop this handle is associated</span>
+ <span class="doccomment">/// with has gone away, or if there is an error communicating with the event</span>
+ <span class="doccomment">/// loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will also panic if there is not a currently running future</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">schedule_write</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">Schedule</span>(<span class="self">self</span>.<span class="ident">token</span>, <span class="ident">task</span>::<span class="ident">current</span>(), <span class="ident">Direction</span>::<span class="ident">Write</span>));
+ }
+
+ <span class="doccomment">/// Unregister all information associated with a token on an event loop,</span>
+ <span class="doccomment">/// deallocating all internal resources assigned to the given token.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method should be called whenever a source of events is being</span>
+ <span class="doccomment">/// destroyed. This will ensure that the event loop can reuse `tok` for</span>
+ <span class="doccomment">/// another I/O object if necessary and also remove it from any poll</span>
+ <span class="doccomment">/// notifications and callbacks.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that wake callbacks may still be invoked after this method is</span>
+ <span class="doccomment">/// called as it may take some time for the message to drop a source to</span>
+ <span class="doccomment">/// reach the event loop. Despite this fact, this method will attempt to</span>
+ <span class="doccomment">/// ensure that the callbacks are **not** invoked, so pending scheduled</span>
+ <span class="doccomment">/// callbacks cannot be relied upon to get called.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// > **Note**: This method should generally not be used directly, but</span>
+ <span class="doccomment">/// > rather the `ReadinessStream` type should be used instead.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if the event loop this handle is associated</span>
+ <span class="doccomment">/// with has gone away, or if there is an error communicating with the event</span>
+ <span class="doccomment">/// loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">drop_source</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">DropSource</span>(<span class="self">self</span>.<span class="ident">token</span>));
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/mod.rs.html b/src/tokio_core/reactor/mod.rs.html
new file mode 100644
index 0000000..3fee0b4
--- /dev/null
+++ b/src/tokio_core/reactor/mod.rs.html
@@ -0,0 +1,1989 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/mod.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>mod.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+<span id="410">410</span>
+<span id="411">411</span>
+<span id="412">412</span>
+<span id="413">413</span>
+<span id="414">414</span>
+<span id="415">415</span>
+<span id="416">416</span>
+<span id="417">417</span>
+<span id="418">418</span>
+<span id="419">419</span>
+<span id="420">420</span>
+<span id="421">421</span>
+<span id="422">422</span>
+<span id="423">423</span>
+<span id="424">424</span>
+<span id="425">425</span>
+<span id="426">426</span>
+<span id="427">427</span>
+<span id="428">428</span>
+<span id="429">429</span>
+<span id="430">430</span>
+<span id="431">431</span>
+<span id="432">432</span>
+<span id="433">433</span>
+<span id="434">434</span>
+<span id="435">435</span>
+<span id="436">436</span>
+<span id="437">437</span>
+<span id="438">438</span>
+<span id="439">439</span>
+<span id="440">440</span>
+<span id="441">441</span>
+<span id="442">442</span>
+<span id="443">443</span>
+<span id="444">444</span>
+<span id="445">445</span>
+<span id="446">446</span>
+<span id="447">447</span>
+<span id="448">448</span>
+<span id="449">449</span>
+<span id="450">450</span>
+<span id="451">451</span>
+<span id="452">452</span>
+<span id="453">453</span>
+<span id="454">454</span>
+<span id="455">455</span>
+<span id="456">456</span>
+<span id="457">457</span>
+<span id="458">458</span>
+<span id="459">459</span>
+<span id="460">460</span>
+<span id="461">461</span>
+<span id="462">462</span>
+<span id="463">463</span>
+<span id="464">464</span>
+<span id="465">465</span>
+<span id="466">466</span>
+<span id="467">467</span>
+<span id="468">468</span>
+<span id="469">469</span>
+<span id="470">470</span>
+<span id="471">471</span>
+<span id="472">472</span>
+<span id="473">473</span>
+<span id="474">474</span>
+<span id="475">475</span>
+<span id="476">476</span>
+<span id="477">477</span>
+<span id="478">478</span>
+<span id="479">479</span>
+<span id="480">480</span>
+<span id="481">481</span>
+<span id="482">482</span>
+<span id="483">483</span>
+<span id="484">484</span>
+<span id="485">485</span>
+<span id="486">486</span>
+<span id="487">487</span>
+<span id="488">488</span>
+<span id="489">489</span>
+<span id="490">490</span>
+<span id="491">491</span>
+<span id="492">492</span>
+<span id="493">493</span>
+<span id="494">494</span>
+<span id="495">495</span>
+<span id="496">496</span>
+<span id="497">497</span>
+<span id="498">498</span>
+<span id="499">499</span>
+<span id="500">500</span>
+<span id="501">501</span>
+<span id="502">502</span>
+<span id="503">503</span>
+<span id="504">504</span>
+<span id="505">505</span>
+<span id="506">506</span>
+<span id="507">507</span>
+<span id="508">508</span>
+<span id="509">509</span>
+<span id="510">510</span>
+<span id="511">511</span>
+<span id="512">512</span>
+<span id="513">513</span>
+<span id="514">514</span>
+<span id="515">515</span>
+<span id="516">516</span>
+<span id="517">517</span>
+<span id="518">518</span>
+<span id="519">519</span>
+<span id="520">520</span>
+<span id="521">521</span>
+<span id="522">522</span>
+<span id="523">523</span>
+<span id="524">524</span>
+<span id="525">525</span>
+<span id="526">526</span>
+<span id="527">527</span>
+<span id="528">528</span>
+<span id="529">529</span>
+<span id="530">530</span>
+<span id="531">531</span>
+<span id="532">532</span>
+<span id="533">533</span>
+<span id="534">534</span>
+<span id="535">535</span>
+<span id="536">536</span>
+<span id="537">537</span>
+<span id="538">538</span>
+<span id="539">539</span>
+<span id="540">540</span>
+<span id="541">541</span>
+<span id="542">542</span>
+<span id="543">543</span>
+<span id="544">544</span>
+<span id="545">545</span>
+<span id="546">546</span>
+<span id="547">547</span>
+<span id="548">548</span>
+<span id="549">549</span>
+<span id="550">550</span>
+<span id="551">551</span>
+<span id="552">552</span>
+<span id="553">553</span>
+<span id="554">554</span>
+<span id="555">555</span>
+<span id="556">556</span>
+<span id="557">557</span>
+<span id="558">558</span>
+<span id="559">559</span>
+<span id="560">560</span>
+<span id="561">561</span>
+<span id="562">562</span>
+<span id="563">563</span>
+<span id="564">564</span>
+<span id="565">565</span>
+<span id="566">566</span>
+<span id="567">567</span>
+<span id="568">568</span>
+<span id="569">569</span>
+<span id="570">570</span>
+<span id="571">571</span>
+<span id="572">572</span>
+<span id="573">573</span>
+<span id="574">574</span>
+<span id="575">575</span>
+<span id="576">576</span>
+<span id="577">577</span>
+<span id="578">578</span>
+<span id="579">579</span>
+<span id="580">580</span>
+<span id="581">581</span>
+<span id="582">582</span>
+<span id="583">583</span>
+<span id="584">584</span>
+<span id="585">585</span>
+<span id="586">586</span>
+<span id="587">587</span>
+<span id="588">588</span>
+<span id="589">589</span>
+<span id="590">590</span>
+<span id="591">591</span>
+<span id="592">592</span>
+<span id="593">593</span>
+<span id="594">594</span>
+<span id="595">595</span>
+<span id="596">596</span>
+<span id="597">597</span>
+<span id="598">598</span>
+<span id="599">599</span>
+<span id="600">600</span>
+<span id="601">601</span>
+<span id="602">602</span>
+<span id="603">603</span>
+<span id="604">604</span>
+<span id="605">605</span>
+<span id="606">606</span>
+<span id="607">607</span>
+<span id="608">608</span>
+<span id="609">609</span>
+<span id="610">610</span>
+<span id="611">611</span>
+<span id="612">612</span>
+<span id="613">613</span>
+<span id="614">614</span>
+<span id="615">615</span>
+<span id="616">616</span>
+<span id="617">617</span>
+<span id="618">618</span>
+<span id="619">619</span>
+<span id="620">620</span>
+<span id="621">621</span>
+<span id="622">622</span>
+<span id="623">623</span>
+<span id="624">624</span>
+<span id="625">625</span>
+<span id="626">626</span>
+<span id="627">627</span>
+<span id="628">628</span>
+<span id="629">629</span>
+<span id="630">630</span>
+<span id="631">631</span>
+<span id="632">632</span>
+<span id="633">633</span>
+<span id="634">634</span>
+<span id="635">635</span>
+<span id="636">636</span>
+<span id="637">637</span>
+<span id="638">638</span>
+<span id="639">639</span>
+<span id="640">640</span>
+<span id="641">641</span>
+<span id="642">642</span>
+<span id="643">643</span>
+<span id="644">644</span>
+<span id="645">645</span>
+<span id="646">646</span>
+<span id="647">647</span>
+<span id="648">648</span>
+<span id="649">649</span>
+<span id="650">650</span>
+<span id="651">651</span>
+<span id="652">652</span>
+<span id="653">653</span>
+<span id="654">654</span>
+<span id="655">655</span>
+<span id="656">656</span>
+<span id="657">657</span>
+<span id="658">658</span>
+<span id="659">659</span>
+<span id="660">660</span>
+<span id="661">661</span>
+<span id="662">662</span>
+<span id="663">663</span>
+<span id="664">664</span>
+<span id="665">665</span>
+<span id="666">666</span>
+<span id="667">667</span>
+<span id="668">668</span>
+<span id="669">669</span>
+<span id="670">670</span>
+<span id="671">671</span>
+<span id="672">672</span>
+<span id="673">673</span>
+<span id="674">674</span>
+<span id="675">675</span>
+<span id="676">676</span>
+<span id="677">677</span>
+<span id="678">678</span>
+<span id="679">679</span>
+<span id="680">680</span>
+<span id="681">681</span>
+<span id="682">682</span>
+<span id="683">683</span>
+<span id="684">684</span>
+<span id="685">685</span>
+<span id="686">686</span>
+<span id="687">687</span>
+<span id="688">688</span>
+<span id="689">689</span>
+<span id="690">690</span>
+<span id="691">691</span>
+<span id="692">692</span>
+<span id="693">693</span>
+<span id="694">694</span>
+<span id="695">695</span>
+<span id="696">696</span>
+<span id="697">697</span>
+<span id="698">698</span>
+<span id="699">699</span>
+<span id="700">700</span>
+<span id="701">701</span>
+<span id="702">702</span>
+<span id="703">703</span>
+<span id="704">704</span>
+<span id="705">705</span>
+<span id="706">706</span>
+<span id="707">707</span>
+<span id="708">708</span>
+<span id="709">709</span>
+<span id="710">710</span>
+<span id="711">711</span>
+<span id="712">712</span>
+<span id="713">713</span>
+<span id="714">714</span>
+<span id="715">715</span>
+<span id="716">716</span>
+<span id="717">717</span>
+<span id="718">718</span>
+<span id="719">719</span>
+<span id="720">720</span>
+<span id="721">721</span>
+<span id="722">722</span>
+<span id="723">723</span>
+<span id="724">724</span>
+<span id="725">725</span>
+<span id="726">726</span>
+<span id="727">727</span>
+<span id="728">728</span>
+<span id="729">729</span>
+<span id="730">730</span>
+<span id="731">731</span>
+<span id="732">732</span>
+<span id="733">733</span>
+<span id="734">734</span>
+<span id="735">735</span>
+<span id="736">736</span>
+<span id="737">737</span>
+<span id="738">738</span>
+<span id="739">739</span>
+<span id="740">740</span>
+<span id="741">741</span>
+<span id="742">742</span>
+<span id="743">743</span>
+<span id="744">744</span>
+<span id="745">745</span>
+<span id="746">746</span>
+<span id="747">747</span>
+<span id="748">748</span>
+<span id="749">749</span>
+<span id="750">750</span>
+<span id="751">751</span>
+<span id="752">752</span>
+<span id="753">753</span>
+<span id="754">754</span>
+<span id="755">755</span>
+<span id="756">756</span>
+<span id="757">757</span>
+<span id="758">758</span>
+<span id="759">759</span>
+<span id="760">760</span>
+<span id="761">761</span>
+<span id="762">762</span>
+<span id="763">763</span>
+<span id="764">764</span>
+<span id="765">765</span>
+<span id="766">766</span>
+<span id="767">767</span>
+<span id="768">768</span>
+<span id="769">769</span>
+<span id="770">770</span>
+<span id="771">771</span>
+<span id="772">772</span>
+<span id="773">773</span>
+<span id="774">774</span>
+<span id="775">775</span>
+<span id="776">776</span>
+<span id="777">777</span>
+<span id="778">778</span>
+<span id="779">779</span>
+<span id="780">780</span>
+<span id="781">781</span>
+<span id="782">782</span>
+<span id="783">783</span>
+<span id="784">784</span>
+<span id="785">785</span>
+<span id="786">786</span>
+<span id="787">787</span>
+<span id="788">788</span>
+<span id="789">789</span>
+<span id="790">790</span>
+<span id="791">791</span>
+<span id="792">792</span>
+<span id="793">793</span>
+<span id="794">794</span>
+<span id="795">795</span>
+<span id="796">796</span>
+<span id="797">797</span>
+<span id="798">798</span>
+<span id="799">799</span>
+<span id="800">800</span>
+<span id="801">801</span>
+<span id="802">802</span>
+<span id="803">803</span>
+<span id="804">804</span>
+<span id="805">805</span>
+<span id="806">806</span>
+<span id="807">807</span>
+<span id="808">808</span>
+<span id="809">809</span>
+<span id="810">810</span>
+<span id="811">811</span>
+<span id="812">812</span>
+<span id="813">813</span>
+<span id="814">814</span>
+<span id="815">815</span>
+<span id="816">816</span>
+<span id="817">817</span>
+<span id="818">818</span>
+<span id="819">819</span>
+<span id="820">820</span>
+<span id="821">821</span>
+<span id="822">822</span>
+<span id="823">823</span>
+<span id="824">824</span>
+<span id="825">825</span>
+<span id="826">826</span>
+<span id="827">827</span>
+<span id="828">828</span>
+<span id="829">829</span>
+<span id="830">830</span>
+<span id="831">831</span>
+<span id="832">832</span>
+<span id="833">833</span>
+<span id="834">834</span>
+<span id="835">835</span>
+<span id="836">836</span>
+<span id="837">837</span>
+<span id="838">838</span>
+<span id="839">839</span>
+<span id="840">840</span>
+<span id="841">841</span>
+<span id="842">842</span>
+<span id="843">843</span>
+<span id="844">844</span>
+<span id="845">845</span>
+<span id="846">846</span>
+<span id="847">847</span>
+<span id="848">848</span>
+<span id="849">849</span>
+<span id="850">850</span>
+<span id="851">851</span>
+<span id="852">852</span>
+<span id="853">853</span>
+<span id="854">854</span>
+<span id="855">855</span>
+<span id="856">856</span>
+<span id="857">857</span>
+<span id="858">858</span>
+<span id="859">859</span>
+<span id="860">860</span>
+<span id="861">861</span>
+<span id="862">862</span>
+<span id="863">863</span>
+<span id="864">864</span>
+<span id="865">865</span>
+<span id="866">866</span>
+<span id="867">867</span>
+<span id="868">868</span>
+<span id="869">869</span>
+<span id="870">870</span>
+<span id="871">871</span>
+<span id="872">872</span>
+<span id="873">873</span>
+<span id="874">874</span>
+<span id="875">875</span>
+<span id="876">876</span>
+<span id="877">877</span>
+<span id="878">878</span>
+<span id="879">879</span>
+<span id="880">880</span>
+<span id="881">881</span>
+<span id="882">882</span>
+<span id="883">883</span>
+<span id="884">884</span>
+<span id="885">885</span>
+<span id="886">886</span>
+<span id="887">887</span>
+<span id="888">888</span>
+<span id="889">889</span>
+<span id="890">890</span>
+<span id="891">891</span>
+<span id="892">892</span>
+<span id="893">893</span>
+<span id="894">894</span>
+<span id="895">895</span>
+<span id="896">896</span>
+<span id="897">897</span>
+<span id="898">898</span>
+<span id="899">899</span>
+<span id="900">900</span>
+<span id="901">901</span>
+<span id="902">902</span>
+<span id="903">903</span>
+<span id="904">904</span>
+<span id="905">905</span>
+<span id="906">906</span>
+<span id="907">907</span>
+<span id="908">908</span>
+<span id="909">909</span>
+<span id="910">910</span>
+<span id="911">911</span>
+<span id="912">912</span>
+<span id="913">913</span>
+<span id="914">914</span>
+<span id="915">915</span>
+<span id="916">916</span>
+<span id="917">917</span>
+<span id="918">918</span>
+<span id="919">919</span>
+<span id="920">920</span>
+<span id="921">921</span>
+<span id="922">922</span>
+<span id="923">923</span>
+<span id="924">924</span>
+<span id="925">925</span>
+<span id="926">926</span>
+<span id="927">927</span>
+<span id="928">928</span>
+<span id="929">929</span>
+<span id="930">930</span>
+<span id="931">931</span>
+<span id="932">932</span>
+<span id="933">933</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! The core reactor driving all I/O</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This module contains the `Core` type which is the reactor for all I/O</span>
+<span class="doccomment">//! happening in `tokio-core`. This reactor (or event loop) is used to run</span>
+<span class="doccomment">//! futures, schedule tasks, issue I/O requests, etc.</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cell</span>::<span class="ident">RefCell</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">ErrorKind</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">rc</span>::{<span class="ident">Rc</span>, <span class="ident">Weak</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::{<span class="ident">AtomicUsize</span>, <span class="ident">ATOMIC_USIZE_INIT</span>, <span class="ident">Ordering</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::{<span class="ident">Instant</span>, <span class="ident">Duration</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">IntoFuture</span>, <span class="ident">Async</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">future</span>::{<span class="self">self</span>, <span class="ident">Executor</span>, <span class="ident">ExecuteError</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">executor</span>::{<span class="self">self</span>, <span class="ident">Spawn</span>, <span class="ident">Notify</span>};
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">sync</span>::<span class="ident">mpsc</span>;
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">task</span>::<span class="ident">Task</span>;
+<span class="kw">use</span> <span class="ident">mio</span>;
+<span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">event</span>::<span class="ident">Evented</span>;
+<span class="kw">use</span> <span class="ident">slab</span>::<span class="ident">Slab</span>;
+
+<span class="kw">use</span> <span class="ident">heap</span>::{<span class="ident">Heap</span>, <span class="ident">Slot</span>};
+
+<span class="kw">mod</span> <span class="ident">io_token</span>;
+<span class="kw">mod</span> <span class="ident">timeout_token</span>;
+
+<span class="kw">mod</span> <span class="ident">poll_evented</span>;
+<span class="kw">mod</span> <span class="ident">timeout</span>;
+<span class="kw">mod</span> <span class="ident">interval</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">poll_evented</span>::<span class="ident">PollEvented</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">timeout</span>::<span class="ident">Timeout</span>;
+<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">interval</span>::<span class="ident">Interval</span>;
+
+<span class="kw">static</span> <span class="ident">NEXT_LOOP_ID</span>: <span class="ident">AtomicUsize</span> <span class="op">=</span> <span class="ident">ATOMIC_USIZE_INIT</span>;
+<span class="macro">scoped_thread_local</span><span class="macro">!</span>(<span class="kw">static</span> <span class="ident">CURRENT_LOOP</span>: <span class="ident">Core</span>);
+
+<span class="doccomment">/// An event loop.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The event loop is the main source of blocking in an application which drives</span>
+<span class="doccomment">/// all other I/O events and notifications happening. Each event loop can have</span>
+<span class="doccomment">/// multiple handles pointing to it, each of which can then be used to create</span>
+<span class="doccomment">/// various I/O objects to interact with the event loop in interesting ways.</span>
+<span class="comment">// TODO: expand this</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Core</span> {
+ <span class="ident">events</span>: <span class="ident">mio</span>::<span class="ident">Events</span>,
+ <span class="ident">tx</span>: <span class="ident">mpsc</span>::<span class="ident">UnboundedSender</span><span class="op"><</span><span class="ident">Message</span><span class="op">></span>,
+ <span class="ident">rx</span>: <span class="ident">RefCell</span><span class="op"><</span><span class="ident">Spawn</span><span class="op"><</span><span class="ident">mpsc</span>::<span class="ident">UnboundedReceiver</span><span class="op"><</span><span class="ident">Message</span><span class="op">>></span><span class="op">></span>,
+ <span class="ident">_rx_registration</span>: <span class="ident">mio</span>::<span class="ident">Registration</span>,
+ <span class="ident">rx_readiness</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">MySetReadiness</span><span class="op">></span>,
+
+ <span class="ident">inner</span>: <span class="ident">Rc</span><span class="op"><</span><span class="ident">RefCell</span><span class="op"><</span><span class="ident">Inner</span><span class="op">>></span>,
+
+ <span class="comment">// Used for determining when the future passed to `run` is ready. Once the</span>
+ <span class="comment">// registration is passed to `io` above we never touch it again, just keep</span>
+ <span class="comment">// it alive.</span>
+ <span class="ident">_future_registration</span>: <span class="ident">mio</span>::<span class="ident">Registration</span>,
+ <span class="ident">future_readiness</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">MySetReadiness</span><span class="op">></span>,
+}
+
+<span class="kw">struct</span> <span class="ident">Inner</span> {
+ <span class="ident">id</span>: <span class="ident">usize</span>,
+ <span class="ident">io</span>: <span class="ident">mio</span>::<span class="ident">Poll</span>,
+
+ <span class="comment">// Dispatch slabs for I/O and futures events</span>
+ <span class="ident">io_dispatch</span>: <span class="ident">Slab</span><span class="op"><</span><span class="ident">ScheduledIo</span><span class="op">></span>,
+ <span class="ident">task_dispatch</span>: <span class="ident">Slab</span><span class="op"><</span><span class="ident">ScheduledTask</span><span class="op">></span>,
+
+ <span class="comment">// Timer wheel keeping track of all timeouts. The `usize` stored in the</span>
+ <span class="comment">// timer wheel is an index into the slab below.</span>
+ <span class="comment">//</span>
+ <span class="comment">// The slab below keeps track of the timeouts themselves as well as the</span>
+ <span class="comment">// state of the timeout itself. The `TimeoutToken` type is an index into the</span>
+ <span class="comment">// `timeouts` slab.</span>
+ <span class="ident">timer_heap</span>: <span class="ident">Heap</span><span class="op"><</span>(<span class="ident">Instant</span>, <span class="ident">usize</span>)<span class="op">></span>,
+ <span class="ident">timeouts</span>: <span class="ident">Slab</span><span class="op"><</span>(<span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Slot</span><span class="op">></span>, <span class="ident">TimeoutState</span>)<span class="op">></span>,
+}
+
+<span class="doccomment">/// An unique ID for a Core</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// An ID by which different cores may be distinguished. Can be compared and used as an index in</span>
+<span class="doccomment">/// a `HashMap`.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// The ID is globally unique and never reused.</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>,<span class="ident">Copy</span>,<span class="ident">Eq</span>,<span class="ident">PartialEq</span>,<span class="ident">Hash</span>,<span class="ident">Debug</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">CoreId</span>(<span class="ident">usize</span>);
+
+<span class="doccomment">/// Handle to an event loop, used to construct I/O objects, send messages, and</span>
+<span class="doccomment">/// otherwise interact indirectly with the event loop itself.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Handles can be cloned, and when cloned they will still refer to the</span>
+<span class="doccomment">/// same underlying event loop.</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Remote</span> {
+ <span class="ident">id</span>: <span class="ident">usize</span>,
+ <span class="ident">tx</span>: <span class="ident">mpsc</span>::<span class="ident">UnboundedSender</span><span class="op"><</span><span class="ident">Message</span><span class="op">></span>,
+}
+
+<span class="doccomment">/// A non-sendable handle to an event loop, useful for manufacturing instances</span>
+<span class="doccomment">/// of `LoopData`.</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Handle</span> {
+ <span class="ident">remote</span>: <span class="ident">Remote</span>,
+ <span class="ident">inner</span>: <span class="ident">Weak</span><span class="op"><</span><span class="ident">RefCell</span><span class="op"><</span><span class="ident">Inner</span><span class="op">>></span>,
+}
+
+<span class="kw">struct</span> <span class="ident">ScheduledIo</span> {
+ <span class="ident">readiness</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">AtomicUsize</span><span class="op">></span>,
+ <span class="ident">reader</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span>,
+ <span class="ident">writer</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span>,
+}
+
+<span class="kw">struct</span> <span class="ident">ScheduledTask</span> {
+ <span class="ident">_registration</span>: <span class="ident">mio</span>::<span class="ident">Registration</span>,
+ <span class="ident">spawn</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Spawn</span><span class="op"><</span><span class="ident">Box</span><span class="op"><</span><span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span>(), <span class="ident">Error</span><span class="op">=</span>()<span class="op">>></span><span class="op">>></span>,
+ <span class="ident">wake</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Arc</span><span class="op"><</span><span class="ident">MySetReadiness</span><span class="op">>></span>,
+}
+
+<span class="kw">enum</span> <span class="ident">TimeoutState</span> {
+ <span class="ident">NotFired</span>,
+ <span class="ident">Fired</span>,
+ <span class="ident">Waiting</span>(<span class="ident">Task</span>),
+}
+
+<span class="kw">enum</span> <span class="ident">Direction</span> {
+ <span class="ident">Read</span>,
+ <span class="ident">Write</span>,
+}
+
+<span class="kw">enum</span> <span class="ident">Message</span> {
+ <span class="ident">DropSource</span>(<span class="ident">usize</span>),
+ <span class="ident">Schedule</span>(<span class="ident">usize</span>, <span class="ident">Task</span>, <span class="ident">Direction</span>),
+ <span class="ident">UpdateTimeout</span>(<span class="ident">usize</span>, <span class="ident">Task</span>),
+ <span class="ident">ResetTimeout</span>(<span class="ident">usize</span>, <span class="ident">Instant</span>),
+ <span class="ident">CancelTimeout</span>(<span class="ident">usize</span>),
+ <span class="ident">Run</span>(<span class="ident">Box</span><span class="op"><</span><span class="ident">FnBox</span><span class="op">></span>),
+}
+
+<span class="kw">const</span> <span class="ident">TOKEN_MESSAGES</span>: <span class="ident">mio</span>::<span class="ident">Token</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Token</span>(<span class="number">0</span>);
+<span class="kw">const</span> <span class="ident">TOKEN_FUTURE</span>: <span class="ident">mio</span>::<span class="ident">Token</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Token</span>(<span class="number">1</span>);
+<span class="kw">const</span> <span class="ident">TOKEN_START</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">2</span>;
+
+<span class="kw">impl</span> <span class="ident">Core</span> {
+ <span class="doccomment">/// Creates a new event loop, returning any error that happened during the</span>
+ <span class="doccomment">/// creation.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">Core</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">io</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">mio</span>::<span class="ident">Poll</span>::<span class="ident">new</span>());
+ <span class="kw">let</span> <span class="ident">future_pair</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Registration</span>::<span class="ident">new2</span>();
+ <span class="macro">try</span><span class="macro">!</span>(<span class="ident">io</span>.<span class="ident">register</span>(<span class="kw-2">&</span><span class="ident">future_pair</span>.<span class="number">0</span>,
+ <span class="ident">TOKEN_FUTURE</span>,
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>(),
+ <span class="ident">mio</span>::<span class="ident">PollOpt</span>::<span class="ident">level</span>()));
+ <span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc</span>::<span class="ident">unbounded</span>();
+ <span class="kw">let</span> <span class="ident">channel_pair</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Registration</span>::<span class="ident">new2</span>();
+ <span class="macro">try</span><span class="macro">!</span>(<span class="ident">io</span>.<span class="ident">register</span>(<span class="kw-2">&</span><span class="ident">channel_pair</span>.<span class="number">0</span>,
+ <span class="ident">TOKEN_MESSAGES</span>,
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>(),
+ <span class="ident">mio</span>::<span class="ident">PollOpt</span>::<span class="ident">level</span>()));
+ <span class="kw">let</span> <span class="ident">rx_readiness</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">MySetReadiness</span>(<span class="ident">channel_pair</span>.<span class="number">1</span>));
+ <span class="ident">rx_readiness</span>.<span class="ident">notify</span>(<span class="number">0</span>);
+
+ <span class="prelude-val">Ok</span>(<span class="ident">Core</span> {
+ <span class="ident">events</span>: <span class="ident">mio</span>::<span class="ident">Events</span>::<span class="ident">with_capacity</span>(<span class="number">1024</span>),
+ <span class="ident">tx</span>: <span class="ident">tx</span>,
+ <span class="ident">rx</span>: <span class="ident">RefCell</span>::<span class="ident">new</span>(<span class="ident">executor</span>::<span class="ident">spawn</span>(<span class="ident">rx</span>)),
+ <span class="ident">_rx_registration</span>: <span class="ident">channel_pair</span>.<span class="number">0</span>,
+ <span class="ident">rx_readiness</span>: <span class="ident">rx_readiness</span>,
+
+ <span class="ident">_future_registration</span>: <span class="ident">future_pair</span>.<span class="number">0</span>,
+ <span class="ident">future_readiness</span>: <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">MySetReadiness</span>(<span class="ident">future_pair</span>.<span class="number">1</span>)),
+
+ <span class="ident">inner</span>: <span class="ident">Rc</span>::<span class="ident">new</span>(<span class="ident">RefCell</span>::<span class="ident">new</span>(<span class="ident">Inner</span> {
+ <span class="ident">id</span>: <span class="ident">NEXT_LOOP_ID</span>.<span class="ident">fetch_add</span>(<span class="number">1</span>, <span class="ident">Ordering</span>::<span class="ident">Relaxed</span>),
+ <span class="ident">io</span>: <span class="ident">io</span>,
+ <span class="ident">io_dispatch</span>: <span class="ident">Slab</span>::<span class="ident">with_capacity</span>(<span class="number">1</span>),
+ <span class="ident">task_dispatch</span>: <span class="ident">Slab</span>::<span class="ident">with_capacity</span>(<span class="number">1</span>),
+ <span class="ident">timeouts</span>: <span class="ident">Slab</span>::<span class="ident">with_capacity</span>(<span class="number">1</span>),
+ <span class="ident">timer_heap</span>: <span class="ident">Heap</span>::<span class="ident">new</span>(),
+ })),
+ })
+ }
+
+ <span class="doccomment">/// Returns a handle to this event loop which cannot be sent across threads</span>
+ <span class="doccomment">/// but can be used as a proxy to the event loop itself.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Handles are cloneable and clones always refer to the same event loop.</span>
+ <span class="doccomment">/// This handle is typically passed into functions that create I/O objects</span>
+ <span class="doccomment">/// to bind them to this event loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">handle</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Handle</span> {
+ <span class="ident">Handle</span> {
+ <span class="ident">remote</span>: <span class="self">self</span>.<span class="ident">remote</span>(),
+ <span class="ident">inner</span>: <span class="ident">Rc</span>::<span class="ident">downgrade</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">inner</span>),
+ }
+ }
+
+ <span class="doccomment">/// Generates a remote handle to this event loop which can be used to spawn</span>
+ <span class="doccomment">/// tasks from other threads into this event loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">remote</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Remote</span> {
+ <span class="ident">Remote</span> {
+ <span class="ident">id</span>: <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow</span>().<span class="ident">id</span>,
+ <span class="ident">tx</span>: <span class="self">self</span>.<span class="ident">tx</span>.<span class="ident">clone</span>(),
+ }
+ }
+
+ <span class="doccomment">/// Runs a future until completion, driving the event loop while we're</span>
+ <span class="doccomment">/// otherwise waiting for the future to complete.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will begin executing the event loop and will finish once</span>
+ <span class="doccomment">/// the provided future is resolved. Note that the future argument here</span>
+ <span class="doccomment">/// crucially does not require the `'static` nor `Send` bounds. As a result</span>
+ <span class="doccomment">/// the future will be "pinned" to not only this thread but also this stack</span>
+ <span class="doccomment">/// frame.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will return the value that the future resolves to once</span>
+ <span class="doccomment">/// the future has finished. If the future never resolves then this function</span>
+ <span class="doccomment">/// will never return.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will **not** catch panics from polling the future `f`. If</span>
+ <span class="doccomment">/// the future panics then it's the responsibility of the caller to catch</span>
+ <span class="doccomment">/// that panic and handle it as appropriate.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">run</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">f</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">F</span>::<span class="ident">Item</span>, <span class="ident">F</span>::<span class="ident">Error</span><span class="op">></span>
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Future</span>,
+ {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">task</span> <span class="op">=</span> <span class="ident">executor</span>::<span class="ident">spawn</span>(<span class="ident">f</span>);
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">future_fired</span> <span class="op">=</span> <span class="bool-val">true</span>;
+
+ <span class="kw">loop</span> {
+ <span class="kw">if</span> <span class="ident">future_fired</span> {
+ <span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">CURRENT_LOOP</span>.<span class="ident">set</span>(<span class="self">self</span>, <span class="op">||</span> {
+ <span class="ident">task</span>.<span class="ident">poll_future_notify</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">future_readiness</span>, <span class="number">0</span>)
+ }));
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="ident">e</span>) <span class="op">=</span> <span class="ident">res</span> {
+ <span class="kw">return</span> <span class="prelude-val">Ok</span>(<span class="ident">e</span>)
+ }
+ }
+ <span class="ident">future_fired</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll</span>(<span class="prelude-val">None</span>);
+ }
+ }
+
+ <span class="doccomment">/// Performs one iteration of the event loop, blocking on waiting for events</span>
+ <span class="doccomment">/// for at most `max_wait` (forever if `None`).</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// It only makes sense to call this method if you've previously spawned</span>
+ <span class="doccomment">/// a future onto this event loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// `loop { lp.turn(None) }` is equivalent to calling `run` with an</span>
+ <span class="doccomment">/// empty future (one that never finishes).</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">turn</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">max_wait</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">></span>) {
+ <span class="self">self</span>.<span class="ident">poll</span>(<span class="ident">max_wait</span>);
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">max_wait</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">></span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="comment">// Given the `max_wait` variable specified, figure out the actual</span>
+ <span class="comment">// timeout that we're going to pass to `poll`. This involves taking a</span>
+ <span class="comment">// look at active timers on our heap as well.</span>
+ <span class="kw">let</span> <span class="ident">start</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
+ <span class="kw">let</span> <span class="ident">timeout</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">timer_heap</span>.<span class="ident">peek</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> {
+ <span class="kw">if</span> <span class="ident">t</span>.<span class="number">0</span> <span class="op"><</span> <span class="ident">start</span> {
+ <span class="ident">Duration</span>::<span class="ident">new</span>(<span class="number">0</span>, <span class="number">0</span>)
+ } <span class="kw">else</span> {
+ <span class="ident">t</span>.<span class="number">0</span> <span class="op">-</span> <span class="ident">start</span>
+ }
+ });
+ <span class="kw">let</span> <span class="ident">timeout</span> <span class="op">=</span> <span class="kw">match</span> (<span class="ident">max_wait</span>, <span class="ident">timeout</span>) {
+ (<span class="prelude-val">Some</span>(<span class="ident">d1</span>), <span class="prelude-val">Some</span>(<span class="ident">d2</span>)) <span class="op">=></span> <span class="prelude-val">Some</span>(<span class="ident">cmp</span>::<span class="ident">min</span>(<span class="ident">d1</span>, <span class="ident">d2</span>)),
+ (<span class="ident">max_wait</span>, <span class="ident">timeout</span>) <span class="op">=></span> <span class="ident">max_wait</span>.<span class="ident">or</span>(<span class="ident">timeout</span>),
+ };
+
+ <span class="comment">// Block waiting for an event to happen, peeling out how many events</span>
+ <span class="comment">// happened.</span>
+ <span class="kw">let</span> <span class="ident">amt</span> <span class="op">=</span> <span class="kw">match</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">io</span>.<span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">events</span>, <span class="ident">timeout</span>) {
+ <span class="prelude-val">Ok</span>(<span class="ident">a</span>) <span class="op">=></span> <span class="ident">a</span>,
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">ErrorKind</span>::<span class="ident">Interrupted</span> <span class="op">=></span> <span class="kw">return</span> <span class="bool-val">false</span>,
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"error in poll: {}"</span>, <span class="ident">e</span>),
+ };
+
+ <span class="kw">let</span> <span class="ident">after_poll</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"loop poll - {:?}"</span>, <span class="ident">after_poll</span> <span class="op">-</span> <span class="ident">start</span>);
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"loop time - {:?}"</span>, <span class="ident">after_poll</span>);
+
+ <span class="comment">// Process all timeouts that may have just occurred, updating the</span>
+ <span class="comment">// current time since</span>
+ <span class="self">self</span>.<span class="ident">consume_timeouts</span>(<span class="ident">after_poll</span>);
+
+ <span class="comment">// Process all the events that came in, dispatching appropriately</span>
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">fired</span> <span class="op">=</span> <span class="bool-val">false</span>;
+ <span class="kw">for</span> <span class="ident">event</span> <span class="kw">in</span> <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">events</span> {
+ <span class="kw">let</span> <span class="ident">token</span> <span class="op">=</span> <span class="ident">event</span>.<span class="ident">token</span>();
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"event {:?} {:?}"</span>, <span class="ident">event</span>.<span class="ident">readiness</span>(), <span class="ident">event</span>.<span class="ident">token</span>());
+
+ <span class="kw">if</span> <span class="ident">token</span> <span class="op">==</span> <span class="ident">TOKEN_MESSAGES</span> {
+ <span class="self">self</span>.<span class="ident">rx_readiness</span>.<span class="number">0</span>.<span class="ident">set_readiness</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">empty</span>()).<span class="ident">unwrap</span>();
+ <span class="ident">CURRENT_LOOP</span>.<span class="ident">set</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="op">||</span> <span class="self">self</span>.<span class="ident">consume_queue</span>());
+ } <span class="kw">else</span> <span class="kw">if</span> <span class="ident">token</span> <span class="op">==</span> <span class="ident">TOKEN_FUTURE</span> {
+ <span class="self">self</span>.<span class="ident">future_readiness</span>.<span class="number">0</span>.<span class="ident">set_readiness</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">empty</span>()).<span class="ident">unwrap</span>();
+ <span class="ident">fired</span> <span class="op">=</span> <span class="bool-val">true</span>;
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">dispatch</span>(<span class="ident">token</span>, <span class="ident">event</span>.<span class="ident">readiness</span>());
+ }
+ }
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"loop process - {} events, {:?}"</span>, <span class="ident">amt</span>, <span class="ident">after_poll</span>.<span class="ident">elapsed</span>());
+ <span class="kw">return</span> <span class="ident">fired</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">dispatch</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">token</span>: <span class="ident">mio</span>::<span class="ident">Token</span>, <span class="ident">ready</span>: <span class="ident">mio</span>::<span class="ident">Ready</span>) {
+ <span class="kw">let</span> <span class="ident">token</span> <span class="op">=</span> <span class="ident">usize</span>::<span class="ident">from</span>(<span class="ident">token</span>) <span class="op">-</span> <span class="ident">TOKEN_START</span>;
+ <span class="kw">if</span> <span class="ident">token</span> <span class="op">%</span> <span class="number">2</span> <span class="op">==</span> <span class="number">0</span> {
+ <span class="self">self</span>.<span class="ident">dispatch_io</span>(<span class="ident">token</span> <span class="op">/</span> <span class="number">2</span>, <span class="ident">ready</span>)
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">dispatch_task</span>(<span class="ident">token</span> <span class="op">/</span> <span class="number">2</span>)
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">dispatch_io</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>, <span class="ident">ready</span>: <span class="ident">mio</span>::<span class="ident">Ready</span>) {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">reader</span> <span class="op">=</span> <span class="prelude-val">None</span>;
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">writer</span> <span class="op">=</span> <span class="prelude-val">None</span>;
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">inner</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>();
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">io</span>) <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">io_dispatch</span>.<span class="ident">get_mut</span>(<span class="ident">token</span>) {
+ <span class="ident">io</span>.<span class="ident">readiness</span>.<span class="ident">fetch_or</span>(<span class="ident">ready2usize</span>(<span class="ident">ready</span>), <span class="ident">Ordering</span>::<span class="ident">Relaxed</span>);
+ <span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_writable</span>() {
+ <span class="ident">writer</span> <span class="op">=</span> <span class="ident">io</span>.<span class="ident">writer</span>.<span class="ident">take</span>();
+ }
+ <span class="kw">if</span> <span class="op">!</span>(<span class="ident">ready</span> <span class="op">&</span> (<span class="op">!</span><span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">writable</span>())).<span class="ident">is_empty</span>() {
+ <span class="ident">reader</span> <span class="op">=</span> <span class="ident">io</span>.<span class="ident">reader</span>.<span class="ident">take</span>();
+ }
+ }
+ <span class="ident">drop</span>(<span class="ident">inner</span>);
+ <span class="comment">// TODO: don't notify the same task twice</span>
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">reader</span>) <span class="op">=</span> <span class="ident">reader</span> {
+ <span class="self">self</span>.<span class="ident">notify_handle</span>(<span class="ident">reader</span>);
+ }
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">writer</span>) <span class="op">=</span> <span class="ident">writer</span> {
+ <span class="self">self</span>.<span class="ident">notify_handle</span>(<span class="ident">writer</span>);
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">dispatch_task</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>) {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">inner</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>();
+ <span class="kw">let</span> (<span class="ident">task</span>, <span class="ident">wake</span>) <span class="op">=</span> <span class="kw">match</span> <span class="ident">inner</span>.<span class="ident">task_dispatch</span>.<span class="ident">get_mut</span>(<span class="ident">token</span>) {
+ <span class="prelude-val">Some</span>(<span class="ident">slot</span>) <span class="op">=></span> (<span class="ident">slot</span>.<span class="ident">spawn</span>.<span class="ident">take</span>(), <span class="ident">slot</span>.<span class="ident">wake</span>.<span class="ident">take</span>()),
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="kw">return</span>,
+ };
+ <span class="kw">let</span> (<span class="kw-2">mut</span> <span class="ident">task</span>, <span class="ident">wake</span>) <span class="op">=</span> <span class="kw">match</span> (<span class="ident">task</span>, <span class="ident">wake</span>) {
+ (<span class="prelude-val">Some</span>(<span class="ident">task</span>), <span class="prelude-val">Some</span>(<span class="ident">wake</span>)) <span class="op">=></span> (<span class="ident">task</span>, <span class="ident">wake</span>),
+ _ <span class="op">=></span> <span class="kw">return</span>,
+ };
+ <span class="ident">wake</span>.<span class="number">0</span>.<span class="ident">set_readiness</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">empty</span>()).<span class="ident">unwrap</span>();
+ <span class="ident">drop</span>(<span class="ident">inner</span>);
+ <span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">CURRENT_LOOP</span>.<span class="ident">set</span>(<span class="self">self</span>, <span class="op">||</span> {
+ <span class="ident">task</span>.<span class="ident">poll_future_notify</span>(<span class="kw-2">&</span><span class="ident">wake</span>, <span class="number">0</span>)
+ });
+ <span class="kw">let</span> <span class="ident">_task_to_drop</span>;
+ <span class="ident">inner</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>();
+ <span class="kw">match</span> <span class="ident">res</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>) <span class="op">=></span> {
+ <span class="macro">assert</span><span class="macro">!</span>(<span class="ident">inner</span>.<span class="ident">task_dispatch</span>[<span class="ident">token</span>].<span class="ident">spawn</span>.<span class="ident">is_none</span>());
+ <span class="ident">inner</span>.<span class="ident">task_dispatch</span>[<span class="ident">token</span>].<span class="ident">spawn</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">task</span>);
+ <span class="ident">inner</span>.<span class="ident">task_dispatch</span>[<span class="ident">token</span>].<span class="ident">wake</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">wake</span>);
+ }
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(())) <span class="op">|</span>
+ <span class="prelude-val">Err</span>(()) <span class="op">=></span> {
+ <span class="ident">_task_to_drop</span> <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">task_dispatch</span>.<span class="ident">remove</span>(<span class="ident">token</span>);
+ }
+ }
+ <span class="ident">drop</span>(<span class="ident">inner</span>);
+ }
+
+ <span class="kw">fn</span> <span class="ident">consume_timeouts</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">now</span>: <span class="ident">Instant</span>) {
+ <span class="kw">loop</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">inner</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>();
+ <span class="kw">match</span> <span class="ident">inner</span>.<span class="ident">timer_heap</span>.<span class="ident">peek</span>() {
+ <span class="prelude-val">Some</span>(<span class="ident">head</span>) <span class="kw">if</span> <span class="ident">head</span>.<span class="number">0</span> <span class="op"><=</span> <span class="ident">now</span> <span class="op">=></span> {}
+ <span class="prelude-val">Some</span>(_) <span class="op">=></span> <span class="kw">break</span>,
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="kw">break</span>,
+ };
+ <span class="kw">let</span> (_, <span class="ident">slab_idx</span>) <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">timer_heap</span>.<span class="ident">pop</span>().<span class="ident">unwrap</span>();
+
+ <span class="macro">trace</span><span class="macro">!</span>(<span class="string">"firing timeout: {}"</span>, <span class="ident">slab_idx</span>);
+ <span class="ident">inner</span>.<span class="ident">timeouts</span>[<span class="ident">slab_idx</span>].<span class="number">0</span>.<span class="ident">take</span>().<span class="ident">unwrap</span>();
+ <span class="kw">let</span> <span class="ident">handle</span> <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">timeouts</span>[<span class="ident">slab_idx</span>].<span class="number">1</span>.<span class="ident">fire</span>();
+ <span class="ident">drop</span>(<span class="ident">inner</span>);
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">handle</span>) <span class="op">=</span> <span class="ident">handle</span> {
+ <span class="self">self</span>.<span class="ident">notify_handle</span>(<span class="ident">handle</span>);
+ }
+ }
+ }
+
+ <span class="doccomment">/// Method used to notify a task handle.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that this should be used instead of `handle.notify()` to ensure</span>
+ <span class="doccomment">/// that the `CURRENT_LOOP` variable is set appropriately.</span>
+ <span class="kw">fn</span> <span class="ident">notify_handle</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="ident">Task</span>) {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"notifying a task handle"</span>);
+ <span class="ident">CURRENT_LOOP</span>.<span class="ident">set</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="op">||</span> <span class="ident">handle</span>.<span class="ident">notify</span>());
+ }
+
+ <span class="kw">fn</span> <span class="ident">consume_queue</span>(<span class="kw-2">&</span><span class="self">self</span>) {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"consuming notification queue"</span>);
+ <span class="comment">// TODO: can we do better than `.unwrap()` here?</span>
+ <span class="kw">loop</span> {
+ <span class="kw">let</span> <span class="ident">msg</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">rx</span>.<span class="ident">borrow_mut</span>().<span class="ident">poll_stream_notify</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">rx_readiness</span>, <span class="number">0</span>).<span class="ident">unwrap</span>();
+ <span class="kw">match</span> <span class="ident">msg</span> {
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">Some</span>(<span class="ident">msg</span>)) <span class="op">=></span> <span class="self">self</span>.<span class="ident">notify</span>(<span class="ident">msg</span>),
+ <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">|</span>
+ <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="prelude-val">None</span>) <span class="op">=></span> <span class="kw">break</span>,
+ }
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">notify</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">msg</span>: <span class="ident">Message</span>) {
+ <span class="kw">match</span> <span class="ident">msg</span> {
+ <span class="ident">Message</span>::<span class="ident">DropSource</span>(<span class="ident">tok</span>) <span class="op">=></span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">drop_source</span>(<span class="ident">tok</span>),
+ <span class="ident">Message</span>::<span class="ident">Schedule</span>(<span class="ident">tok</span>, <span class="ident">wake</span>, <span class="ident">dir</span>) <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">task</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">schedule</span>(<span class="ident">tok</span>, <span class="ident">wake</span>, <span class="ident">dir</span>);
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">task</span>) <span class="op">=</span> <span class="ident">task</span> {
+ <span class="self">self</span>.<span class="ident">notify_handle</span>(<span class="ident">task</span>);
+ }
+ }
+ <span class="ident">Message</span>::<span class="ident">UpdateTimeout</span>(<span class="ident">t</span>, <span class="ident">handle</span>) <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">task</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">update_timeout</span>(<span class="ident">t</span>, <span class="ident">handle</span>);
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">task</span>) <span class="op">=</span> <span class="ident">task</span> {
+ <span class="self">self</span>.<span class="ident">notify_handle</span>(<span class="ident">task</span>);
+ }
+ }
+ <span class="ident">Message</span>::<span class="ident">ResetTimeout</span>(<span class="ident">t</span>, <span class="ident">at</span>) <span class="op">=></span> {
+ <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">reset_timeout</span>(<span class="ident">t</span>, <span class="ident">at</span>);
+ }
+ <span class="ident">Message</span>::<span class="ident">CancelTimeout</span>(<span class="ident">t</span>) <span class="op">=></span> {
+ <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">cancel_timeout</span>(<span class="ident">t</span>)
+ }
+ <span class="ident">Message</span>::<span class="ident">Run</span>(<span class="ident">r</span>) <span class="op">=></span> <span class="ident">r</span>.<span class="ident">call_box</span>(<span class="self">self</span>),
+ }
+ }
+
+ <span class="doccomment">/// Get the ID of this loop</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">id</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">CoreId</span> {
+ <span class="ident">CoreId</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">borrow</span>().<span class="ident">id</span>)
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="ident">Executor</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="kw">for</span> <span class="ident">Core</span>
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span> <span class="op">=</span> (), <span class="ident">Error</span> <span class="op">=</span> ()<span class="op">></span> <span class="op">+</span> <span class="lifetime">'static</span>,
+{
+ <span class="kw">fn</span> <span class="ident">execute</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">future</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="prelude-ty">Result</span><span class="op"><</span>(), <span class="ident">ExecuteError</span><span class="op"><</span><span class="ident">F</span><span class="op">>></span> {
+ <span class="self">self</span>.<span class="ident">handle</span>().<span class="ident">execute</span>(<span class="ident">future</span>)
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Core</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="ident">f</span>.<span class="ident">debug_struct</span>(<span class="string">"Core"</span>)
+ .<span class="ident">field</span>(<span class="string">"id"</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">id</span>())
+ .<span class="ident">finish</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Inner</span> {
+ <span class="kw">fn</span> <span class="ident">add_source</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">source</span>: <span class="kw-2">&</span><span class="ident">Evented</span>)
+ <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>(<span class="ident">Arc</span><span class="op"><</span><span class="ident">AtomicUsize</span><span class="op">></span>, <span class="ident">usize</span>)<span class="op">></span> {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"adding a new I/O source"</span>);
+ <span class="kw">let</span> <span class="ident">sched</span> <span class="op">=</span> <span class="ident">ScheduledIo</span> {
+ <span class="ident">readiness</span>: <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">AtomicUsize</span>::<span class="ident">new</span>(<span class="number">0</span>)),
+ <span class="ident">reader</span>: <span class="prelude-val">None</span>,
+ <span class="ident">writer</span>: <span class="prelude-val">None</span>,
+ };
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">capacity</span>() {
+ <span class="kw">let</span> <span class="ident">amt</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">len</span>();
+ <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">reserve_exact</span>(<span class="ident">amt</span>);
+ }
+ <span class="kw">let</span> <span class="ident">entry</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">vacant_entry</span>();
+ <span class="kw">let</span> <span class="ident">key</span> <span class="op">=</span> <span class="ident">entry</span>.<span class="ident">key</span>();
+ <span class="macro">try</span><span class="macro">!</span>(<span class="self">self</span>.<span class="ident">io</span>.<span class="ident">register</span>(<span class="ident">source</span>,
+ <span class="ident">mio</span>::<span class="ident">Token</span>(<span class="ident">TOKEN_START</span> <span class="op">+</span> <span class="ident">key</span> <span class="op">*</span> <span class="number">2</span>),
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>() <span class="op">|</span>
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">writable</span>() <span class="op">|</span>
+ <span class="ident">platform</span>::<span class="ident">all</span>(),
+ <span class="ident">mio</span>::<span class="ident">PollOpt</span>::<span class="ident">edge</span>()));
+ <span class="kw">let</span> <span class="ident">sched</span> <span class="op">=</span> <span class="ident">entry</span>.<span class="ident">insert</span>(<span class="ident">sched</span>);
+ <span class="prelude-val">Ok</span>((<span class="ident">sched</span>.<span class="ident">readiness</span>.<span class="ident">clone</span>(), <span class="ident">key</span>))
+ }
+
+ <span class="kw">fn</span> <span class="ident">deregister_source</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">source</span>: <span class="kw-2">&</span><span class="ident">Evented</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">deregister</span>(<span class="ident">source</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">drop_source</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>) {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"dropping I/O source: {}"</span>, <span class="ident">token</span>);
+ <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">remove</span>(<span class="ident">token</span>);
+ }
+
+ <span class="kw">fn</span> <span class="ident">schedule</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>, <span class="ident">wake</span>: <span class="ident">Task</span>, <span class="ident">dir</span>: <span class="ident">Direction</span>)
+ <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span> {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"scheduling direction for: {}"</span>, <span class="ident">token</span>);
+ <span class="kw">let</span> <span class="ident">sched</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">io_dispatch</span>.<span class="ident">get_mut</span>(<span class="ident">token</span>).<span class="ident">unwrap</span>();
+ <span class="kw">let</span> (<span class="ident">slot</span>, <span class="ident">ready</span>) <span class="op">=</span> <span class="kw">match</span> <span class="ident">dir</span> {
+ <span class="ident">Direction</span>::<span class="ident">Read</span> <span class="op">=></span> (<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">sched</span>.<span class="ident">reader</span>, <span class="op">!</span><span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">writable</span>()),
+ <span class="ident">Direction</span>::<span class="ident">Write</span> <span class="op">=></span> (<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">sched</span>.<span class="ident">writer</span>, <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">writable</span>()),
+ };
+ <span class="kw">if</span> <span class="ident">sched</span>.<span class="ident">readiness</span>.<span class="ident">load</span>(<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>) <span class="op">&</span> <span class="ident">ready2usize</span>(<span class="ident">ready</span>) <span class="op">!=</span> <span class="number">0</span> {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"cancelling block"</span>);
+ <span class="kw-2">*</span><span class="ident">slot</span> <span class="op">=</span> <span class="prelude-val">None</span>;
+ <span class="prelude-val">Some</span>(<span class="ident">wake</span>)
+ } <span class="kw">else</span> {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"blocking"</span>);
+ <span class="kw-2">*</span><span class="ident">slot</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">wake</span>);
+ <span class="prelude-val">None</span>
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">add_timeout</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">at</span>: <span class="ident">Instant</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">capacity</span>() {
+ <span class="kw">let</span> <span class="ident">len</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">len</span>();
+ <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">reserve_exact</span>(<span class="ident">len</span>);
+ }
+ <span class="kw">let</span> <span class="ident">entry</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">vacant_entry</span>();
+ <span class="kw">let</span> <span class="ident">key</span> <span class="op">=</span> <span class="ident">entry</span>.<span class="ident">key</span>();
+ <span class="kw">let</span> <span class="ident">slot</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">timer_heap</span>.<span class="ident">push</span>((<span class="ident">at</span>, <span class="ident">key</span>));
+ <span class="ident">entry</span>.<span class="ident">insert</span>((<span class="prelude-val">Some</span>(<span class="ident">slot</span>), <span class="ident">TimeoutState</span>::<span class="ident">NotFired</span>));
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"added a timeout: {}"</span>, <span class="ident">key</span>);
+ <span class="kw">return</span> <span class="ident">key</span>;
+ }
+
+ <span class="kw">fn</span> <span class="ident">update_timeout</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>, <span class="ident">handle</span>: <span class="ident">Task</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span> {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"updating a timeout: {}"</span>, <span class="ident">token</span>);
+ <span class="self">self</span>.<span class="ident">timeouts</span>[<span class="ident">token</span>].<span class="number">1</span>.<span class="ident">block</span>(<span class="ident">handle</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">reset_timeout</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>, <span class="ident">at</span>: <span class="ident">Instant</span>) {
+ <span class="kw">let</span> <span class="ident">pair</span> <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">timeouts</span>[<span class="ident">token</span>];
+ <span class="comment">// TODO: avoid remove + push and instead just do one sift of the heap?</span>
+ <span class="comment">// In theory we could update it in place and then do the percolation</span>
+ <span class="comment">// as necessary</span>
+ <span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">slot</span>) <span class="op">=</span> <span class="ident">pair</span>.<span class="number">0</span>.<span class="ident">take</span>() {
+ <span class="self">self</span>.<span class="ident">timer_heap</span>.<span class="ident">remove</span>(<span class="ident">slot</span>);
+ }
+ <span class="kw">let</span> <span class="ident">slot</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">timer_heap</span>.<span class="ident">push</span>((<span class="ident">at</span>, <span class="ident">token</span>));
+ <span class="kw-2">*</span><span class="ident">pair</span> <span class="op">=</span> (<span class="prelude-val">Some</span>(<span class="ident">slot</span>), <span class="ident">TimeoutState</span>::<span class="ident">NotFired</span>);
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"set a timeout: {}"</span>, <span class="ident">token</span>);
+ }
+
+ <span class="kw">fn</span> <span class="ident">cancel_timeout</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">token</span>: <span class="ident">usize</span>) {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"cancel a timeout: {}"</span>, <span class="ident">token</span>);
+ <span class="kw">let</span> <span class="ident">pair</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">timeouts</span>.<span class="ident">remove</span>(<span class="ident">token</span>);
+ <span class="kw">if</span> <span class="kw">let</span> (<span class="prelude-val">Some</span>(<span class="ident">slot</span>), <span class="ident">_state</span>) <span class="op">=</span> <span class="ident">pair</span> {
+ <span class="self">self</span>.<span class="ident">timer_heap</span>.<span class="ident">remove</span>(<span class="ident">slot</span>);
+ }
+ }
+
+ <span class="kw">fn</span> <span class="ident">spawn</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">future</span>: <span class="ident">Box</span><span class="op"><</span><span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span>(), <span class="ident">Error</span><span class="op">=</span>()<span class="op">>></span>) {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">task_dispatch</span>.<span class="ident">len</span>() <span class="op">==</span> <span class="self">self</span>.<span class="ident">task_dispatch</span>.<span class="ident">capacity</span>() {
+ <span class="kw">let</span> <span class="ident">len</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">task_dispatch</span>.<span class="ident">len</span>();
+ <span class="self">self</span>.<span class="ident">task_dispatch</span>.<span class="ident">reserve_exact</span>(<span class="ident">len</span>);
+ }
+ <span class="kw">let</span> <span class="ident">entry</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">task_dispatch</span>.<span class="ident">vacant_entry</span>();
+ <span class="kw">let</span> <span class="ident">token</span> <span class="op">=</span> <span class="ident">TOKEN_START</span> <span class="op">+</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">entry</span>.<span class="ident">key</span>() <span class="op">+</span> <span class="number">1</span>;
+ <span class="kw">let</span> <span class="ident">pair</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Registration</span>::<span class="ident">new2</span>();
+ <span class="self">self</span>.<span class="ident">io</span>.<span class="ident">register</span>(<span class="kw-2">&</span><span class="ident">pair</span>.<span class="number">0</span>,
+ <span class="ident">mio</span>::<span class="ident">Token</span>(<span class="ident">token</span>),
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>(),
+ <span class="ident">mio</span>::<span class="ident">PollOpt</span>::<span class="ident">level</span>())
+ .<span class="ident">expect</span>(<span class="string">"cannot fail future registration with mio"</span>);
+ <span class="kw">let</span> <span class="ident">unpark</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">MySetReadiness</span>(<span class="ident">pair</span>.<span class="number">1</span>));
+ <span class="ident">unpark</span>.<span class="ident">notify</span>(<span class="number">0</span>);
+ <span class="ident">entry</span>.<span class="ident">insert</span>(<span class="ident">ScheduledTask</span> {
+ <span class="ident">spawn</span>: <span class="prelude-val">Some</span>(<span class="ident">executor</span>::<span class="ident">spawn</span>(<span class="ident">future</span>)),
+ <span class="ident">wake</span>: <span class="prelude-val">Some</span>(<span class="ident">unpark</span>),
+ <span class="ident">_registration</span>: <span class="ident">pair</span>.<span class="number">0</span>,
+ });
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Remote</span> {
+ <span class="kw">fn</span> <span class="ident">send</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">msg</span>: <span class="ident">Message</span>) {
+ <span class="self">self</span>.<span class="ident">with_loop</span>(<span class="op">|</span><span class="ident">lp</span><span class="op">|</span> {
+ <span class="kw">match</span> <span class="ident">lp</span> {
+ <span class="prelude-val">Some</span>(<span class="ident">lp</span>) <span class="op">=></span> {
+ <span class="comment">// We want to make sure that all messages are received in</span>
+ <span class="comment">// order, so we need to consume pending messages before</span>
+ <span class="comment">// delivering this message to the core. The actually</span>
+ <span class="comment">// `consume_queue` function, however, can be somewhat slow</span>
+ <span class="comment">// right now where receiving on a channel will acquire a</span>
+ <span class="comment">// lock and block the current task.</span>
+ <span class="comment">//</span>
+ <span class="comment">// To speed this up check the message queue's readiness as a</span>
+ <span class="comment">// sort of preflight check to see if we've actually got any</span>
+ <span class="comment">// messages. This should just involve some atomics and if it</span>
+ <span class="comment">// comes back false then we know for sure there are no</span>
+ <span class="comment">// pending messages, so we can immediately deliver our</span>
+ <span class="comment">// message.</span>
+ <span class="kw">if</span> <span class="ident">lp</span>.<span class="ident">rx_readiness</span>.<span class="number">0</span>.<span class="ident">readiness</span>().<span class="ident">is_readable</span>() {
+ <span class="ident">lp</span>.<span class="ident">consume_queue</span>();
+ }
+ <span class="ident">lp</span>.<span class="ident">notify</span>(<span class="ident">msg</span>);
+ }
+ <span class="prelude-val">None</span> <span class="op">=></span> {
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">tx</span>.<span class="ident">unbounded_send</span>(<span class="ident">msg</span>) {
+ <span class="prelude-val">Ok</span>(()) <span class="op">=></span> {}
+
+ <span class="comment">// TODO: this error should punt upwards and we should</span>
+ <span class="comment">// notify the caller that the message wasn't</span>
+ <span class="comment">// received. This is tokio-core#17</span>
+ <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> <span class="ident">drop</span>(<span class="ident">e</span>),
+ }
+ }
+ }
+ })
+ }
+
+ <span class="kw">fn</span> <span class="ident">with_loop</span><span class="op"><</span><span class="ident">F</span>, <span class="ident">R</span><span class="op">></span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="ident">R</span>
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnOnce</span>(<span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">Core</span><span class="op">></span>) <span class="op">-></span> <span class="ident">R</span>
+ {
+ <span class="kw">if</span> <span class="ident">CURRENT_LOOP</span>.<span class="ident">is_set</span>() {
+ <span class="ident">CURRENT_LOOP</span>.<span class="ident">with</span>(<span class="op">|</span><span class="ident">lp</span><span class="op">|</span> {
+ <span class="kw">let</span> <span class="ident">same</span> <span class="op">=</span> <span class="ident">lp</span>.<span class="ident">inner</span>.<span class="ident">borrow</span>().<span class="ident">id</span> <span class="op">==</span> <span class="self">self</span>.<span class="ident">id</span>;
+ <span class="kw">if</span> <span class="ident">same</span> {
+ <span class="ident">f</span>(<span class="prelude-val">Some</span>(<span class="ident">lp</span>))
+ } <span class="kw">else</span> {
+ <span class="ident">f</span>(<span class="prelude-val">None</span>)
+ }
+ })
+ } <span class="kw">else</span> {
+ <span class="ident">f</span>(<span class="prelude-val">None</span>)
+ }
+ }
+
+ <span class="doccomment">/// Spawns a new future into the event loop this remote is associated with.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function takes a closure which is executed within the context of</span>
+ <span class="doccomment">/// the I/O loop itself. The future returned by the closure will be</span>
+ <span class="doccomment">/// scheduled on the event loop and run to completion.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that while the closure, `F`, requires the `Send` bound as it might</span>
+ <span class="doccomment">/// cross threads, the future `R` does not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will **not** catch panics from polling the future `f`. If</span>
+ <span class="doccomment">/// the future panics then it's the responsibility of the caller to catch</span>
+ <span class="doccomment">/// that panic and handle it as appropriate.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">spawn</span><span class="op"><</span><span class="ident">F</span>, <span class="ident">R</span><span class="op">></span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="ident">F</span>)
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnOnce</span>(<span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">R</span> <span class="op">+</span> <span class="ident">Send</span> <span class="op">+</span> <span class="lifetime">'static</span>,
+ <span class="ident">R</span>: <span class="ident">IntoFuture</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span>(), <span class="ident">Error</span><span class="op">=</span>()<span class="op">></span>,
+ <span class="ident">R</span>::<span class="ident">Future</span>: <span class="lifetime">'static</span>,
+ {
+ <span class="self">self</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">Run</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="op">|</span><span class="ident">lp</span>: <span class="kw-2">&</span><span class="ident">Core</span><span class="op">|</span> {
+ <span class="kw">let</span> <span class="ident">f</span> <span class="op">=</span> <span class="ident">f</span>(<span class="kw-2">&</span><span class="ident">lp</span>.<span class="ident">handle</span>());
+ <span class="ident">lp</span>.<span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">spawn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>.<span class="ident">into_future</span>()));
+ })));
+ }
+
+ <span class="doccomment">/// Return the ID of the represented Core</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">id</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">CoreId</span> {
+ <span class="ident">CoreId</span>(<span class="self">self</span>.<span class="ident">id</span>)
+ }
+
+ <span class="doccomment">/// Attempts to "promote" this remote to a handle, if possible.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function is intended for structures which typically work through a</span>
+ <span class="doccomment">/// `Remote` but want to optimize runtime when the remote doesn't actually</span>
+ <span class="doccomment">/// leave the thread of the original reactor. This will attempt to return a</span>
+ <span class="doccomment">/// handle if the `Remote` is on the same thread as the event loop and the</span>
+ <span class="doccomment">/// event loop is running.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this `Remote` has moved to a different thread or if the event loop is</span>
+ <span class="doccomment">/// running, then `None` may be returned. If you need to guarantee access to</span>
+ <span class="doccomment">/// a `Handle`, then you can call this function and fall back to using</span>
+ <span class="doccomment">/// `spawn` above if it returns `None`.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">handle</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Handle</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="ident">CURRENT_LOOP</span>.<span class="ident">is_set</span>() {
+ <span class="ident">CURRENT_LOOP</span>.<span class="ident">with</span>(<span class="op">|</span><span class="ident">lp</span><span class="op">|</span> {
+ <span class="kw">let</span> <span class="ident">same</span> <span class="op">=</span> <span class="ident">lp</span>.<span class="ident">inner</span>.<span class="ident">borrow</span>().<span class="ident">id</span> <span class="op">==</span> <span class="self">self</span>.<span class="ident">id</span>;
+ <span class="kw">if</span> <span class="ident">same</span> {
+ <span class="prelude-val">Some</span>(<span class="ident">lp</span>.<span class="ident">handle</span>())
+ } <span class="kw">else</span> {
+ <span class="prelude-val">None</span>
+ }
+ })
+ } <span class="kw">else</span> {
+ <span class="prelude-val">None</span>
+ }
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="ident">Executor</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="kw">for</span> <span class="ident">Remote</span>
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span> <span class="op">=</span> (), <span class="ident">Error</span> <span class="op">=</span> ()<span class="op">></span> <span class="op">+</span> <span class="ident">Send</span> <span class="op">+</span> <span class="lifetime">'static</span>,
+{
+ <span class="kw">fn</span> <span class="ident">execute</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">future</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="prelude-ty">Result</span><span class="op"><</span>(), <span class="ident">ExecuteError</span><span class="op"><</span><span class="ident">F</span><span class="op">>></span> {
+ <span class="self">self</span>.<span class="ident">spawn</span>(<span class="op">|</span>_<span class="op">|</span> <span class="ident">future</span>);
+ <span class="prelude-val">Ok</span>(())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Remote</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="ident">f</span>.<span class="ident">debug_struct</span>(<span class="string">"Remote"</span>)
+ .<span class="ident">field</span>(<span class="string">"id"</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">id</span>())
+ .<span class="ident">finish</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Handle</span> {
+ <span class="doccomment">/// Returns a reference to the underlying remote handle to the event loop.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">remote</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">Remote</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">remote</span>
+ }
+
+ <span class="doccomment">/// Spawns a new future on the event loop this handle is associated with.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will **not** catch panics from polling the future `f`. If</span>
+ <span class="doccomment">/// the future panics then it's the responsibility of the caller to catch</span>
+ <span class="doccomment">/// that panic and handle it as appropriate.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">spawn</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="ident">F</span>)
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span>(), <span class="ident">Error</span><span class="op">=</span>()<span class="op">></span> <span class="op">+</span> <span class="lifetime">'static</span>,
+ {
+ <span class="kw">let</span> <span class="ident">inner</span> <span class="op">=</span> <span class="kw">match</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">upgrade</span>() {
+ <span class="prelude-val">Some</span>(<span class="ident">inner</span>) <span class="op">=></span> <span class="ident">inner</span>,
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="kw">return</span>,
+ };
+ <span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">spawn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>));
+ }
+
+ <span class="doccomment">/// Spawns a closure on this event loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function is a convenience wrapper around the `spawn` function above</span>
+ <span class="doccomment">/// for running a closure wrapped in `futures::lazy`. It will spawn the</span>
+ <span class="doccomment">/// function `f` provided onto the event loop, and continue to run the</span>
+ <span class="doccomment">/// future returned by `f` on the event loop as well.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will **not** catch panics from polling the future `f`. If</span>
+ <span class="doccomment">/// the future panics then it's the responsibility of the caller to catch</span>
+ <span class="doccomment">/// that panic and handle it as appropriate.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">spawn_fn</span><span class="op"><</span><span class="ident">F</span>, <span class="ident">R</span><span class="op">></span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="ident">F</span>)
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnOnce</span>() <span class="op">-></span> <span class="ident">R</span> <span class="op">+</span> <span class="lifetime">'static</span>,
+ <span class="ident">R</span>: <span class="ident">IntoFuture</span><span class="op"><</span><span class="ident">Item</span><span class="op">=</span>(), <span class="ident">Error</span><span class="op">=</span>()<span class="op">></span> <span class="op">+</span> <span class="lifetime">'static</span>,
+ {
+ <span class="self">self</span>.<span class="ident">spawn</span>(<span class="ident">future</span>::<span class="ident">lazy</span>(<span class="ident">f</span>))
+ }
+
+ <span class="doccomment">/// Return the ID of the represented Core</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">id</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">CoreId</span> {
+ <span class="self">self</span>.<span class="ident">remote</span>.<span class="ident">id</span>()
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="ident">Executor</span><span class="op"><</span><span class="ident">F</span><span class="op">></span> <span class="kw">for</span> <span class="ident">Handle</span>
+ <span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Future</span><span class="op"><</span><span class="ident">Item</span> <span class="op">=</span> (), <span class="ident">Error</span> <span class="op">=</span> ()<span class="op">></span> <span class="op">+</span> <span class="lifetime">'static</span>,
+{
+ <span class="kw">fn</span> <span class="ident">execute</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">future</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="prelude-ty">Result</span><span class="op"><</span>(), <span class="ident">ExecuteError</span><span class="op"><</span><span class="ident">F</span><span class="op">>></span> {
+ <span class="self">self</span>.<span class="ident">spawn</span>(<span class="ident">future</span>);
+ <span class="prelude-val">Ok</span>(())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Handle</span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="ident">f</span>.<span class="ident">debug_struct</span>(<span class="string">"Handle"</span>)
+ .<span class="ident">field</span>(<span class="string">"id"</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">id</span>())
+ .<span class="ident">finish</span>()
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">TimeoutState</span> {
+ <span class="kw">fn</span> <span class="ident">block</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">handle</span>: <span class="ident">Task</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
+ <span class="ident">TimeoutState</span>::<span class="ident">Fired</span> <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="ident">handle</span>),
+ _ <span class="op">=></span> {}
+ }
+ <span class="kw-2">*</span><span class="self">self</span> <span class="op">=</span> <span class="ident">TimeoutState</span>::<span class="ident">Waiting</span>(<span class="ident">handle</span>);
+ <span class="prelude-val">None</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">fire</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Task</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="ident">mem</span>::<span class="ident">replace</span>(<span class="self">self</span>, <span class="ident">TimeoutState</span>::<span class="ident">Fired</span>) {
+ <span class="ident">TimeoutState</span>::<span class="ident">NotFired</span> <span class="op">=></span> <span class="prelude-val">None</span>,
+ <span class="ident">TimeoutState</span>::<span class="ident">Fired</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"fired twice?"</span>),
+ <span class="ident">TimeoutState</span>::<span class="ident">Waiting</span>(<span class="ident">handle</span>) <span class="op">=></span> <span class="prelude-val">Some</span>(<span class="ident">handle</span>),
+ }
+ }
+}
+
+<span class="kw">struct</span> <span class="ident">MySetReadiness</span>(<span class="ident">mio</span>::<span class="ident">SetReadiness</span>);
+
+<span class="kw">impl</span> <span class="ident">Notify</span> <span class="kw">for</span> <span class="ident">MySetReadiness</span> {
+ <span class="kw">fn</span> <span class="ident">notify</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">_id</span>: <span class="ident">usize</span>) {
+ <span class="self">self</span>.<span class="number">0</span>.<span class="ident">set_readiness</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>())
+ .<span class="ident">expect</span>(<span class="string">"failed to set readiness"</span>);
+ }
+}
+
+<span class="kw">trait</span> <span class="ident">FnBox</span>: <span class="ident">Send</span> <span class="op">+</span> <span class="lifetime">'static</span> {
+ <span class="kw">fn</span> <span class="ident">call_box</span>(<span class="self">self</span>: <span class="ident">Box</span><span class="op"><</span><span class="self">Self</span><span class="op">></span>, <span class="ident">lp</span>: <span class="kw-2">&</span><span class="ident">Core</span>);
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">F</span>: <span class="ident">FnOnce</span>(<span class="kw-2">&</span><span class="ident">Core</span>) <span class="op">+</span> <span class="ident">Send</span> <span class="op">+</span> <span class="lifetime">'static</span><span class="op">></span> <span class="ident">FnBox</span> <span class="kw">for</span> <span class="ident">F</span> {
+ <span class="kw">fn</span> <span class="ident">call_box</span>(<span class="self">self</span>: <span class="ident">Box</span><span class="op"><</span><span class="self">Self</span><span class="op">></span>, <span class="ident">lp</span>: <span class="kw-2">&</span><span class="ident">Core</span>) {
+ (<span class="kw-2">*</span><span class="self">self</span>)(<span class="ident">lp</span>)
+ }
+}
+
+<span class="kw">fn</span> <span class="ident">read_ready</span>() <span class="op">-></span> <span class="ident">mio</span>::<span class="ident">Ready</span> {
+ <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>() <span class="op">|</span> <span class="ident">platform</span>::<span class="ident">hup</span>()
+}
+
+<span class="kw">const</span> <span class="ident">READ</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span> <span class="op"><<</span> <span class="number">0</span>;
+<span class="kw">const</span> <span class="ident">WRITE</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span> <span class="op"><<</span> <span class="number">1</span>;
+
+<span class="kw">fn</span> <span class="ident">ready2usize</span>(<span class="ident">ready</span>: <span class="ident">mio</span>::<span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bits</span> <span class="op">=</span> <span class="number">0</span>;
+ <span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_readable</span>() {
+ <span class="ident">bits</span> <span class="op">|=</span> <span class="ident">READ</span>;
+ }
+ <span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_writable</span>() {
+ <span class="ident">bits</span> <span class="op">|=</span> <span class="ident">WRITE</span>;
+ }
+ <span class="ident">bits</span> <span class="op">|</span> <span class="ident">platform</span>::<span class="ident">ready2usize</span>(<span class="ident">ready</span>)
+}
+
+<span class="kw">fn</span> <span class="ident">usize2ready</span>(<span class="ident">bits</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">mio</span>::<span class="ident">Ready</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">ready</span> <span class="op">=</span> <span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">empty</span>();
+ <span class="kw">if</span> <span class="ident">bits</span> <span class="op">&</span> <span class="ident">READ</span> <span class="op">!=</span> <span class="number">0</span> {
+ <span class="ident">ready</span>.<span class="ident">insert</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">readable</span>());
+ }
+ <span class="kw">if</span> <span class="ident">bits</span> <span class="op">&</span> <span class="ident">WRITE</span> <span class="op">!=</span> <span class="number">0</span> {
+ <span class="ident">ready</span>.<span class="ident">insert</span>(<span class="ident">mio</span>::<span class="ident">Ready</span>::<span class="ident">writable</span>());
+ }
+ <span class="ident">ready</span> <span class="op">|</span> <span class="ident">platform</span>::<span class="ident">usize2ready</span>(<span class="ident">bits</span>)
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">unix</span>, <span class="ident">not</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"fuchsia"</span>)))]</span>
+<span class="kw">mod</span> <span class="ident">platform</span> {
+ <span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">Ready</span>;
+ <span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">unix</span>::<span class="ident">UnixReady</span>;
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>))]</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">all</span>() <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="ident">hup</span>() <span class="op">|</span> <span class="ident">UnixReady</span>::<span class="ident">aio</span>()
+ }
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>)))]</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">all</span>() <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="ident">hup</span>()
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">hup</span>() <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="ident">UnixReady</span>::<span class="ident">hup</span>().<span class="ident">into</span>()
+ }
+
+ <span class="kw">const</span> <span class="ident">HUP</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span> <span class="op"><<</span> <span class="number">2</span>;
+ <span class="kw">const</span> <span class="ident">ERROR</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span> <span class="op"><<</span> <span class="number">3</span>;
+ <span class="kw">const</span> <span class="ident">AIO</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span> <span class="op"><<</span> <span class="number">4</span>;
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>))]</span>
+ <span class="kw">fn</span> <span class="ident">is_aio</span>(<span class="ident">ready</span>: <span class="kw-2">&</span><span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="ident">UnixReady</span>::<span class="ident">from</span>(<span class="kw-2">*</span><span class="ident">ready</span>).<span class="ident">is_aio</span>()
+ }
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>)))]</span>
+ <span class="kw">fn</span> <span class="ident">is_aio</span>(<span class="ident">_ready</span>: <span class="kw-2">&</span><span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="bool-val">false</span>
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ready2usize</span>(<span class="ident">ready</span>: <span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="kw">let</span> <span class="ident">ready</span> <span class="op">=</span> <span class="ident">UnixReady</span>::<span class="ident">from</span>(<span class="ident">ready</span>);
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bits</span> <span class="op">=</span> <span class="number">0</span>;
+ <span class="kw">if</span> <span class="ident">is_aio</span>(<span class="kw-2">&</span><span class="ident">ready</span>) {
+ <span class="ident">bits</span> <span class="op">|=</span> <span class="ident">AIO</span>;
+ }
+ <span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_error</span>() {
+ <span class="ident">bits</span> <span class="op">|=</span> <span class="ident">ERROR</span>;
+ }
+ <span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_hup</span>() {
+ <span class="ident">bits</span> <span class="op">|=</span> <span class="ident">HUP</span>;
+ }
+ <span class="ident">bits</span>
+ }
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"ios"</span>,
+ <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"macos"</span>))]</span>
+ <span class="kw">fn</span> <span class="ident">usize2ready_aio</span>(<span class="ident">ready</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">UnixReady</span>) {
+ <span class="ident">ready</span>.<span class="ident">insert</span>(<span class="ident">UnixReady</span>::<span class="ident">aio</span>());
+ }
+
+ <span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>,
+ <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"ios"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"macos"</span>)))]</span>
+ <span class="kw">fn</span> <span class="ident">usize2ready_aio</span>(<span class="ident">_ready</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">UnixReady</span>) {
+ <span class="comment">// aio not available here → empty</span>
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">usize2ready</span>(<span class="ident">bits</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">ready</span> <span class="op">=</span> <span class="ident">UnixReady</span>::<span class="ident">from</span>(<span class="ident">Ready</span>::<span class="ident">empty</span>());
+ <span class="kw">if</span> <span class="ident">bits</span> <span class="op">&</span> <span class="ident">AIO</span> <span class="op">!=</span> <span class="number">0</span> {
+ <span class="ident">usize2ready_aio</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">ready</span>);
+ }
+ <span class="kw">if</span> <span class="ident">bits</span> <span class="op">&</span> <span class="ident">HUP</span> <span class="op">!=</span> <span class="number">0</span> {
+ <span class="ident">ready</span>.<span class="ident">insert</span>(<span class="ident">UnixReady</span>::<span class="ident">hup</span>());
+ }
+ <span class="kw">if</span> <span class="ident">bits</span> <span class="op">&</span> <span class="ident">ERROR</span> <span class="op">!=</span> <span class="number">0</span> {
+ <span class="ident">ready</span>.<span class="ident">insert</span>(<span class="ident">UnixReady</span>::<span class="ident">error</span>());
+ }
+ <span class="ident">ready</span>.<span class="ident">into</span>()
+ }
+}
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">windows</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"fuchsia"</span>))]</span>
+<span class="kw">mod</span> <span class="ident">platform</span> {
+ <span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">Ready</span>;
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">all</span>() <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="comment">// No platform-specific Readinesses for Windows</span>
+ <span class="ident">Ready</span>::<span class="ident">empty</span>()
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">hup</span>() <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="ident">Ready</span>::<span class="ident">empty</span>()
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ready2usize</span>(<span class="ident">_r</span>: <span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">usize</span> {
+ <span class="number">0</span>
+ }
+
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">usize2ready</span>(<span class="ident">_r</span>: <span class="ident">usize</span>) <span class="op">-></span> <span class="ident">Ready</span> {
+ <span class="ident">Ready</span>::<span class="ident">empty</span>()
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/poll_evented.rs.html b/src/tokio_core/reactor/poll_evented.rs.html
new file mode 100644
index 0000000..0e73380
--- /dev/null
+++ b/src/tokio_core/reactor/poll_evented.rs.html
@@ -0,0 +1,941 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/poll_evented.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>poll_evented.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! Readiness tracking streams, backing I/O objects.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This module contains the core type which is used to back all I/O on object</span>
+<span class="doccomment">//! in `tokio-core`. The `PollEvented` type is the implementation detail of</span>
+<span class="doccomment">//! all I/O. Each `PollEvented` manages registration with a reactor,</span>
+<span class="doccomment">//! acquisition of a token, and tracking of the readiness state on the</span>
+<span class="doccomment">//! underlying I/O primitive.</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Read</span>, <span class="ident">Write</span>};
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::{<span class="ident">AtomicUsize</span>, <span class="ident">Ordering</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Async</span>, <span class="ident">Poll</span>};
+<span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">event</span>::<span class="ident">Evented</span>;
+<span class="kw">use</span> <span class="ident">mio</span>::<span class="ident">Ready</span>;
+<span class="kw">use</span> <span class="ident">tokio_io</span>::{<span class="ident">AsyncRead</span>, <span class="ident">AsyncWrite</span>};
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Handle</span>, <span class="ident">Remote</span>};
+<span class="kw">use</span> <span class="ident">reactor</span>::<span class="ident">io_token</span>::<span class="ident">IoToken</span>;
+
+<span class="doccomment">/// A concrete implementation of a stream of readiness notifications for I/O</span>
+<span class="doccomment">/// objects that originates from an event loop.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Created by the `PollEvented::new` method, each `PollEvented` is</span>
+<span class="doccomment">/// associated with a specific event loop and source of events that will be</span>
+<span class="doccomment">/// registered with an event loop.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// An instance of `PollEvented` is essentially the bridge between the `mio`</span>
+<span class="doccomment">/// world and the `tokio-core` world, providing abstractions to receive</span>
+<span class="doccomment">/// notifications about changes to an object's `mio::Ready` state.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Each readiness stream has a number of methods to test whether the underlying</span>
+<span class="doccomment">/// object is readable or writable. Once the methods return that an object is</span>
+<span class="doccomment">/// readable/writable, then it will continue to do so until the `need_read` or</span>
+<span class="doccomment">/// `need_write` methods are called.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// That is, this object is typically wrapped in another form of I/O object.</span>
+<span class="doccomment">/// It's the responsibility of the wrapper to inform the readiness stream when a</span>
+<span class="doccomment">/// "would block" I/O event is seen. The readiness stream will then take care of</span>
+<span class="doccomment">/// any scheduling necessary to get notified when the event is ready again.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// You can find more information about creating a custom I/O object [online].</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// [online]: https://tokio.rs/docs/going-deeper-tokio/core-low-level/#custom-io</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// ## Readiness to read/write</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// A `PollEvented` allows listening and waiting for an arbitrary `mio::Ready`</span>
+<span class="doccomment">/// instance, including the platform-specific contents of `mio::Ready`. At most</span>
+<span class="doccomment">/// two future tasks, however, can be waiting on a `PollEvented`. The</span>
+<span class="doccomment">/// `need_read` and `need_write` methods can block two separate tasks, one on</span>
+<span class="doccomment">/// reading and one on writing. Not all I/O events correspond to read/write,</span>
+<span class="doccomment">/// however!</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// To account for this a `PollEvented` gets a little interesting when working</span>
+<span class="doccomment">/// with an arbitrary instance of `mio::Ready` that may not map precisely to</span>
+<span class="doccomment">/// "write" and "read" tasks. Currently it is defined that instances of</span>
+<span class="doccomment">/// `mio::Ready` that do *not* return true from `is_writable` are all notified</span>
+<span class="doccomment">/// through `need_read`, or the read task.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// In other words, `poll_ready` with the `mio::UnixReady::hup` event will block</span>
+<span class="doccomment">/// the read task of this `PollEvented` if the `hup` event isn't available.</span>
+<span class="doccomment">/// Essentially a good rule of thumb is that if you're using the `poll_ready`</span>
+<span class="doccomment">/// method you want to also use `need_read` to signal blocking and you should</span>
+<span class="doccomment">/// otherwise probably avoid using two tasks on the same `PollEvented`.</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="ident">token</span>: <span class="ident">IoToken</span>,
+ <span class="ident">handle</span>: <span class="ident">Remote</span>,
+ <span class="ident">readiness</span>: <span class="ident">AtomicUsize</span>,
+ <span class="ident">io</span>: <span class="ident">E</span>,
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Evented</span> <span class="op">+</span> <span class="ident">fmt</span>::<span class="ident">Debug</span><span class="op">></span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
+ <span class="ident">f</span>.<span class="ident">debug_struct</span>(<span class="string">"PollEvented"</span>)
+ .<span class="ident">field</span>(<span class="string">"io"</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>)
+ .<span class="ident">finish</span>()
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Evented</span><span class="op">></span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="doccomment">/// Creates a new readiness stream associated with the provided</span>
+ <span class="doccomment">/// `loop_handle` and for the given `source`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method returns a future which will resolve to the readiness stream</span>
+ <span class="doccomment">/// when it's ready.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">io</span>: <span class="ident">E</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">>></span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">PollEvented</span> {
+ <span class="ident">token</span>: <span class="macro">try</span><span class="macro">!</span>(<span class="ident">IoToken</span>::<span class="ident">new</span>(<span class="kw-2">&</span><span class="ident">io</span>, <span class="ident">handle</span>)),
+ <span class="ident">handle</span>: <span class="ident">handle</span>.<span class="ident">remote</span>().<span class="ident">clone</span>(),
+ <span class="ident">readiness</span>: <span class="ident">AtomicUsize</span>::<span class="ident">new</span>(<span class="number">0</span>),
+ <span class="ident">io</span>: <span class="ident">io</span>,
+ })
+ }
+
+ <span class="doccomment">/// Deregisters this source of events from the reactor core specified.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method can optionally be called to unregister the underlying I/O</span>
+ <span class="doccomment">/// object with the event loop that the `handle` provided points to.</span>
+ <span class="doccomment">/// Typically this method is not required as this automatically happens when</span>
+ <span class="doccomment">/// `E` is dropped, but for some use cases the `E` object doesn't represent</span>
+ <span class="doccomment">/// an owned reference, so dropping it won't automatically unregister with</span>
+ <span class="doccomment">/// the event loop.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This consumes `self` as it will no longer provide events after the</span>
+ <span class="doccomment">/// method is called, and will likely return an error if this `PollEvented`</span>
+ <span class="doccomment">/// was created on a separate event loop from the `handle` specified.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">deregister</span>(<span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">inner</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">handle</span>.<span class="ident">inner</span>.<span class="ident">upgrade</span>() {
+ <span class="prelude-val">Some</span>(<span class="ident">inner</span>) <span class="op">=></span> <span class="ident">inner</span>,
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Ok</span>(()),
+ };
+ <span class="kw">let</span> <span class="ident">ret</span> <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">deregister_source</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>);
+ <span class="kw">return</span> <span class="ident">ret</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="doccomment">/// Tests to see if this source is ready to be read from or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this stream is not ready for a read then `NotReady` will be returned</span>
+ <span class="doccomment">/// and the current task will be scheduled to receive a notification when</span>
+ <span class="doccomment">/// the stream is readable again. In other words, this method is only safe</span>
+ <span class="doccomment">/// to call from within the context of a future's task, typically done in a</span>
+ <span class="doccomment">/// `Future::poll` method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This is mostly equivalent to `self.poll_ready(Ready::readable())`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if called outside the context of a future's</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">poll_ready</span>(<span class="kw">super</span>::<span class="ident">read_ready</span>())
+ .<span class="ident">map</span>(<span class="op">|</span>_<span class="op">|</span> ())
+ }
+
+ <span class="doccomment">/// Tests to see if this source is ready to be written to or not.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If this stream is not ready for a write then `NotReady` will be returned</span>
+ <span class="doccomment">/// and the current task will be scheduled to receive a notification when</span>
+ <span class="doccomment">/// the stream is writable again. In other words, this method is only safe</span>
+ <span class="doccomment">/// to call from within the context of a future's task, typically done in a</span>
+ <span class="doccomment">/// `Future::poll` method.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This is mostly equivalent to `self.poll_ready(Ready::writable())`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if called outside the context of a future's</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="self">self</span>.<span class="ident">poll_ready</span>(<span class="ident">Ready</span>::<span class="ident">writable</span>())
+ .<span class="ident">map</span>(<span class="op">|</span>_<span class="op">|</span> ())
+ }
+
+ <span class="doccomment">/// Test to see whether this source fulfills any condition listed in `mask`</span>
+ <span class="doccomment">/// provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `mask` given here is a mio `Ready` set of possible events. This can</span>
+ <span class="doccomment">/// contain any events like read/write but also platform-specific events</span>
+ <span class="doccomment">/// such as hup and error. The `mask` indicates events that are interested</span>
+ <span class="doccomment">/// in being ready.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If any event in `mask` is ready then it is returned through</span>
+ <span class="doccomment">/// `Async::Ready`. The `Ready` set returned is guaranteed to not be empty</span>
+ <span class="doccomment">/// and contains all events that are currently ready in the `mask` provided.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If no events are ready in the `mask` provided then the current task is</span>
+ <span class="doccomment">/// scheduled to receive a notification when any of them become ready. If</span>
+ <span class="doccomment">/// the `writable` event is contained within `mask` then this</span>
+ <span class="doccomment">/// `PollEvented`'s `write` task will be blocked and otherwise the `read`</span>
+ <span class="doccomment">/// task will be blocked. This is generally only relevant if you're working</span>
+ <span class="doccomment">/// with this `PollEvented` object on multiple tasks.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if called outside the context of a future's</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">poll_ready</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">mask</span>: <span class="ident">Ready</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span><span class="ident">Ready</span><span class="op">></span> {
+ <span class="kw">let</span> <span class="ident">bits</span> <span class="op">=</span> <span class="kw">super</span>::<span class="ident">ready2usize</span>(<span class="ident">mask</span>);
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">load</span>(<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>) <span class="op">&</span> <span class="ident">bits</span> {
+ <span class="number">0</span> <span class="op">=></span> {}
+ <span class="ident">n</span> <span class="op">=></span> <span class="kw">return</span> <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw">super</span>::<span class="ident">usize2ready</span>(<span class="ident">n</span>)),
+ }
+ <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">fetch_or</span>(<span class="self">self</span>.<span class="ident">token</span>.<span class="ident">take_readiness</span>(), <span class="ident">Ordering</span>::<span class="ident">SeqCst</span>);
+ <span class="kw">match</span> <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">load</span>(<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>) <span class="op">&</span> <span class="ident">bits</span> {
+ <span class="number">0</span> <span class="op">=></span> {
+ <span class="kw">if</span> <span class="ident">mask</span>.<span class="ident">is_writable</span>() {
+ <span class="self">self</span>.<span class="ident">need_write</span>();
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">need_read</span>();
+ }
+ <span class="ident">Async</span>::<span class="ident">NotReady</span>
+ }
+ <span class="ident">n</span> <span class="op">=></span> <span class="ident">Async</span>::<span class="ident">Ready</span>(<span class="kw">super</span>::<span class="ident">usize2ready</span>(<span class="ident">n</span>)),
+ }
+ }
+
+ <span class="doccomment">/// Indicates to this source of events that the corresponding I/O object is</span>
+ <span class="doccomment">/// no longer readable, but it needs to be.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function, like `poll_read`, is only safe to call from the context</span>
+ <span class="doccomment">/// of a future's task (typically in a `Future::poll` implementation). It</span>
+ <span class="doccomment">/// informs this readiness stream that the underlying object is no longer</span>
+ <span class="doccomment">/// readable, typically because a "would block" error was seen.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// *All* readiness bits associated with this stream except the writable bit</span>
+ <span class="doccomment">/// will be reset when this method is called. The current task is then</span>
+ <span class="doccomment">/// scheduled to receive a notification whenever anything changes other than</span>
+ <span class="doccomment">/// the writable bit. Note that this typically just means the readable bit</span>
+ <span class="doccomment">/// is used here, but if you're using a custom I/O object for events like</span>
+ <span class="doccomment">/// hup/error this may also be relevant.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that it is also only valid to call this method if `poll_read`</span>
+ <span class="doccomment">/// previously indicated that the object is readable. That is, this function</span>
+ <span class="doccomment">/// must always be paired with calls to `poll_read` previously.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if called outside the context of a future's</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">need_read</span>(<span class="kw-2">&</span><span class="self">self</span>) {
+ <span class="kw">let</span> <span class="ident">bits</span> <span class="op">=</span> <span class="kw">super</span>::<span class="ident">ready2usize</span>(<span class="kw">super</span>::<span class="ident">read_ready</span>());
+ <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">fetch_and</span>(<span class="op">!</span><span class="ident">bits</span>, <span class="ident">Ordering</span>::<span class="ident">SeqCst</span>);
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">schedule_read</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Indicates to this source of events that the corresponding I/O object is</span>
+ <span class="doccomment">/// no longer writable, but it needs to be.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function, like `poll_write`, is only safe to call from the context</span>
+ <span class="doccomment">/// of a future's task (typically in a `Future::poll` implementation). It</span>
+ <span class="doccomment">/// informs this readiness stream that the underlying object is no longer</span>
+ <span class="doccomment">/// writable, typically because a "would block" error was seen.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The flag indicating that this stream is writable is unset and the</span>
+ <span class="doccomment">/// current task is scheduled to receive a notification when the stream is</span>
+ <span class="doccomment">/// then again writable.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that it is also only valid to call this method if `poll_write`</span>
+ <span class="doccomment">/// previously indicated that the object is writable. That is, this function</span>
+ <span class="doccomment">/// must always be paired with calls to `poll_write` previously.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will panic if called outside the context of a future's</span>
+ <span class="doccomment">/// task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">need_write</span>(<span class="kw-2">&</span><span class="self">self</span>) {
+ <span class="kw">let</span> <span class="ident">bits</span> <span class="op">=</span> <span class="kw">super</span>::<span class="ident">ready2usize</span>(<span class="ident">Ready</span>::<span class="ident">writable</span>());
+ <span class="self">self</span>.<span class="ident">readiness</span>.<span class="ident">fetch_and</span>(<span class="op">!</span><span class="ident">bits</span>, <span class="ident">Ordering</span>::<span class="ident">SeqCst</span>);
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">schedule_write</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Returns a reference to the event loop handle that this readiness stream</span>
+ <span class="doccomment">/// is associated with.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">remote</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">Remote</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>
+ }
+
+ <span class="doccomment">/// Returns a shared reference to the underlying I/O object this readiness</span>
+ <span class="doccomment">/// stream is wrapping.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_ref</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">E</span> {
+ <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">io</span>
+ }
+
+ <span class="doccomment">/// Returns a mutable reference to the underlying I/O object this readiness</span>
+ <span class="doccomment">/// stream is wrapping.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">E</span> {
+ <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">io</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Read</span><span class="op">></span> <span class="ident">Read</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_mut</span>().<span class="ident">read</span>(<span class="ident">buf</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_read</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Write</span><span class="op">></span> <span class="ident">Write</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_mut</span>().<span class="ident">write</span>(<span class="ident">buf</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_write</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_mut</span>().<span class="ident">flush</span>();
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_write</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Read</span><span class="op">></span> <span class="ident">AsyncRead</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Write</span><span class="op">></span> <span class="ident">AsyncWrite</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="prelude-val">Ok</span>(().<span class="ident">into</span>())
+ }
+}
+
+<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span>: <span class="ident">Read</span> <span class="op">+</span> <span class="ident">Write</span><span class="op">></span> ::<span class="ident">io</span>::<span class="ident">Io</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">>></span>::<span class="ident">poll_read</span>(<span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">>></span>::<span class="ident">poll_write</span>(<span class="self">self</span>)
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span>, <span class="ident">E</span><span class="op">></span> <span class="ident">Read</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span>
+ <span class="kw">where</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">E</span>: <span class="ident">Read</span>,
+{
+ <span class="kw">fn</span> <span class="ident">read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_read</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_ref</span>().<span class="ident">read</span>(<span class="ident">buf</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_read</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span>, <span class="ident">E</span><span class="op">></span> <span class="ident">Write</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span>
+ <span class="kw">where</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">E</span>: <span class="ident">Write</span>,
+{
+ <span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_ref</span>().<span class="ident">write</span>(<span class="ident">buf</span>);
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_write</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+
+ <span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="kw">if</span> <span class="kw">let</span> <span class="ident">Async</span>::<span class="ident">NotReady</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">poll_write</span>() {
+ <span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>.<span class="ident">into</span>())
+ }
+ <span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">get_ref</span>().<span class="ident">flush</span>();
+ <span class="kw">if</span> <span class="ident">is_wouldblock</span>(<span class="kw-2">&</span><span class="ident">r</span>) {
+ <span class="self">self</span>.<span class="ident">need_write</span>();
+ }
+ <span class="kw">return</span> <span class="ident">r</span>
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span>, <span class="ident">E</span><span class="op">></span> <span class="ident">AsyncRead</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span>
+ <span class="kw">where</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">E</span>: <span class="ident">Read</span>,
+{
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span>, <span class="ident">E</span><span class="op">></span> <span class="ident">AsyncWrite</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span>
+ <span class="kw">where</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">E</span>: <span class="ident">Write</span>,
+{
+ <span class="kw">fn</span> <span class="ident">shutdown</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="prelude-val">Ok</span>(().<span class="ident">into</span>())
+ }
+}
+
+<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
+<span class="kw">impl</span><span class="op"><</span><span class="lifetime">'a</span>, <span class="ident">E</span><span class="op">></span> ::<span class="ident">io</span>::<span class="ident">Io</span> <span class="kw">for</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span>
+ <span class="kw">where</span> <span class="kw-2">&</span><span class="lifetime">'a</span> <span class="ident">E</span>: <span class="ident">Read</span> <span class="op">+</span> <span class="ident">Write</span>,
+{
+ <span class="kw">fn</span> <span class="ident">poll_read</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">>></span>::<span class="ident">poll_read</span>(<span class="self">self</span>)
+ }
+
+ <span class="kw">fn</span> <span class="ident">poll_write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Async</span><span class="op"><</span>()<span class="op">></span> {
+ <span class="op"><</span><span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">>></span>::<span class="ident">poll_write</span>(<span class="self">self</span>)
+ }
+}
+
+<span class="kw">fn</span> <span class="ident">is_wouldblock</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="ident">r</span>: <span class="kw-2">&</span><span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>) <span class="op">-></span> <span class="ident">bool</span> {
+ <span class="kw">match</span> <span class="kw-2">*</span><span class="ident">r</span> {
+ <span class="prelude-val">Ok</span>(_) <span class="op">=></span> <span class="bool-val">false</span>,
+ <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="op">=></span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">WouldBlock</span>,
+ }
+}
+
+<span class="kw">impl</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> <span class="ident">Drop</span> <span class="kw">for</span> <span class="ident">PollEvented</span><span class="op"><</span><span class="ident">E</span><span class="op">></span> {
+ <span class="kw">fn</span> <span class="ident">drop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) {
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">drop_source</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/timeout.rs.html b/src/tokio_core/reactor/timeout.rs.html
new file mode 100644
index 0000000..e16eb2d
--- /dev/null
+++ b/src/tokio_core/reactor/timeout.rs.html
@@ -0,0 +1,335 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/timeout.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>timeout.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+</pre><pre class="rust ">
+<span class="doccomment">//! Support for creating futures that represent timeouts.</span>
+<span class="doccomment">//!</span>
+<span class="doccomment">//! This module contains the `Timeout` type which is a future that will resolve</span>
+<span class="doccomment">//! at a particular point in the future.</span>
+
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::{<span class="ident">Duration</span>, <span class="ident">Instant</span>};
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">Poll</span>, <span class="ident">Async</span>};
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Remote</span>, <span class="ident">Handle</span>};
+<span class="kw">use</span> <span class="ident">reactor</span>::<span class="ident">timeout_token</span>::<span class="ident">TimeoutToken</span>;
+
+<span class="doccomment">/// A future representing the notification that a timeout has occurred.</span>
+<span class="doccomment">///</span>
+<span class="doccomment">/// Timeouts are created through the `Timeout::new` or</span>
+<span class="doccomment">/// `Timeout::new_at` methods indicating when a timeout should fire at.</span>
+<span class="doccomment">/// Note that timeouts are not intended for high resolution timers, but rather</span>
+<span class="doccomment">/// they will likely fire some granularity after the exact instant that they're</span>
+<span class="doccomment">/// otherwise indicated to fire at.</span>
+<span class="attribute">#[<span class="ident">must_use</span> <span class="op">=</span> <span class="string">"futures do nothing unless polled"</span>]</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Timeout</span> {
+ <span class="ident">token</span>: <span class="ident">TimeoutToken</span>,
+ <span class="ident">when</span>: <span class="ident">Instant</span>,
+ <span class="ident">handle</span>: <span class="ident">Remote</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">Timeout</span> {
+ <span class="doccomment">/// Creates a new timeout which will fire at `dur` time into the future.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will return a Result with the actual timeout object or an</span>
+ <span class="doccomment">/// error. The timeout object itself is then a future which will be</span>
+ <span class="doccomment">/// set to fire at the specified point in the future.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">dur</span>: <span class="ident">Duration</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">Timeout</span><span class="op">></span> {
+ <span class="ident">Timeout</span>::<span class="ident">new_at</span>(<span class="ident">Instant</span>::<span class="ident">now</span>() <span class="op">+</span> <span class="ident">dur</span>, <span class="ident">handle</span>)
+ }
+
+ <span class="doccomment">/// Creates a new timeout which will fire at the time specified by `at`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function will return a Result with the actual timeout object or an</span>
+ <span class="doccomment">/// error. The timeout object itself is then a future which will be</span>
+ <span class="doccomment">/// set to fire at the specified point in the future.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new_at</span>(<span class="ident">at</span>: <span class="ident">Instant</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">Timeout</span><span class="op">></span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">Timeout</span> {
+ <span class="ident">token</span>: <span class="macro">try</span><span class="macro">!</span>(<span class="ident">TimeoutToken</span>::<span class="ident">new</span>(<span class="ident">at</span>, <span class="kw-2">&</span><span class="ident">handle</span>)),
+ <span class="ident">when</span>: <span class="ident">at</span>,
+ <span class="ident">handle</span>: <span class="ident">handle</span>.<span class="ident">remote</span>().<span class="ident">clone</span>(),
+ })
+ }
+
+ <span class="doccomment">/// Resets this timeout to an new timeout which will fire at the time</span>
+ <span class="doccomment">/// specified by `at`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method is usable even of this instance of `Timeout` has "already</span>
+ <span class="doccomment">/// fired". That is, if this future has resolved, calling this method means</span>
+ <span class="doccomment">/// that the future will still re-resolve at the specified instant.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// If `at` is in the past then this future will immediately be resolved</span>
+ <span class="doccomment">/// (when `poll` is called).</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// Note that if any task is currently blocked on this future then that task</span>
+ <span class="doccomment">/// will be dropped. It is required to call `poll` again after this method</span>
+ <span class="doccomment">/// has been called to ensure that a task is blocked on this future.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">reset</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">at</span>: <span class="ident">Instant</span>) {
+ <span class="self">self</span>.<span class="ident">when</span> <span class="op">=</span> <span class="ident">at</span>;
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">reset_timeout</span>(<span class="self">self</span>.<span class="ident">when</span>, <span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ }
+
+ <span class="doccomment">/// Polls this `Timeout` instance to see if it's elapsed, assuming the</span>
+ <span class="doccomment">/// current time is specified by `now`.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// The `Future::poll` implementation for `Timeout` will call `Instant::now`</span>
+ <span class="doccomment">/// each time it's invoked, but in some contexts this can be a costly</span>
+ <span class="doccomment">/// operation. This method is provided to amortize the cost by avoiding</span>
+ <span class="doccomment">/// usage of `Instant::now`, assuming that it's been called elsewhere.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This function takes the assumed current time as the first parameter and</span>
+ <span class="doccomment">/// otherwise functions as this future's `poll` function. This will block a</span>
+ <span class="doccomment">/// task if one isn't already blocked or update a previous one if already</span>
+ <span class="doccomment">/// blocked.</span>
+ <span class="kw">fn</span> <span class="ident">poll_at</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">now</span>: <span class="ident">Instant</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="kw">if</span> <span class="self">self</span>.<span class="ident">when</span> <span class="op"><=</span> <span class="ident">now</span> {
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">Ready</span>(()))
+ } <span class="kw">else</span> {
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">update_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">Async</span>::<span class="ident">NotReady</span>)
+ }
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Future</span> <span class="kw">for</span> <span class="ident">Timeout</span> {
+ <span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> ();
+ <span class="kw">type</span> <span class="ident">Error</span> <span class="op">=</span> <span class="ident">io</span>::<span class="ident">Error</span>;
+
+ <span class="kw">fn</span> <span class="ident">poll</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">Poll</span><span class="op"><</span>(), <span class="ident">io</span>::<span class="ident">Error</span><span class="op">></span> {
+ <span class="comment">// TODO: is this fast enough?</span>
+ <span class="self">self</span>.<span class="ident">poll_at</span>(<span class="ident">Instant</span>::<span class="ident">now</span>())
+ }
+}
+
+<span class="kw">impl</span> <span class="ident">Drop</span> <span class="kw">for</span> <span class="ident">Timeout</span> {
+ <span class="kw">fn</span> <span class="ident">drop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) {
+ <span class="self">self</span>.<span class="ident">token</span>.<span class="ident">cancel_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>.<span class="ident">handle</span>);
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/tokio_core/reactor/timeout_token.rs.html b/src/tokio_core/reactor/timeout_token.rs.html
new file mode 100644
index 0000000..3b3469e
--- /dev/null
+++ b/src/tokio_core/reactor/timeout_token.rs.html
@@ -0,0 +1,237 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `src/reactor/timeout_token.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>timeout_token.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../../main.css" id="themeStyle">
+ <script src="../../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc source">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10">10</span>
+<span id="11">11</span>
+<span id="12">12</span>
+<span id="13">13</span>
+<span id="14">14</span>
+<span id="15">15</span>
+<span id="16">16</span>
+<span id="17">17</span>
+<span id="18">18</span>
+<span id="19">19</span>
+<span id="20">20</span>
+<span id="21">21</span>
+<span id="22">22</span>
+<span id="23">23</span>
+<span id="24">24</span>
+<span id="25">25</span>
+<span id="26">26</span>
+<span id="27">27</span>
+<span id="28">28</span>
+<span id="29">29</span>
+<span id="30">30</span>
+<span id="31">31</span>
+<span id="32">32</span>
+<span id="33">33</span>
+<span id="34">34</span>
+<span id="35">35</span>
+<span id="36">36</span>
+<span id="37">37</span>
+<span id="38">38</span>
+<span id="39">39</span>
+<span id="40">40</span>
+<span id="41">41</span>
+<span id="42">42</span>
+<span id="43">43</span>
+<span id="44">44</span>
+<span id="45">45</span>
+<span id="46">46</span>
+<span id="47">47</span>
+<span id="48">48</span>
+<span id="49">49</span>
+<span id="50">50</span>
+<span id="51">51</span>
+<span id="52">52</span>
+<span id="53">53</span>
+<span id="54">54</span>
+<span id="55">55</span>
+<span id="56">56</span>
+<span id="57">57</span>
+</pre><pre class="rust ">
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
+<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::<span class="ident">Instant</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::<span class="ident">task</span>;
+
+<span class="kw">use</span> <span class="ident">reactor</span>::{<span class="ident">Message</span>, <span class="ident">Handle</span>, <span class="ident">Remote</span>};
+
+<span class="doccomment">/// A token that identifies an active timeout.</span>
+<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>)]</span>
+<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TimeoutToken</span> {
+ <span class="ident">token</span>: <span class="ident">usize</span>,
+}
+
+<span class="kw">impl</span> <span class="ident">TimeoutToken</span> {
+ <span class="doccomment">/// Adds a new timeout to get fired at the specified instant, notifying the</span>
+ <span class="doccomment">/// specified task.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">at</span>: <span class="ident">Instant</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Handle</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TimeoutToken</span><span class="op">></span> {
+ <span class="kw">match</span> <span class="ident">handle</span>.<span class="ident">inner</span>.<span class="ident">upgrade</span>() {
+ <span class="prelude-val">Some</span>(<span class="ident">inner</span>) <span class="op">=></span> {
+ <span class="kw">let</span> <span class="ident">token</span> <span class="op">=</span> <span class="ident">inner</span>.<span class="ident">borrow_mut</span>().<span class="ident">add_timeout</span>(<span class="ident">at</span>);
+ <span class="prelude-val">Ok</span>(<span class="ident">TimeoutToken</span> { <span class="ident">token</span>: <span class="ident">token</span> })
+ }
+ <span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">Err</span>(<span class="ident">io</span>::<span class="ident">Error</span>::<span class="ident">new</span>(<span class="ident">io</span>::<span class="ident">ErrorKind</span>::<span class="ident">Other</span>, <span class="string">"event loop gone"</span>)),
+ }
+ }
+
+ <span class="doccomment">/// Updates a previously added timeout to notify a new task instead.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if the timeout specified was not created by this</span>
+ <span class="doccomment">/// loop handle's `add_timeout` method.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">update_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">UpdateTimeout</span>(<span class="self">self</span>.<span class="ident">token</span>, <span class="ident">task</span>::<span class="ident">current</span>()))
+ }
+
+ <span class="doccomment">/// Resets previously added (or fired) timeout to an new timeout</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if the timeout specified was not created by this</span>
+ <span class="doccomment">/// loop handle's `add_timeout` method.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">reset_timeout</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">at</span>: <span class="ident">Instant</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">ResetTimeout</span>(<span class="self">self</span>.<span class="ident">token</span>, <span class="ident">at</span>));
+ }
+
+ <span class="doccomment">/// Cancel a previously added timeout.</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// # Panics</span>
+ <span class="doccomment">///</span>
+ <span class="doccomment">/// This method will panic if the timeout specified was not created by this</span>
+ <span class="doccomment">/// loop handle's `add_timeout` method or if called multiple times.</span>
+ <span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">cancel_timeout</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">handle</span>: <span class="kw-2">&</span><span class="ident">Remote</span>) {
+ <span class="macro">debug</span><span class="macro">!</span>(<span class="string">"cancel timeout {}"</span>, <span class="self">self</span>.<span class="ident">token</span>);
+ <span class="ident">handle</span>.<span class="ident">send</span>(<span class="ident">Message</span>::<span class="ident">CancelTimeout</span>(<span class="self">self</span>.<span class="ident">token</span>))
+ }
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../../main.js"></script>
+ <script defer src="../../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/storage.js b/storage.js
new file mode 100644
index 0000000..0aa1065
--- /dev/null
+++ b/storage.js
@@ -0,0 +1,36 @@
+/*!
+ * Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+var currentTheme = document.getElementById("themeStyle");
+var mainTheme = document.getElementById("mainThemeStyle");
+
+function updateLocalStorage(name, value) {
+ if (typeof(Storage) !== "undefined") {
+ localStorage[name] = value;
+ } else {
+ // No Web Storage support so we do nothing
+ }
+}
+
+function getCurrentValue(name) {
+ if (typeof(Storage) !== "undefined" && localStorage[name] !== undefined) {
+ return localStorage[name];
+ }
+ return null;
+}
+
+function switchTheme(styleElem, mainStyleElem, newTheme) {
+ styleElem.href = mainStyleElem.href.replace("rustdoc.css", newTheme + ".css");
+ updateLocalStorage('theme', newTheme);
+}
+
+switchTheme(currentTheme, mainTheme, getCurrentValue('theme') || 'main');
diff --git a/theme.js b/theme.js
new file mode 100644
index 0000000..6515f81
--- /dev/null
+++ b/theme.js
@@ -0,0 +1,21 @@
+var themes = document.getElementById("theme-choices");
+var themePicker = document.getElementById("theme-picker");
+themePicker.onclick = function() {
+ if (themes.style.display === "block") {
+ themes.style.display = "none";
+ themePicker.style.borderBottomRightRadius = "3px";
+ themePicker.style.borderBottomLeftRadius = "3px";
+ } else {
+ themes.style.display = "block";
+ themePicker.style.borderBottomRightRadius = "0";
+ themePicker.style.borderBottomLeftRadius = "0";
+ }
+};
+["dark","main"].forEach(function(item) {
+ var but = document.createElement('button');
+ but.innerHTML = item;
+ but.onclick = function(el) {
+ switchTheme(currentTheme, mainTheme, item);
+ };
+ themes.appendChild(but);
+});
diff --git a/tokio_core/index.html b/tokio_core/index.html
new file mode 100644
index 0000000..0bb64c9
--- /dev/null
+++ b/tokio_core/index.html
@@ -0,0 +1,242 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `tokio_core` crate.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, tokio_core">
+
+ <title>tokio_core - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../dark.css">
+ <link rel="stylesheet" type="text/css" href="../main.css" id="themeStyle">
+ <script src="../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc mod">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Crate tokio_core</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#modules">Modules</a></li><li><a href="#macros">Macros</a></li></ul></div><p class='location'></p><script>window.sidebarCurrent = {name: 'tokio_core', ty: 'mod', relpath: '../'};</script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Crate <a class="mod" href=''>tokio_core</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../src/tokio_core/lib.rs.html#1-119' title='goto source code'>[src]</a></span></h1>
+<div class='docblock'><p><code>Future</code>-powered I/O at the core of Tokio</p>
+<p>This crate uses the <code>futures</code> crate to provide an event loop ("reactor
+core") which can be used to drive I/O like TCP and UDP, spawned future
+tasks, and other events like channels/timeouts. All asynchronous I/O is
+powered by the <code>mio</code> crate.</p>
+<p>The concrete types provided in this crate are relatively bare bones but are
+intended to be the essential foundation for further projects needing an
+event loop. In this crate you'll find:</p>
+<ul>
+<li>TCP, both streams and listeners</li>
+<li>UDP sockets</li>
+<li>Timeouts</li>
+<li>An event loop to run futures</li>
+</ul>
+<p>More functionality is likely to be added over time, but otherwise the crate
+is intended to be flexible, with the <code>PollEvented</code> type accepting any
+type that implements <code>mio::Evented</code>. For example, the <code>tokio-uds</code> crate
+uses <code>PollEvented</code> to provide support for Unix domain sockets.</p>
+<p>Some other important tasks covered by this crate are:</p>
+<ul>
+<li>
+<p>The ability to spawn futures into an event loop. The <code>Handle</code> and <code>Remote</code>
+types have a <code>spawn</code> method which allows executing a future on an event
+loop. The <code>Handle::spawn</code> method crucially does not require the future
+itself to be <code>Send</code>.</p>
+</li>
+<li>
+<p>The <code>Io</code> trait serves as an abstraction for future crates to build on top
+of. This packages up <code>Read</code> and <code>Write</code> functionality as well as the
+ability to poll for readiness on both ends.</p>
+</li>
+<li>
+<p>All I/O is futures-aware. If any action in this crate returns "not ready"
+or "would block", then the current future task is scheduled to receive a
+notification when it would otherwise make progress.</p>
+</li>
+</ul>
+<p>You can find more extensive documentation in terms of tutorials at
+<a href="https://tokio.rs">https://tokio.rs</a>.</p>
+<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
+<p>A simple TCP echo server:</p>
+
+<pre class="rust rust-example-rendered">
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">futures</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">tokio_core</span>;
+<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">tokio_io</span>;
+
+<span class="kw">use</span> <span class="ident">futures</span>::{<span class="ident">Future</span>, <span class="ident">Stream</span>};
+<span class="kw">use</span> <span class="ident">tokio_io</span>::<span class="ident">AsyncRead</span>;
+<span class="kw">use</span> <span class="ident">tokio_io</span>::<span class="ident">io</span>::<span class="ident">copy</span>;
+<span class="kw">use</span> <span class="ident">tokio_core</span>::<span class="ident">net</span>::<span class="ident">TcpListener</span>;
+<span class="kw">use</span> <span class="ident">tokio_core</span>::<span class="ident">reactor</span>::<span class="ident">Core</span>;
+
+<span class="kw">fn</span> <span class="ident">main</span>() {
+ <span class="comment">// Create the event loop that will drive this server</span>
+ <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">core</span> <span class="op">=</span> <span class="ident">Core</span>::<span class="ident">new</span>().<span class="ident">unwrap</span>();
+ <span class="kw">let</span> <span class="ident">handle</span> <span class="op">=</span> <span class="ident">core</span>.<span class="ident">handle</span>();
+
+ <span class="comment">// Bind the server's socket</span>
+ <span class="kw">let</span> <span class="ident">addr</span> <span class="op">=</span> <span class="string">"127.0.0.1:12345"</span>.<span class="ident">parse</span>().<span class="ident">unwrap</span>();
+ <span class="kw">let</span> <span class="ident">listener</span> <span class="op">=</span> <span class="ident">TcpListener</span>::<span class="ident">bind</span>(<span class="kw-2">&</span><span class="ident">addr</span>, <span class="kw-2">&</span><span class="ident">handle</span>).<span class="ident">unwrap</span>();
+
+ <span class="comment">// Pull out a stream of sockets for incoming connections</span>
+ <span class="kw">let</span> <span class="ident">server</span> <span class="op">=</span> <span class="ident">listener</span>.<span class="ident">incoming</span>().<span class="ident">for_each</span>(<span class="op">|</span>(<span class="ident">sock</span>, _)<span class="op">|</span> {
+ <span class="comment">// Split up the reading and writing parts of the</span>
+ <span class="comment">// socket</span>
+ <span class="kw">let</span> (<span class="ident">reader</span>, <span class="ident">writer</span>) <span class="op">=</span> <span class="ident">sock</span>.<span class="ident">split</span>();
+
+ <span class="comment">// A future that echos the data and returns how</span>
+ <span class="comment">// many bytes were copied...</span>
+ <span class="kw">let</span> <span class="ident">bytes_copied</span> <span class="op">=</span> <span class="ident">copy</span>(<span class="ident">reader</span>, <span class="ident">writer</span>);
+
+ <span class="comment">// ... after which we'll print what happened</span>
+ <span class="kw">let</span> <span class="ident">handle_conn</span> <span class="op">=</span> <span class="ident">bytes_copied</span>.<span class="ident">map</span>(<span class="op">|</span><span class="ident">amt</span><span class="op">|</span> {
+ <span class="macro">println</span><span class="macro">!</span>(<span class="string">"wrote {:?} bytes"</span>, <span class="ident">amt</span>)
+ }).<span class="ident">map_err</span>(<span class="op">|</span><span class="ident">err</span><span class="op">|</span> {
+ <span class="macro">println</span><span class="macro">!</span>(<span class="string">"IO error {:?}"</span>, <span class="ident">err</span>)
+ });
+
+ <span class="comment">// Spawn the future as a concurrent task</span>
+ <span class="ident">handle</span>.<span class="ident">spawn</span>(<span class="ident">handle_conn</span>);
+
+ <span class="prelude-val">Ok</span>(())
+ });
+
+ <span class="comment">// Spin up the server on the event loop</span>
+ <span class="ident">core</span>.<span class="ident">run</span>(<span class="ident">server</span>).<span class="ident">unwrap</span>();
+}</pre>
+</div><h2 id='modules' class='section-header'><a href="#modules">Modules</a></h2>
+<table>
+ <tr class=' module-item'>
+ <td><a class="mod" href="net/index.html"
+ title='mod tokio_core::net'>net</a></td>
+ <td class='docblock-short'>
+ <p>TCP/UDP bindings for <code>tokio-core</code></p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="mod" href="reactor/index.html"
+ title='mod tokio_core::reactor'>reactor</a></td>
+ <td class='docblock-short'>
+ <p>The core reactor driving all I/O</p>
+
+ </td>
+ </tr></table><h2 id='macros' class='section-header'><a href="#macros">Macros</a></h2>
+<table>
+ <tr class=' module-item'>
+ <td><a class="macro" href="macro.try_nb.html"
+ title='macro tokio_core::try_nb'>try_nb</a></td>
+ <td class='docblock-short'>
+ <p>A convenience macro for working with <code>io::Result<T></code> from the <code>Read</code> and
+<code>Write</code> traits.</p>
+
+ </td>
+ </tr></table></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../main.js"></script>
+ <script defer src="../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git "a/tokio_core/macro.try_nb\041.html" "b/tokio_core/macro.try_nb\041.html"
new file mode 100644
index 0000000..cc31fa3
--- /dev/null
+++ "b/tokio_core/macro.try_nb\041.html"
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=macro.try_nb.html">
+</head>
+<body>
+ <p>Redirecting to <a href="macro.try_nb.html">macro.try_nb.html</a>...</p>
+ <script>location.replace("macro.try_nb.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/macro.try_nb.html b/tokio_core/macro.try_nb.html
new file mode 100644
index 0000000..e3a6420
--- /dev/null
+++ b/tokio_core/macro.try_nb.html
@@ -0,0 +1,136 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `try_nb` macro in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, try_nb">
+
+ <title>tokio_core::try_nb - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../dark.css">
+ <link rel="stylesheet" type="text/css" href="../main.css" id="themeStyle">
+ <script src="../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc macro">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'><a href='index.html'>tokio_core</a></p><script>window.sidebarCurrent = {name: 'try_nb', ty: 'macro', relpath: ''};</script><script defer src="sidebar-items.js"></script>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Macro <a href='index.html'>tokio_core</a>::<wbr><a class="macro" href=''>try_nb</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../src/tokio_core/io/mod.rs.html#35-43' title='goto source code'>[src]</a></span></h1>
+<pre class="rust macro">
+<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">try_nb</span> {
+ (<span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>) <span class="op">=></span> { ... };
+}</pre>
+<div class='docblock'><p>A convenience macro for working with <code>io::Result<T></code> from the <code>Read</code> and
+<code>Write</code> traits.</p>
+<p>This macro takes <code>io::Result<T></code> as input, and returns <code>T</code> as the output. If
+the input type is of the <code>Err</code> variant, then <code>Poll::NotReady</code> is returned if
+it indicates <code>WouldBlock</code> or otherwise <code>Err</code> is returned.</p>
+</div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../main.js"></script>
+ <script defer src="../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/Incoming.t.html b/tokio_core/net/Incoming.t.html
new file mode 100644
index 0000000..9c81029
--- /dev/null
+++ b/tokio_core/net/Incoming.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Incoming.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Incoming.html">struct.Incoming.html</a>...</p>
+ <script>location.replace("struct.Incoming.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/RecvDgram.t.html b/tokio_core/net/RecvDgram.t.html
new file mode 100644
index 0000000..6fc423a
--- /dev/null
+++ b/tokio_core/net/RecvDgram.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.RecvDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.RecvDgram.html">struct.RecvDgram.html</a>...</p>
+ <script>location.replace("struct.RecvDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/SendDgram.t.html b/tokio_core/net/SendDgram.t.html
new file mode 100644
index 0000000..b5ad102
--- /dev/null
+++ b/tokio_core/net/SendDgram.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.SendDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.SendDgram.html">struct.SendDgram.html</a>...</p>
+ <script>location.replace("struct.SendDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/TcpListener.t.html b/tokio_core/net/TcpListener.t.html
new file mode 100644
index 0000000..3434754
--- /dev/null
+++ b/tokio_core/net/TcpListener.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpListener.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpListener.html">struct.TcpListener.html</a>...</p>
+ <script>location.replace("struct.TcpListener.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/TcpStream.t.html b/tokio_core/net/TcpStream.t.html
new file mode 100644
index 0000000..4716a01
--- /dev/null
+++ b/tokio_core/net/TcpStream.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpStream.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpStream.html">struct.TcpStream.html</a>...</p>
+ <script>location.replace("struct.TcpStream.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/TcpStreamNew.t.html b/tokio_core/net/TcpStreamNew.t.html
new file mode 100644
index 0000000..4b8289d
--- /dev/null
+++ b/tokio_core/net/TcpStreamNew.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpStreamNew.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpStreamNew.html">struct.TcpStreamNew.html</a>...</p>
+ <script>location.replace("struct.TcpStreamNew.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/UdpCodec.t.html b/tokio_core/net/UdpCodec.t.html
new file mode 100644
index 0000000..2274d16
--- /dev/null
+++ b/tokio_core/net/UdpCodec.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=trait.UdpCodec.html">
+</head>
+<body>
+ <p>Redirecting to <a href="trait.UdpCodec.html">trait.UdpCodec.html</a>...</p>
+ <script>location.replace("trait.UdpCodec.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/UdpFramed.t.html b/tokio_core/net/UdpFramed.t.html
new file mode 100644
index 0000000..15a771b
--- /dev/null
+++ b/tokio_core/net/UdpFramed.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.UdpFramed.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.UdpFramed.html">struct.UdpFramed.html</a>...</p>
+ <script>location.replace("struct.UdpFramed.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/UdpSocket.t.html b/tokio_core/net/UdpSocket.t.html
new file mode 100644
index 0000000..2d72edb
--- /dev/null
+++ b/tokio_core/net/UdpSocket.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.UdpSocket.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.UdpSocket.html">struct.UdpSocket.html</a>...</p>
+ <script>location.replace("struct.UdpSocket.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/index.html b/tokio_core/net/index.html
new file mode 100644
index 0000000..7750bb5
--- /dev/null
+++ b/tokio_core/net/index.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `net` mod in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, net">
+
+ <title>tokio_core::net - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc mod">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Module net</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#structs">Structs</a></li><li><a href="#traits">Traits</a></li></ul></div><p class='location'><a href='../index.html'>tokio_core</a></p><script>window.sidebarCurrent = {name: 'net', ty: 'mod', relpath: '../'};</script><script defer src="../sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Module <a href='../index.html'>tokio_core</a>::<wbr><a class="mod" href=''>net</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/mod.rs.html#1-11' title='goto source code'>[src]</a></span></h1>
+<div class='docblock'><p>TCP/UDP bindings for <code>tokio-core</code></p>
+<p>This module contains the TCP/UDP networking types, similar to the standard
+library, which can be used to implement networking protocols.</p>
+</div><h2 id='structs' class='section-header'><a href="#structs">Structs</a></h2>
+<table>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Incoming.html"
+ title='struct tokio_core::net::Incoming'>Incoming</a></td>
+ <td class='docblock-short'>
+ <p>Stream returned by the <code>TcpListener::incoming</code> function representing the
+stream of sockets received from a listener.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.RecvDgram.html"
+ title='struct tokio_core::net::RecvDgram'>RecvDgram</a></td>
+ <td class='docblock-short'>
+ <p>A future used to receive a datagram from a UDP socket.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.SendDgram.html"
+ title='struct tokio_core::net::SendDgram'>SendDgram</a></td>
+ <td class='docblock-short'>
+ <p>A future used to write the entire contents of some data to a UDP socket.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.TcpListener.html"
+ title='struct tokio_core::net::TcpListener'>TcpListener</a></td>
+ <td class='docblock-short'>
+ <p>An I/O object representing a TCP socket listening for incoming connections.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.TcpStream.html"
+ title='struct tokio_core::net::TcpStream'>TcpStream</a></td>
+ <td class='docblock-short'>
+ <p>An I/O object representing a TCP stream connected to a remote endpoint.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.TcpStreamNew.html"
+ title='struct tokio_core::net::TcpStreamNew'>TcpStreamNew</a></td>
+ <td class='docblock-short'>
+ <p>Future returned by <code>TcpStream::connect</code> which will resolve to a <code>TcpStream</code>
+when the stream is connected.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.UdpFramed.html"
+ title='struct tokio_core::net::UdpFramed'>UdpFramed</a></td>
+ <td class='docblock-short'>
+ <p>A unified <code>Stream</code> and <code>Sink</code> interface to an underlying <code>UdpSocket</code>, using
+the <code>UdpCodec</code> trait to encode and decode frames.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.UdpSocket.html"
+ title='struct tokio_core::net::UdpSocket'>UdpSocket</a></td>
+ <td class='docblock-short'>
+ <p>An I/O object representing a UDP socket.</p>
+
+ </td>
+ </tr></table><h2 id='traits' class='section-header'><a href="#traits">Traits</a></h2>
+<table>
+ <tr class=' module-item'>
+ <td><a class="trait" href="trait.UdpCodec.html"
+ title='trait tokio_core::net::UdpCodec'>UdpCodec</a></td>
+ <td class='docblock-short'>
+ <p>Encoding of frames via buffers.</p>
+
+ </td>
+ </tr></table></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/sidebar-items.js b/tokio_core/net/sidebar-items.js
new file mode 100644
index 0000000..63a6c53
--- /dev/null
+++ b/tokio_core/net/sidebar-items.js
@@ -0,0 +1 @@
+initSidebarItems({"struct":[["Incoming","Stream returned by the `TcpListener::incoming` function representing the stream of sockets received from a listener."],["RecvDgram","A future used to receive a datagram from a UDP socket."],["SendDgram","A future used to write the entire contents of some data to a UDP socket."],["TcpListener","An I/O object representing a TCP socket listening for incoming connections."],["TcpStream","An I/O object representing a TCP stream connected to a remote endpoint."],["TcpStreamNew","Future returned by `TcpStream::connect` which will resolve to a `TcpStream` when the stream is connected."],["UdpFramed","A unified `Stream` and `Sink` interface to an underlying `UdpSocket`, using the `UdpCodec` trait to encode and decode frames."],["UdpSocket","An I/O object representing a UDP socket."]],"trait":[["UdpCodec","Encoding of frames via buffers."]]});
\ No newline at end of file
diff --git a/tokio_core/net/struct.Incoming.html b/tokio_core/net/struct.Incoming.html
new file mode 100644
index 0000000..b34d218
--- /dev/null
+++ b/tokio_core/net/struct.Incoming.html
@@ -0,0 +1,213 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Incoming` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Incoming">
+
+ <title>tokio_core::net::Incoming - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Incoming</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Stream">Stream</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'Incoming', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>Incoming</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#29-31' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "streams do nothing unless polled"]
+</div>pub struct Incoming { /* fields omitted */ }</pre><div class='docblock'><p>Stream returned by the <code>TcpListener::incoming</code> function representing the
+stream of sockets received from a listener.</p>
+</div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Stream' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a> for <a class="struct" href="../../tokio_core/net/struct.Incoming.html" title="struct tokio_core::net::Incoming">Incoming</a></code><a href='#impl-Stream' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#238-245' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
+<div class='docblock'><p>The type of item this stream will yield on success.</p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error this stream may generate.</p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#242-244' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempt to pull out the next value of this stream, returning <code>None</code> if the stream is finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></h3><code class="content"><span class="where fmt-newline">impl<S> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, <S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>;</span></code></div></div><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait' class='fnname'>wait</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#244-248' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an iterator which blocks the current thread until each item of this stream is resolved. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait">Read more</a></p>
+</div><h4 id='method.into_future' class="method"><span id='into_future.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future' class='fnname'>into_future</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/future/struct.StreamFuture.html" title="struct futures::stream::future::StreamFuture">StreamFuture</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#291-295' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts this stream into a <code>Future</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map' class='fnname'>map</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map/struct.Map.html" title="struct futures::stream::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#316-321' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of type <code>T</code> to a stream of type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err' class='fnname'>map_err</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map_err/struct.MapErr.html" title="struct futures::stream::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#342-347' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of error type <code>T</code> to a stream of error type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err">Read more</a></p>
+</div><h4 id='method.filter' class="method"><span id='filter.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter' class='fnname'>filter</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter/struct.Filter.html" title="struct futures::stream::filter::Filter">Filter</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#372-377' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream according to the provided predicate. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter">Read more</a></p>
+</div><h4 id='method.filter_map' class="method"><span id='filter_map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map' class='fnname'>filter_map</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter_map/struct.FilterMap.html" title="struct futures::stream::filter_map::FilterMap">FilterMap</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><B>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#408-413' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream while simultaneously mapping them to a different type. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then' class='fnname'>then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/then/struct.Then.html" title="struct futures::stream::then::Then">Then</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#447-453' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the resulting item to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then' class='fnname'>and_then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/and_then/struct.AndThen.html" title="struct futures::stream::and_then::AndThen">AndThen</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#494-500' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the successful results to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else' class='fnname'>or_else</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/or_else/struct.OrElse.html" title="struct futures::stream::or_else::OrElse">OrElse</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#521-527' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when an error happens, passing the erroneous result to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else">Read more</a></p>
+</div><h4 id='method.collect' class="method"><span id='collect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect' class='fnname'>collect</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/collect/struct.Collect.html" title="struct futures::stream::collect::Collect">Collect</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#562-566' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Collect all of the values of this stream into a vector, returning a future representing the result of that computation. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect">Read more</a></p>
+</div><h4 id='method.concat2' class="method"><span id='concat2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2' class='fnname'>concat2</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat2.html" title="struct futures::stream::concat::Concat2">Concat2</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#598-603' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2">Read more</a></p>
+</div><h4 id='method.concat' class="method"><span id='concat.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat' class='fnname'>concat</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat.html" title="struct futures::stream::concat::Concat">Concat</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#638-643' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated since 0.1.14<p>: please use <code>Stream::concat2</code> instead</p>
+</div></div><div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat">Read more</a></p>
+</div><h4 id='method.fold' class="method"><span id='fold.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold' class='fnname'>fold</a><F, T, Fut>(self, init: T, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fold/struct.Fold.html" title="struct futures::stream::fold::Fold">Fold</a><Self, F, Fut, T> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(T, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> Fut,<br> Fut: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = T>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<Fut as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#668-675' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute an accumulating computation over a stream, collecting all the values into one final result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/flatten/struct.Flatten.html" title="struct futures::stream::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#710-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flattens a stream of streams into just one continuous stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten">Read more</a></p>
+</div><h4 id='method.skip_while' class="method"><span id='skip_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while' class='fnname'>skip_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip_while/struct.SkipWhile.html" title="struct futures::stream::skip_while::SkipWhile">SkipWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#725-731' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Skip elements on this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while">Read more</a></p>
+</div><h4 id='method.take_while' class="method"><span id='take_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while' class='fnname'>take_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take_while/struct.TakeWhile.html" title="struct futures::stream::take_while::TakeWhile">TakeWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#739-745' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Take elements from this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while">Read more</a></p>
+</div><h4 id='method.for_each' class="method"><span id='for_each.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each' class='fnname'>for_each</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/for_each/struct.ForEach.html" title="struct futures::stream::for_each::ForEach">ForEach</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#761-767' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Runs this stream to completion, executing the provided closure for each element on the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/from_err/struct.FromErr.html" title="struct futures::stream::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#780-784' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this stream's error to any error implementing <code>From</code> for this stream's <code>Error</code>, returning a new stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err">Read more</a></p>
+</div><h4 id='method.take' class="method"><span id='take.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take' class='fnname'>take</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take/struct.Take.html" title="struct futures::stream::take::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#796-800' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream of at most <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take">Read more</a></p>
+</div><h4 id='method.skip' class="method"><span id='skip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip' class='fnname'>skip</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip/struct.Skip.html" title="struct futures::stream::skip::Skip">Skip</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#811-815' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which skips <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fuse/struct.Fuse.html" title="struct futures::stream::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#832-836' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a stream such that <code>poll</code> will never again be called once it has finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse">Read more</a></p>
+</div><h4 id='method.by_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#857-861' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Borrows a stream, rather than consuming it. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/catch_unwind/struct.CatchUnwind.html" title="struct futures::stream::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#897-901' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.buffered' class="method"><span id='buffered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered' class='fnname'>buffered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffered/struct.Buffered.html" title="struct futures::stream::buffered::Buffered">Buffered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#917-922' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered">Read more</a></p>
+</div><h4 id='method.buffer_unordered' class="method"><span id='buffer_unordered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered' class='fnname'>buffer_unordered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffer_unordered/struct.BufferUnordered.html" title="struct futures::stream::buffer_unordered::BufferUnordered">BufferUnordered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#938-943' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures (unordered). <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered">Read more</a></p>
+</div><h4 id='method.merge' class="method"><span id='merge.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge' class='fnname'>merge</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/merge/struct.Merge.html" title="struct futures::stream::merge::Merge">Merge</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#952-957' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated<p>: functionality provided by <code>select</code> now</p>
+</div></div><div class='docblock'><p>An adapter for merging the output of two streams. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge">Read more</a></p>
+</div><h4 id='method.zip' class="method"><span id='zip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip' class='fnname'>zip</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/zip/struct.Zip.html" title="struct futures::stream::zip::Zip">Zip</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#964-969' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adapter for zipping two streams together. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip">Read more</a></p>
+</div><h4 id='method.chain' class="method"><span id='chain.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain' class='fnname'>chain</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chain/struct.Chain.html" title="struct futures::stream::chain::Chain">Chain</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#990-995' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Adapter for chaining two stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain">Read more</a></p>
+</div><h4 id='method.peekable' class="method"><span id='peekable.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable' class='fnname'>peekable</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/peek/struct.Peekable.html" title="struct futures::stream::peek::Peekable">Peekable</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1000-1004' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which exposes a <code>peek</code> method. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable">Read more</a></p>
+</div><h4 id='method.chunks' class="method"><span id='chunks.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks' class='fnname'>chunks</a>(self, capacity: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chunks/struct.Chunks.html" title="struct futures::stream::chunks::Chunks">Chunks</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1027-1031' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for chunking up items of the stream inside a vector. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select' class='fnname'>select</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/select/struct.Select.html" title="struct futures::stream::select::Select">Select</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1044-1049' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a stream that selects the next element from either this stream or the provided one, whichever is ready first. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select">Read more</a></p>
+</div><h4 id='method.forward' class="method"><span id='forward.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward' class='fnname'>forward</a><S>(self, sink: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/forward/struct.Forward.html" title="struct futures::stream::forward::Forward">Forward</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a><SinkItem = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1065-1071' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes after the given stream has been fully processed into the sink, including flushing. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward">Read more</a></p>
+</div><h4 id='method.split' class="method"><span id='split.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitSink.html" title="struct futures::stream::split::SplitSink">SplitSink</a><Self>, <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitStream.html" title="struct futures::stream::split::SplitStream">SplitStream</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1083-1087' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Splits this <code>Stream + Sink</code> object into separate <code>Stream</code> and <code>Sink</code> objects. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect/struct.Inspect.html" title="struct futures::stream::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1094-1099' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with each item of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect">Read more</a></p>
+</div><h4 id='method.inspect_err' class="method"><span id='inspect_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err' class='fnname'>inspect_err</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect_err/struct.InspectErr.html" title="struct futures::stream::inspect_err::InspectErr">InspectErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1106-1111' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the error of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.RecvDgram.html b/tokio_core/net/struct.RecvDgram.html
new file mode 100644
index 0000000..7cb1181
--- /dev/null
+++ b/tokio_core/net/struct.RecvDgram.html
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `RecvDgram` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, RecvDgram">
+
+ <title>tokio_core::net::RecvDgram - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct RecvDgram</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Future">Future</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'RecvDgram', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>RecvDgram</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#418' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "futures do nothing unless polled"]
+</div>pub struct RecvDgram<T>(_);</pre><div class='docblock'><p>A future used to receive a datagram from a UDP socket.</p>
+<p>This is created by the <code>UdpSocket::recv_dgram</code> method.</p>
+</div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Future' class='impl'><span class='in-band'><code>impl<T> <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a> for <a class="struct" href="../../tokio_core/net/struct.RecvDgram.html" title="struct tokio_core::net::RecvDgram">RecvDgram</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsMut.html" title="trait core::convert::AsMut">AsMut</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span></code><a href='#impl-Future' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#420-437' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a>, T, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
+<div class='docblock'><p>The type of value that this future will resolved with if it is successful. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item">Read more</a></p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error that this future will resolve with if it fails in a normal fashion. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error">Read more</a></p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#426-436' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Query this future to see if its value has become available, registering interest if it is not. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait' class='fnname'>wait</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#296-300' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Block the current thread until this future is resolved. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map' class='fnname'>map</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map/struct.Map.html" title="struct futures::future::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#370-375' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's result to a different type, returning a new future of the resulting type. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err' class='fnname'>map_err</a><F, E>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map_err/struct.MapErr.html" title="struct futures::future::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> E, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#410-415' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to a different error, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/from_err/struct.FromErr.html" title="struct futures::future::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#440-444' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to any error implementing <code>From</code> for this future's <code>Error</code>, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then' class='fnname'>then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/then/struct.Then.html" title="struct futures::future::then::Then">Then</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#484-490' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a future finished, passing the result of the future to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then' class='fnname'>and_then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/and_then/struct.AndThen.html" title="struct futures::future::and_then::AndThen">AndThen</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#525-531' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future after this one has resolved successfully. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else' class='fnname'>or_else</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/or_else/struct.OrElse.html" title="struct futures::future::or_else::OrElse">OrElse</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#566-572' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future if this one resolves with an error. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select' class='fnname'>select</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select/struct.Select.html" title="struct futures::future::select::Select">Select</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#624-631' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select">Read more</a></p>
+</div><h4 id='method.select2' class="method"><span id='select2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2' class='fnname'>select2</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select2/struct.Select2.html" title="struct futures::future::select2::Select2">Select2</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#670-674' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two differently-typed futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2">Read more</a></p>
+</div><h4 id='method.join' class="method"><span id='join.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join' class='fnname'>join</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join.html" title="struct futures::future::join::Join">Join</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#715-721' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Joins the result of two futures, waiting for them both to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join">Read more</a></p>
+</div><h4 id='method.join3' class="method"><span id='join3.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join3' class='fnname'>join3</a><B, C>(<br> self, <br> b: B, <br> c: C<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join3.html" title="struct futures::future::join::Join3">Join3</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#724-730' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join4' class="method"><span id='join4.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join4' class='fnname'>join4</a><B, C, D>(<br> self, <br> b: B, <br> c: C, <br> d: D<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join4.html" title="struct futures::future::join::Join4">Join4</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#733-741' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join5' class="method"><span id='join5.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join5' class='fnname'>join5</a><B, C, D, E>(<br> self, <br> b: B, <br> c: C, <br> d: D, <br> e: E<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join5.html" title="struct futures::future::join::Join5">Join5</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <E as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> E: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#744-754' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.into_stream' class="method"><span id='into_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream' class='fnname'>into_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/into_stream/struct.IntoStream.html" title="struct futures::future::into_stream::IntoStream">IntoStream</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#777-781' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Convert this future into a single element stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten/struct.Flatten.html" title="struct futures::future::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#819-829' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is itself another future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten">Read more</a></p>
+</div><h4 id='method.flatten_stream' class="method"><span id='flatten_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream' class='fnname'>flatten_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten_stream/struct.FlattenStream.html" title="struct futures::future::flatten_stream::FlattenStream">FlattenStream</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#859-864' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is a stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/fuse/struct.Fuse.html" title="struct futures::future::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#899-904' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a future such that <code>poll</code> will never again be called once it has completed. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/inspect/struct.Inspect.html" title="struct futures::future::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#922-927' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the item of a future, passing it on. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/catch_unwind/struct.CatchUnwind.html" title="struct futures::future::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#961-965' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.shared' class="method"><span id='shared.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared' class='fnname'>shared</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/shared/struct.Shared.html" title="struct futures::future::shared::Shared">Shared</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#1010-1014' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a cloneable handle to this future where all handles will resolve to the same result. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.SendDgram.html b/tokio_core/net/struct.SendDgram.html
new file mode 100644
index 0000000..864d330
--- /dev/null
+++ b/tokio_core/net/struct.SendDgram.html
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `SendDgram` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, SendDgram">
+
+ <title>tokio_core::net::SendDgram - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct SendDgram</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Future">Future</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'SendDgram', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>SendDgram</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#386' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "futures do nothing unless polled"]
+</div>pub struct SendDgram<T>(_);</pre><div class='docblock'><p>A future used to write the entire contents of some data to a UDP socket.</p>
+<p>This is created by the <code>UdpSocket::send_dgram</code> method.</p>
+</div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Future' class='impl'><span class='in-band'><code>impl<T> <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a> for <a class="struct" href="../../tokio_core/net/struct.SendDgram.html" title="struct tokio_core::net::SendDgram">SendDgram</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span></code><a href='#impl-Future' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#392-412' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a>, T<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
+<div class='docblock'><p>The type of value that this future will resolved with if it is successful. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item">Read more</a></p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error that this future will resolve with if it fails in a normal fashion. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error">Read more</a></p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a>, T<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#398-411' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Query this future to see if its value has become available, registering interest if it is not. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait' class='fnname'>wait</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#296-300' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Block the current thread until this future is resolved. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map' class='fnname'>map</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map/struct.Map.html" title="struct futures::future::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#370-375' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's result to a different type, returning a new future of the resulting type. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err' class='fnname'>map_err</a><F, E>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map_err/struct.MapErr.html" title="struct futures::future::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> E, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#410-415' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to a different error, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/from_err/struct.FromErr.html" title="struct futures::future::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#440-444' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to any error implementing <code>From</code> for this future's <code>Error</code>, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then' class='fnname'>then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/then/struct.Then.html" title="struct futures::future::then::Then">Then</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#484-490' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a future finished, passing the result of the future to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then' class='fnname'>and_then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/and_then/struct.AndThen.html" title="struct futures::future::and_then::AndThen">AndThen</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#525-531' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future after this one has resolved successfully. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else' class='fnname'>or_else</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/or_else/struct.OrElse.html" title="struct futures::future::or_else::OrElse">OrElse</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#566-572' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future if this one resolves with an error. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select' class='fnname'>select</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select/struct.Select.html" title="struct futures::future::select::Select">Select</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#624-631' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select">Read more</a></p>
+</div><h4 id='method.select2' class="method"><span id='select2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2' class='fnname'>select2</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select2/struct.Select2.html" title="struct futures::future::select2::Select2">Select2</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#670-674' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two differently-typed futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2">Read more</a></p>
+</div><h4 id='method.join' class="method"><span id='join.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join' class='fnname'>join</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join.html" title="struct futures::future::join::Join">Join</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#715-721' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Joins the result of two futures, waiting for them both to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join">Read more</a></p>
+</div><h4 id='method.join3' class="method"><span id='join3.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join3' class='fnname'>join3</a><B, C>(<br> self, <br> b: B, <br> c: C<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join3.html" title="struct futures::future::join::Join3">Join3</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#724-730' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join4' class="method"><span id='join4.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join4' class='fnname'>join4</a><B, C, D>(<br> self, <br> b: B, <br> c: C, <br> d: D<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join4.html" title="struct futures::future::join::Join4">Join4</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#733-741' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join5' class="method"><span id='join5.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join5' class='fnname'>join5</a><B, C, D, E>(<br> self, <br> b: B, <br> c: C, <br> d: D, <br> e: E<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join5.html" title="struct futures::future::join::Join5">Join5</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <E as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> E: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#744-754' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.into_stream' class="method"><span id='into_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream' class='fnname'>into_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/into_stream/struct.IntoStream.html" title="struct futures::future::into_stream::IntoStream">IntoStream</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#777-781' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Convert this future into a single element stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten/struct.Flatten.html" title="struct futures::future::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#819-829' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is itself another future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten">Read more</a></p>
+</div><h4 id='method.flatten_stream' class="method"><span id='flatten_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream' class='fnname'>flatten_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten_stream/struct.FlattenStream.html" title="struct futures::future::flatten_stream::FlattenStream">FlattenStream</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#859-864' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is a stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/fuse/struct.Fuse.html" title="struct futures::future::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#899-904' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a future such that <code>poll</code> will never again be called once it has completed. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/inspect/struct.Inspect.html" title="struct futures::future::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#922-927' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the item of a future, passing it on. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/catch_unwind/struct.CatchUnwind.html" title="struct futures::future::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#961-965' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.shared' class="method"><span id='shared.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared' class='fnname'>shared</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/shared/struct.Shared.html" title="struct futures::future::shared::Shared">Shared</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#1010-1014' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a cloneable handle to this future where all handles will resolve to the same result. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.TcpListener.html b/tokio_core/net/struct.TcpListener.html
new file mode 100644
index 0000000..452acd2
--- /dev/null
+++ b/tokio_core/net/struct.TcpListener.html
@@ -0,0 +1,223 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `TcpListener` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, TcpListener">
+
+ <title>tokio_core::net::TcpListener - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct TcpListener</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.bind">bind</a><a href="#method.accept">accept</a><a href="#method.accept_std">accept_std</a><a href="#method.from_listener">from_listener</a><a href="#method.poll_read">poll_read</a><a href="#method.local_addr">local_addr</a><a href="#method.incoming">incoming</a><a href="#method.set_ttl">set_ttl</a><a href="#method.ttl">ttl</a><a href="#method.set_only_v6">set_only_v6</a><a href="#method.only_v6">only_v6</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-AsRawFd">AsRawFd</a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'TcpListener', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>TcpListener</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#21-24' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct TcpListener { /* fields omitted */ }</pre><div class='docblock'><p>An I/O object representing a TCP socket listening for incoming connections.</p>
+<p>This object can be converted into a stream of incoming connections for
+various forms of processing.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/net/struct.TcpListener.html" title="struct tokio_core::net::TcpListener">TcpListener</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#33-230' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.bind' class="method"><span id='bind.v' class='invisible'><code>pub fn <a href='#method.bind' class='fnname'>bind</a>(addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/net/struct.TcpListener.html" title="struct tokio_core::net::TcpListener">TcpListener</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#38-41' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a new TCP listener associated with this event loop.</p>
+<p>The TCP listener will bind to the provided <code>addr</code> address, if available.
+If the result is <code>Ok</code>, the socket has successfully bound.</p>
+</div><h4 id='method.accept' class="method"><span id='accept.v' class='invisible'><code>pub fn <a href='#method.accept' class='fnname'>accept</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#61-109' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempt to accept a connection and create a new connected <code>TcpStream</code> if
+successful.</p>
+<p>This function will attempt an accept operation, but will not block
+waiting for it to complete. If the operation would block then a "would
+block" error is returned. Additionally, if this method would block, it
+registers the current task to receive a notification when it would
+otherwise not block.</p>
+<p>Note that typically for simple usage it's easier to treat incoming
+connections as a <code>Stream</code> of <code>TcpStream</code>s with the <code>incoming</code> method
+below.</p>
+<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
+<p>This function will panic if it is called outside the context of a
+future's task. It's recommended to only call this from the
+implementation of a <code>Future::poll</code>, if necessary.</p>
+</div><h4 id='method.accept_std' class="method"><span id='accept_std.v' class='invisible'><code>pub fn <a href='#method.accept_std' class='fnname'>accept_std</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://doc.rust-lang.org/nightly/std/net/tcp/struct.TcpStream.html" title="struct std::net::tcp::TcpStream">TcpStream</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#115-129' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Like <code>accept</code>, except that it returns a raw <code>std::net::TcpStream</code>.</p>
+<p>The stream is <em>in blocking mode</em>, and is not associated with the Tokio
+event loop.</p>
+</div><h4 id='method.from_listener' class="method"><span id='from_listener.v' class='invisible'><code>pub fn <a href='#method.from_listener' class='fnname'>from_listener</a>(<br> listener: <a class="struct" href="https://doc.rust-lang.org/nightly/std/net/tcp/struct.TcpListener.html" title="struct std::net::tcp::TcpListener">TcpListener</a>, <br> addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, <br> handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a><br>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/net/struct.TcpListener.html" title="struct tokio_core::net::TcpListener">TcpListener</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#158-163' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a new TCP listener from the standard library's TCP listener.</p>
+<p>This method can be used when the <code>Handle::tcp_listen</code> method isn't
+sufficient because perhaps some more configuration is needed in terms of
+before the calls to <code>bind</code> and <code>listen</code>.</p>
+<p>This API is typically paired with the <code>net2</code> crate and the <code>TcpBuilder</code>
+type to build up and customize a listener before it's shipped off to the
+backing event loop. This allows configuration of options like
+<code>SO_REUSEPORT</code>, binding to multiple addresses, etc.</p>
+<p>The <code>addr</code> argument here is one of the addresses that <code>listener</code> is
+bound to and the listener will only be guaranteed to accept connections
+of the same address type currently.</p>
+<p>Finally, the <code>handle</code> argument is the event loop that this listener will
+be bound to.</p>
+<p>The platform specific behavior of this function looks like:</p>
+<ul>
+<li>
+<p>On Unix, the socket is placed into nonblocking mode and connections
+can be accepted as normal</p>
+</li>
+<li>
+<p>On Windows, the address is stored internally and all future accepts
+will only be for the same IP version as <code>addr</code> specified. That is, if
+<code>addr</code> is an IPv4 address then all sockets accepted will be IPv4 as
+well (same for IPv6).</p>
+</li>
+</ul>
+</div><h4 id='method.poll_read' class="method"><span id='poll_read.v' class='invisible'><code>pub fn <a href='#method.poll_read' class='fnname'>poll_read</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#172-174' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test whether this socket is ready to be read or not.</p>
+</div><h4 id='method.local_addr' class="method"><span id='local_addr.v' class='invisible'><code>pub fn <a href='#method.local_addr' class='fnname'>local_addr</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#180-182' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns the local address that this listener is bound to.</p>
+<p>This can be useful, for example, when binding to port 0 to figure out
+which port was actually bound.</p>
+</div><h4 id='method.incoming' class="method"><span id='incoming.v' class='invisible'><code>pub fn <a href='#method.incoming' class='fnname'>incoming</a>(self) -> <a class="struct" href="../../tokio_core/net/struct.Incoming.html" title="struct tokio_core::net::Incoming">Incoming</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#189-191' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Consumes this listener, returning a stream of the sockets this listener
+accepts.</p>
+<p>This method returns an implementation of the <code>Stream</code> trait which
+resolves to the sockets the are accepted on this listener.</p>
+</div><h4 id='method.set_ttl' class="method"><span id='set_ttl.v' class='invisible'><code>pub fn <a href='#method.set_ttl' class='fnname'>set_ttl</a>(&self, ttl: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#197-199' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IP_TTL</code> option on this socket.</p>
+<p>This value sets the time-to-live field that is used in every packet sent
+from this socket.</p>
+</div><h4 id='method.ttl' class="method"><span id='ttl.v' class='invisible'><code>pub fn <a href='#method.ttl' class='fnname'>ttl</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#206-208' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IP_TTL</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#method.set_ttl"><code>set_ttl</code></a>.</p>
+</div><h4 id='method.set_only_v6' class="method"><span id='set_only_v6.v' class='invisible'><code>pub fn <a href='#method.set_only_v6' class='fnname'>set_only_v6</a>(&self, only_v6: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#218-220' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IPV6_V6ONLY</code> option on this socket.</p>
+<p>If this is set to <code>true</code> then the socket is restricted to sending and
+receiving IPv6 packets only. In this case two IPv4 and IPv6 applications
+can bind the same port at the same time.</p>
+<p>If this is set to <code>false</code> then the socket can be used to send and
+receive packets from an IPv4-mapped IPv6 address.</p>
+</div><h4 id='method.only_v6' class="method"><span id='only_v6.v' class='invisible'><code>pub fn <a href='#method.only_v6' class='fnname'>only_v6</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#227-229' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IPV6_V6ONLY</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#method.set_only_v6"><code>set_only_v6</code></a>.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-AsRawFd' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html" title="trait std::sys::unix::ext::io::AsRawFd">AsRawFd</a> for <a class="struct" href="../../tokio_core/net/struct.TcpListener.html" title="struct tokio_core::net::TcpListener">TcpListener</a></code><a href='#impl-AsRawFd' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#790-794' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.as_raw_fd' class="method"><span id='as_raw_fd.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd' class='fnname'>as_raw_fd</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/type.RawFd.html" title="type std::sys::unix::ext::io::RawFd">RawFd</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#791-793' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Extracts the raw file descriptor. <a href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/net/struct.TcpListener.html" title="struct tokio_core::net::TcpListener">TcpListener</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#232-236' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#233-235' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.TcpStream.html b/tokio_core/net/struct.TcpStream.html
new file mode 100644
index 0000000..53be96c
--- /dev/null
+++ b/tokio_core/net/struct.TcpStream.html
@@ -0,0 +1,361 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `TcpStream` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, TcpStream">
+
+ <title>tokio_core::net::TcpStream - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct TcpStream</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.connect">connect</a><a href="#method.from_stream">from_stream</a><a href="#method.connect_stream">connect_stream</a><a href="#method.poll_read">poll_read</a><a href="#method.poll_write">poll_write</a><a href="#method.local_addr">local_addr</a><a href="#method.peer_addr">peer_addr</a><a href="#method.peek">peek</a><a href="#method.shutdown">shutdown</a><a href="#method.set_nodelay">set_nodelay</a><a href="#method.nodelay">nodelay</a><a href="#method.set_recv_buffer_size">set_recv_buffer_size</a><a href="#method.recv_buffer_size">recv_buffer_size</a><a href="#method.set_send_buffer_size">set_send_buffer_size</a><a href="#method.send_buffer_size">send_buffer_size</a><a href="#method.set_keepalive">set_keepalive</a><a href="#method.keepalive">keepalive</a><a href="#method.set_ttl">set_ttl</a><a href="#method.ttl">ttl</a><a href="#method.set_only_v6">set_only_v6</a><a href="#method.only_v6">only_v6</a><a href="#method.set_linger">set_linger</a><a href="#method.linger">linger</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-AsRawFd">AsRawFd</a><a href="#impl-Read">Read</a><a href="#impl-Write">Write</a><a href="#impl-AsyncRead">AsyncRead</a><a href="#impl-AsyncWrite">AsyncWrite</a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'TcpStream', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>TcpStream</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#253-255' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct TcpStream { /* fields omitted */ }</pre><div class='docblock'><p>An I/O object representing a TCP stream connected to a remote endpoint.</p>
+<p>A TCP stream can either be created by connecting to an endpoint or by
+accepting a connection from a listener. Inside the stream is access to the
+raw underlying I/O object as well as streams for the read/write
+notifications on the stream itself.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#271-536' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.connect' class="method"><span id='connect.v' class='invisible'><code>pub fn <a href='#method.connect' class='fnname'>connect</a>(addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="struct" href="../../tokio_core/net/struct.TcpStreamNew.html" title="struct tokio_core::net::TcpStreamNew">TcpStreamNew</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#279-285' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a new TCP stream connected to the specified address.</p>
+<p>This function will create a new TCP socket and attempt to connect it to
+the <code>addr</code> provided. The returned future will be resolved once the
+stream has successfully connected. If an error happens during the
+connection or during the socket creation, that error will be returned to
+the future instead.</p>
+</div><h4 id='method.from_stream' class="method"><span id='from_stream.v' class='invisible'><code>pub fn <a href='#method.from_stream' class='fnname'>from_stream</a>(stream: <a class="struct" href="https://doc.rust-lang.org/nightly/std/net/tcp/struct.TcpStream.html" title="struct std::net::tcp::TcpStream">TcpStream</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#300-306' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a new <code>TcpStream</code> from a <code>net::TcpStream</code>.</p>
+<p>This function will convert a TCP stream in the standard library to a TCP
+stream ready to be used with the provided event loop handle. The object
+returned is associated with the event loop and ready to perform I/O.</p>
+</div><h4 id='method.connect_stream' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><W> <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='connect_stream.v' class='invisible'><code>pub fn <a href='#method.connect_stream' class='fnname'>connect_stream</a>(<br> stream: <a class="struct" href="https://doc.rust-lang.org/nightly/std/net/tcp/struct.TcpStream.html" title="struct std::net::tcp::TcpStream">TcpStream</a>, <br> addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, <br> handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a><br>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><<a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a><Item = <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a>, Error = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#326-335' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new <code>TcpStream</code> from the pending socket inside the given
+<code>std::net::TcpStream</code>, connecting it to the address specified.</p>
+<p>This constructor allows configuring the socket before it's actually
+connected, and this function will transfer ownership to the returned
+<code>TcpStream</code> if successful. An unconnected <code>TcpStream</code> can be created
+with the <code>net2::TcpBuilder</code> type (and also configured via that route).</p>
+<p>The platform specific behavior of this function looks like:</p>
+<ul>
+<li>
+<p>On Unix, the socket is placed into nonblocking mode and then a
+<code>connect</code> call is issued.</p>
+</li>
+<li>
+<p>On Windows, the address is stored internally and the connect operation
+is issued when the returned <code>TcpStream</code> is registered with an event
+loop. Note that on Windows you must <code>bind</code> a socket before it can be
+connected, so if a custom <code>TcpBuilder</code> is used it should be bound
+(perhaps to <code>INADDR_ANY</code>) before this method is called.</p>
+</li>
+</ul>
+</div><h4 id='method.poll_read' class="method"><span id='poll_read.v' class='invisible'><code>pub fn <a href='#method.poll_read' class='fnname'>poll_read</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#343-345' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test whether this socket is ready to be read or not.</p>
+<p>If the socket is <em>not</em> readable then the current task is scheduled to
+get a notification when the socket does become readable. That is, this
+is only suitable for calling in a <code>Future::poll</code> method and will
+automatically handle ensuring a retry once the socket is readable again.</p>
+</div><h4 id='method.poll_write' class="method"><span id='poll_write.v' class='invisible'><code>pub fn <a href='#method.poll_write' class='fnname'>poll_write</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#353-355' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test whether this socket is ready to be written to or not.</p>
+<p>If the socket is <em>not</em> writable then the current task is scheduled to
+get a notification when the socket does become writable. That is, this
+is only suitable for calling in a <code>Future::poll</code> method and will
+automatically handle ensuring a retry once the socket is writable again.</p>
+</div><h4 id='method.local_addr' class="method"><span id='local_addr.v' class='invisible'><code>pub fn <a href='#method.local_addr' class='fnname'>local_addr</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#358-360' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns the local address that this stream is bound to.</p>
+</div><h4 id='method.peer_addr' class="method"><span id='peer_addr.v' class='invisible'><code>pub fn <a href='#method.peer_addr' class='fnname'>peer_addr</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#363-365' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns the remote address that this stream is connected to.</p>
+</div><h4 id='method.peek' class="method"><span id='peek.v' class='invisible'><code>pub fn <a href='#method.peek' class='fnname'>peek</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#373-383' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Receives data on the socket from the remote address to which it is
+connected, without removing that data from the queue. On success,
+returns the number of bytes peeked.</p>
+<p>Successive calls return the same data. This is accomplished by passing
+<code>MSG_PEEK</code> as a flag to the underlying recv system call.</p>
+</div><h4 id='method.shutdown' class="method"><span id='shutdown.v' class='invisible'><code>pub fn <a href='#method.shutdown' class='fnname'>shutdown</a>(&self, how: <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/enum.Shutdown.html" title="enum std::net::Shutdown">Shutdown</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#390-392' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Shuts down the read, write, or both halves of this connection.</p>
+<p>This function will cause all pending and future I/O on the specified
+portions to return immediately with an appropriate value (see the
+documentation of <code>Shutdown</code>).</p>
+</div><h4 id='method.set_nodelay' class="method"><span id='set_nodelay.v' class='invisible'><code>pub fn <a href='#method.set_nodelay' class='fnname'>set_nodelay</a>(&self, nodelay: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#401-403' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>TCP_NODELAY</code> option on this socket.</p>
+<p>If set, this option disables the Nagle algorithm. This means that
+segments are always sent as soon as possible, even if there is only a
+small amount of data. When not set, data is buffered until there is a
+sufficient amount to send out, thereby avoiding the frequent sending of
+small packets.</p>
+</div><h4 id='method.nodelay' class="method"><span id='nodelay.v' class='invisible'><code>pub fn <a href='#method.nodelay' class='fnname'>nodelay</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#410-412' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>TCP_NODELAY</code> option on this socket.</p>
+<p>For more information about this option, see <a href="#method.set_nodelay"><code>set_nodelay</code></a>.</p>
+</div><h4 id='method.set_recv_buffer_size' class="method"><span id='set_recv_buffer_size.v' class='invisible'><code>pub fn <a href='#method.set_recv_buffer_size' class='fnname'>set_recv_buffer_size</a>(&self, size: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#418-420' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>SO_RCVBUF</code> option on this socket.</p>
+<p>Changes the size of the operating system's receive buffer associated
+with the socket.</p>
+</div><h4 id='method.recv_buffer_size' class="method"><span id='recv_buffer_size.v' class='invisible'><code>pub fn <a href='#method.recv_buffer_size' class='fnname'>recv_buffer_size</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#428-430' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>SO_RCVBUF</code> option on this socket.</p>
+<p>For more information about this option, see
+<a href="#tymethod.set_recv_buffer_size"><code>set_recv_buffer_size</code></a>.</p>
+</div><h4 id='method.set_send_buffer_size' class="method"><span id='set_send_buffer_size.v' class='invisible'><code>pub fn <a href='#method.set_send_buffer_size' class='fnname'>set_send_buffer_size</a>(&self, size: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#436-438' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>SO_SNDBUF</code> option on this socket.</p>
+<p>Changes the size of the operating system's send buffer associated with
+the socket.</p>
+</div><h4 id='method.send_buffer_size' class="method"><span id='send_buffer_size.v' class='invisible'><code>pub fn <a href='#method.send_buffer_size' class='fnname'>send_buffer_size</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#445-447' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>SO_SNDBUF</code> option on this socket.</p>
+<p>For more information about this option, see <a href="#tymethod.set_send_buffer"><code>set_send_buffer</code></a>.</p>
+</div><h4 id='method.set_keepalive' class="method"><span id='set_keepalive.v' class='invisible'><code>pub fn <a href='#method.set_keepalive' class='fnname'>set_keepalive</a>(&self, keepalive: <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#461-463' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets whether keepalive messages are enabled to be sent on this socket.</p>
+<p>On Unix, this option will set the <code>SO_KEEPALIVE</code> as well as the
+<code>TCP_KEEPALIVE</code> or <code>TCP_KEEPIDLE</code> option (depending on your platform).
+On Windows, this will set the <code>SIO_KEEPALIVE_VALS</code> option.</p>
+<p>If <code>None</code> is specified then keepalive messages are disabled, otherwise
+the duration specified will be the time to remain idle before sending a
+TCP keepalive probe.</p>
+<p>Some platforms specify this value in seconds, so sub-second
+specifications may be omitted.</p>
+</div><h4 id='method.keepalive' class="method"><span id='keepalive.v' class='invisible'><code>pub fn <a href='#method.keepalive' class='fnname'>keepalive</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#471-473' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns whether keepalive messages are enabled on this socket, and if so
+the duration of time between them.</p>
+<p>For more information about this option, see <a href="#tymethod.set_keepalive"><code>set_keepalive</code></a>.</p>
+</div><h4 id='method.set_ttl' class="method"><span id='set_ttl.v' class='invisible'><code>pub fn <a href='#method.set_ttl' class='fnname'>set_ttl</a>(&self, ttl: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#479-481' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IP_TTL</code> option on this socket.</p>
+<p>This value sets the time-to-live field that is used in every packet sent
+from this socket.</p>
+</div><h4 id='method.ttl' class="method"><span id='ttl.v' class='invisible'><code>pub fn <a href='#method.ttl' class='fnname'>ttl</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#488-490' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IP_TTL</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#tymethod.set_ttl"><code>set_ttl</code></a>.</p>
+</div><h4 id='method.set_only_v6' class="method"><span id='set_only_v6.v' class='invisible'><code>pub fn <a href='#method.set_only_v6' class='fnname'>set_only_v6</a>(&self, only_v6: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#500-502' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IPV6_V6ONLY</code> option on this socket.</p>
+<p>If this is set to <code>true</code> then the socket is restricted to sending and
+receiving IPv6 packets only. In this case two IPv4 and IPv6 applications
+can bind the same port at the same time.</p>
+<p>If this is set to <code>false</code> then the socket can be used to send and
+receive packets from an IPv4-mapped IPv6 address.</p>
+</div><h4 id='method.only_v6' class="method"><span id='only_v6.v' class='invisible'><code>pub fn <a href='#method.only_v6' class='fnname'>only_v6</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#509-511' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IPV6_V6ONLY</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#tymethod.set_only_v6"><code>set_only_v6</code></a>.</p>
+</div><h4 id='method.set_linger' class="method"><span id='set_linger.v' class='invisible'><code>pub fn <a href='#method.set_linger' class='fnname'>set_linger</a>(&self, dur: <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#514-516' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the linger duration of this socket by setting the SO_LINGER option</p>
+</div><h4 id='method.linger' class="method"><span id='linger.v' class='invisible'><code>pub fn <a href='#method.linger' class='fnname'>linger</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#519-521' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>reads the linger duration for this socket by getting the SO_LINGER option</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-AsRawFd' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html" title="trait std::sys::unix::ext::io::AsRawFd">AsRawFd</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-AsRawFd' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#784-788' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.as_raw_fd' class="method"><span id='as_raw_fd.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd' class='fnname'>as_raw_fd</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/type.RawFd.html" title="type std::sys::unix::ext::io::RawFd">RawFd</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#785-787' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Extracts the raw file descriptor. <a href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd">Read more</a></p>
+</div></div><h3 id='impl-Read' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-Read' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#538-542' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.read' class="method"><span id='read.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read' class='fnname'>read</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#539-541' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified buffer, returning how many bytes were read. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read">Read more</a></p>
+</div><h4 id='method.initializer' class="method"><span id='initializer.v' class='invisible'><code>unsafe fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer' class='fnname'>initializer</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Initializer.html" title="struct std::io::Initializer">Initializer</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#553-555' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>read_initializer</code>)</div></div><div class='docblock'><p>Determines if this <code>Read</code>er can work with buffers of uninitialized memory. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer">Read more</a></p>
+</div><h4 id='method.read_to_end' class="method"><span id='read_to_end.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end' class='fnname'>read_to_end</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#600-602' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, placing them into <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end">Read more</a></p>
+</div><h4 id='method.read_to_string' class="method"><span id='read_to_string.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string' class='fnname'>read_to_string</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#638-649' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, appending them to <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string">Read more</a></p>
+</div><h4 id='method.read_exact' class="method"><span id='read_exact.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact' class='fnname'>read_exact</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.6.0'>1.6.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#701-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read the exact number of bytes required to fill <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact">Read more</a></p>
+</div><h4 id='method.by_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#753' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Read</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.bytes' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>>;</span></code></div></div><span id='bytes.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes' class='fnname'>bytes</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#790-792' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over its bytes. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes">Read more</a></p>
+</div><h4 id='method.chars' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/io/enum.CharsError.html" title="enum std::io::CharsError">CharsError</a>>;</span></code></div></div><span id='chars.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars' class='fnname'>chars</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#834-836' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>io</code>)</summary><p>the semantics of a partial read/write of where errors happen is currently unclear and may change</p>
+</details></div></div><div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over [<code>char</code>]s. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars">Read more</a></p>
+</div><h4 id='method.chain' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></h3><code class="content"><span class="where fmt-newline">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>,<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='chain.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain' class='fnname'>chain</a><R>(self, next: R) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><Self, R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#869-871' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will chain this stream with another. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain">Read more</a></p>
+</div><h4 id='method.take' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></h3><code class="content"><span class="where fmt-newline">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='take.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take' class='fnname'>take</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#905-907' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will read at most <code>limit</code> bytes from it. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take">Read more</a></p>
+</div></div><h3 id='impl-Write' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-Write' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#544-551' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.write' class="method"><span id='write.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write' class='fnname'>write</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#545-547' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a buffer into this object, returning how many bytes were written. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write">Read more</a></p>
+</div><h4 id='method.flush' class="method"><span id='flush.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush' class='fnname'>flush</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#548-550' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flush this output stream, ensuring that all intermediately buffered contents reach their destination. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush">Read more</a></p>
+</div><h4 id='method.write_all' class="method"><span id='write_all.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all' class='fnname'>write_all</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1097-1108' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempts to write an entire buffer into this write. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all">Read more</a></p>
+</div><h4 id='method.write_fmt' class="method"><span id='write_fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt' class='fnname'>write_fmt</a>(&mut self, fmt: <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Arguments.html" title="struct core::fmt::Arguments">Arguments</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1149-1181' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Writes a formatted string into this writer, returning any error encountered. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt">Read more</a></p>
+</div><h4 id='method.by_ref-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1205' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Write</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref">Read more</a></p>
+</div></div><h3 id='impl-AsyncRead' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html" title="trait tokio_io::AsyncRead">AsyncRead</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-AsyncRead' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#553-561' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.prepare_uninitialized_buffer' class="method"><span id='prepare_uninitialized_buffer.v' class='invisible'><code>unsafe fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer' class='fnname'>prepare_uninitialized_buffer</a>(&self, _: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#554-556' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Prepares an uninitialized buffer to be safe to pass to <code>read</code>. Returns <code>true</code> if the supplied buffer was zeroed out. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer">Read more</a></p>
+</div><h4 id='method.read_buf' class="method"><span id='read_buf.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf' class='fnname'>read_buf</a><B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf_mut/trait.BufMut.html" title="trait bytes::buf::buf_mut::BufMut">BufMut</a>>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#558-560' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified <code>Buf</code>, returning how many bytes were read. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf">Read more</a></p>
+</div><h4 id='method.framed' class="method"><span id='framed.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed' class='fnname'>framed</a><T>(self, codec: T) -> <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/framed/struct.Framed.html" title="struct tokio_io::framed::Framed">Framed</a><Self, T> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>,<br> T: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_read/trait.Decoder.html" title="trait tokio_io::framed_read::Decoder">Decoder</a> + <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_write/trait.Encoder.html" title="trait tokio_io::framed_write::Encoder">Encoder</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#175-179' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Provides a <code>Stream</code> and <code>Sink</code> interface for reading and writing to this <code>Io</code> object, using <code>Decode</code> and <code>Encode</code> to read and write the raw data. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed">Read more</a></p>
+</div><h4 id='method.split' class="method"><span id='split.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.ReadHalf.html" title="struct tokio_io::split::ReadHalf">ReadHalf</a><Self>, <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.WriteHalf.html" title="struct tokio_io::split::WriteHalf">WriteHalf</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#185-189' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Helper method for splitting this read/write object into two halves. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split">Read more</a></p>
+</div></div><h3 id='impl-AsyncWrite' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-AsyncWrite' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#563-571' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.shutdown-1' class="method"><span id='shutdown.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown' class='fnname'>shutdown</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#564-566' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown">Read more</a></p>
+</div><h4 id='method.write_buf' class="method"><span id='write_buf.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf' class='fnname'>write_buf</a><B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf/trait.Buf.html" title="trait bytes::buf::buf::Buf">Buf</a>>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#568-570' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a <code>Buf</code> into this value, returning how many bytes were written. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf">Read more</a></p>
+</div></div><h3 id='impl-Read-1' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for &'a <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-Read-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#613-617' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.read-1' class="method"><span id='read.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read' class='fnname'>read</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#614-616' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified buffer, returning how many bytes were read. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read">Read more</a></p>
+</div><h4 id='method.initializer-1' class="method"><span id='initializer.v-1' class='invisible'><code>unsafe fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer' class='fnname'>initializer</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Initializer.html" title="struct std::io::Initializer">Initializer</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#553-555' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>read_initializer</code>)</div></div><div class='docblock'><p>Determines if this <code>Read</code>er can work with buffers of uninitialized memory. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer">Read more</a></p>
+</div><h4 id='method.read_to_end-1' class="method"><span id='read_to_end.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end' class='fnname'>read_to_end</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#600-602' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, placing them into <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end">Read more</a></p>
+</div><h4 id='method.read_to_string-1' class="method"><span id='read_to_string.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string' class='fnname'>read_to_string</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#638-649' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, appending them to <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string">Read more</a></p>
+</div><h4 id='method.read_exact-1' class="method"><span id='read_exact.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact' class='fnname'>read_exact</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.6.0'>1.6.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#701-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read the exact number of bytes required to fill <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact">Read more</a></p>
+</div><h4 id='method.by_ref-2' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-2' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#753' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Read</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.bytes-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>>;</span></code></div></div><span id='bytes.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes' class='fnname'>bytes</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#790-792' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over its bytes. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes">Read more</a></p>
+</div><h4 id='method.chars-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/io/enum.CharsError.html" title="enum std::io::CharsError">CharsError</a>>;</span></code></div></div><span id='chars.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars' class='fnname'>chars</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#834-836' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>io</code>)</summary><p>the semantics of a partial read/write of where errors happen is currently unclear and may change</p>
+</details></div></div><div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over [<code>char</code>]s. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars">Read more</a></p>
+</div><h4 id='method.chain-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></h3><code class="content"><span class="where fmt-newline">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>,<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='chain.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain' class='fnname'>chain</a><R>(self, next: R) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><Self, R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#869-871' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will chain this stream with another. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain">Read more</a></p>
+</div><h4 id='method.take-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></h3><code class="content"><span class="where fmt-newline">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='take.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take' class='fnname'>take</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#905-907' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will read at most <code>limit</code> bytes from it. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take">Read more</a></p>
+</div></div><h3 id='impl-Write-1' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for &'a <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-Write-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#619-627' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.write-1' class="method"><span id='write.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write' class='fnname'>write</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#620-622' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a buffer into this object, returning how many bytes were written. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write">Read more</a></p>
+</div><h4 id='method.flush-1' class="method"><span id='flush.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush' class='fnname'>flush</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#624-626' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flush this output stream, ensuring that all intermediately buffered contents reach their destination. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush">Read more</a></p>
+</div><h4 id='method.write_all-1' class="method"><span id='write_all.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all' class='fnname'>write_all</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1097-1108' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempts to write an entire buffer into this write. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all">Read more</a></p>
+</div><h4 id='method.write_fmt-1' class="method"><span id='write_fmt.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt' class='fnname'>write_fmt</a>(&mut self, fmt: <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Arguments.html" title="struct core::fmt::Arguments">Arguments</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1149-1181' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Writes a formatted string into this writer, returning any error encountered. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt">Read more</a></p>
+</div><h4 id='method.by_ref-3' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-3' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1205' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Write</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref">Read more</a></p>
+</div></div><h3 id='impl-AsyncRead-1' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html" title="trait tokio_io::AsyncRead">AsyncRead</a> for &'a <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-AsyncRead-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#629-680' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.prepare_uninitialized_buffer-1' class="method"><span id='prepare_uninitialized_buffer.v-1' class='invisible'><code>unsafe fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer' class='fnname'>prepare_uninitialized_buffer</a>(&self, _: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#630-632' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Prepares an uninitialized buffer to be safe to pass to <code>read</code>. Returns <code>true</code> if the supplied buffer was zeroed out. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer">Read more</a></p>
+</div><h4 id='method.read_buf-1' class="method"><span id='read_buf.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf' class='fnname'>read_buf</a><B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf_mut/trait.BufMut.html" title="trait bytes::buf::buf_mut::BufMut">BufMut</a>>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#634-679' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified <code>Buf</code>, returning how many bytes were read. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf">Read more</a></p>
+</div><h4 id='method.framed-1' class="method"><span id='framed.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed' class='fnname'>framed</a><T>(self, codec: T) -> <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/framed/struct.Framed.html" title="struct tokio_io::framed::Framed">Framed</a><Self, T> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>,<br> T: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_read/trait.Decoder.html" title="trait tokio_io::framed_read::Decoder">Decoder</a> + <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_write/trait.Encoder.html" title="trait tokio_io::framed_write::Encoder">Encoder</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#175-179' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Provides a <code>Stream</code> and <code>Sink</code> interface for reading and writing to this <code>Io</code> object, using <code>Decode</code> and <code>Encode</code> to read and write the raw data. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed">Read more</a></p>
+</div><h4 id='method.split-1' class="method"><span id='split.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.ReadHalf.html" title="struct tokio_io::split::ReadHalf">ReadHalf</a><Self>, <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.WriteHalf.html" title="struct tokio_io::split::WriteHalf">WriteHalf</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#185-189' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Helper method for splitting this read/write object into two halves. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split">Read more</a></p>
+</div></div><h3 id='impl-AsyncWrite-1' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a> for &'a <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-AsyncWrite-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#682-713' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.shutdown-2' class="method"><span id='shutdown.v-2' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown' class='fnname'>shutdown</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#683-685' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown">Read more</a></p>
+</div><h4 id='method.write_buf-1' class="method"><span id='write_buf.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf' class='fnname'>write_buf</a><B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf/trait.Buf.html" title="trait bytes::buf::buf::Buf">Buf</a>>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#687-712' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a <code>Buf</code> into this value, returning how many bytes were written. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#726-730' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#727-729' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.TcpStreamNew.html b/tokio_core/net/struct.TcpStreamNew.html
new file mode 100644
index 0000000..d4a1f19
--- /dev/null
+++ b/tokio_core/net/struct.TcpStreamNew.html
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `TcpStreamNew` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, TcpStreamNew">
+
+ <title>tokio_core::net::TcpStreamNew - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct TcpStreamNew</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Future">Future</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'TcpStreamNew', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>TcpStreamNew</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#260-262' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "futures do nothing unless polled"]
+</div>pub struct TcpStreamNew { /* fields omitted */ }</pre><div class='docblock'><p>Future returned by <code>TcpStream::connect</code> which will resolve to a <code>TcpStream</code>
+when the stream is connected.</p>
+</div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Future' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a> for <a class="struct" href="../../tokio_core/net/struct.TcpStreamNew.html" title="struct tokio_core::net::TcpStreamNew">TcpStreamNew</a></code><a href='#impl-Future' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#732-739' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item' class="type">Item</a> = <a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a></code></span></h4>
+<div class='docblock'><p>The type of value that this future will resolved with if it is successful. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item">Read more</a></p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error that this future will resolve with if it fails in a normal fashion. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error">Read more</a></p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="struct" href="../../tokio_core/net/struct.TcpStream.html" title="struct tokio_core::net::TcpStream">TcpStream</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/tcp.rs.html#736-738' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Query this future to see if its value has become available, registering interest if it is not. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait' class='fnname'>wait</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#296-300' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Block the current thread until this future is resolved. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map' class='fnname'>map</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map/struct.Map.html" title="struct futures::future::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#370-375' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's result to a different type, returning a new future of the resulting type. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err' class='fnname'>map_err</a><F, E>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map_err/struct.MapErr.html" title="struct futures::future::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> E, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#410-415' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to a different error, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/from_err/struct.FromErr.html" title="struct futures::future::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#440-444' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to any error implementing <code>From</code> for this future's <code>Error</code>, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then' class='fnname'>then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/then/struct.Then.html" title="struct futures::future::then::Then">Then</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#484-490' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a future finished, passing the result of the future to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then' class='fnname'>and_then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/and_then/struct.AndThen.html" title="struct futures::future::and_then::AndThen">AndThen</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#525-531' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future after this one has resolved successfully. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else' class='fnname'>or_else</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/or_else/struct.OrElse.html" title="struct futures::future::or_else::OrElse">OrElse</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#566-572' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future if this one resolves with an error. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select' class='fnname'>select</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select/struct.Select.html" title="struct futures::future::select::Select">Select</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#624-631' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select">Read more</a></p>
+</div><h4 id='method.select2' class="method"><span id='select2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2' class='fnname'>select2</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select2/struct.Select2.html" title="struct futures::future::select2::Select2">Select2</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#670-674' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two differently-typed futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2">Read more</a></p>
+</div><h4 id='method.join' class="method"><span id='join.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join' class='fnname'>join</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join.html" title="struct futures::future::join::Join">Join</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#715-721' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Joins the result of two futures, waiting for them both to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join">Read more</a></p>
+</div><h4 id='method.join3' class="method"><span id='join3.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join3' class='fnname'>join3</a><B, C>(<br> self, <br> b: B, <br> c: C<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join3.html" title="struct futures::future::join::Join3">Join3</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#724-730' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join4' class="method"><span id='join4.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join4' class='fnname'>join4</a><B, C, D>(<br> self, <br> b: B, <br> c: C, <br> d: D<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join4.html" title="struct futures::future::join::Join4">Join4</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#733-741' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join5' class="method"><span id='join5.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join5' class='fnname'>join5</a><B, C, D, E>(<br> self, <br> b: B, <br> c: C, <br> d: D, <br> e: E<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join5.html" title="struct futures::future::join::Join5">Join5</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <E as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> E: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#744-754' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.into_stream' class="method"><span id='into_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream' class='fnname'>into_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/into_stream/struct.IntoStream.html" title="struct futures::future::into_stream::IntoStream">IntoStream</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#777-781' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Convert this future into a single element stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten/struct.Flatten.html" title="struct futures::future::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#819-829' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is itself another future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten">Read more</a></p>
+</div><h4 id='method.flatten_stream' class="method"><span id='flatten_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream' class='fnname'>flatten_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten_stream/struct.FlattenStream.html" title="struct futures::future::flatten_stream::FlattenStream">FlattenStream</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#859-864' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is a stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/fuse/struct.Fuse.html" title="struct futures::future::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#899-904' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a future such that <code>poll</code> will never again be called once it has completed. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/inspect/struct.Inspect.html" title="struct futures::future::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#922-927' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the item of a future, passing it on. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/catch_unwind/struct.CatchUnwind.html" title="struct futures::future::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#961-965' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.shared' class="method"><span id='shared.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared' class='fnname'>shared</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/shared/struct.Shared.html" title="struct futures::future::shared::Shared">Shared</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#1010-1014' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a cloneable handle to this future where all handles will resolve to the same result. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.UdpFramed.html b/tokio_core/net/struct.UdpFramed.html
new file mode 100644
index 0000000..b1dd96b
--- /dev/null
+++ b/tokio_core/net/struct.UdpFramed.html
@@ -0,0 +1,267 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `UdpFramed` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, UdpFramed">
+
+ <title>tokio_core::net::UdpFramed - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct UdpFramed</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.get_ref">get_ref</a><a href="#method.get_mut">get_mut</a><a href="#method.into_inner">into_inner</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Stream">Stream</a><a href="#impl-Sink">Sink</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'UdpFramed', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>UdpFramed</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#59-66' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "sinks do nothing unless polled"]
+</div>pub struct UdpFramed<C> { /* fields omitted */ }</pre><div class='docblock'><p>A unified <code>Stream</code> and <code>Sink</code> interface to an underlying <code>UdpSocket</code>, using
+the <code>UdpCodec</code> trait to encode and decode frames.</p>
+<p>You can acquire a <code>UdpFramed</code> instance by using the <code>UdpSocket::framed</code>
+adapter.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl<C> <a class="struct" href="../../tokio_core/net/struct.UdpFramed.html" title="struct tokio_core::net::UdpFramed">UdpFramed</a><C></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#140-168' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.get_ref' class="method"><span id='get_ref.v' class='invisible'><code>pub fn <a href='#method.get_ref' class='fnname'>get_ref</a>(&self) -> &<a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#146-148' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a reference to the underlying I/O stream wrapped by <code>Framed</code>.</p>
+<p>Note that care should be taken to not tamper with the underlying stream
+of data coming in as it may corrupt the stream of frames otherwise being
+worked with.</p>
+</div><h4 id='method.get_mut' class="method"><span id='get_mut.v' class='invisible'><code>pub fn <a href='#method.get_mut' class='fnname'>get_mut</a>(&mut self) -> &mut <a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#156-158' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a mutable reference to the underlying I/O stream wrapped by
+<code>Framed</code>.</p>
+<p>Note that care should be taken to not tamper with the underlying stream
+of data coming in as it may corrupt the stream of frames otherwise being
+worked with.</p>
+</div><h4 id='method.into_inner' class="method"><span id='into_inner.v' class='invisible'><code>pub fn <a href='#method.into_inner' class='fnname'>into_inner</a>(self) -> <a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#165-167' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Consumes the <code>Framed</code>, returning its underlying I/O stream.</p>
+<p>Note that care should be taken to not tamper with the underlying stream
+of data coming in as it may corrupt the stream of frames otherwise being
+worked with.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Stream' class='impl'><span class='in-band'><code>impl<C: <a class="trait" href="../../tokio_core/net/trait.UdpCodec.html" title="trait tokio_core::net::UdpCodec">UdpCodec</a>> <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a> for <a class="struct" href="../../tokio_core/net/struct.UdpFramed.html" title="struct tokio_core::net::UdpFramed">UdpFramed</a><C></code><a href='#impl-Stream' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#68-79' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item' class="type">Item</a> = C::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.In" title="type tokio_core::net::UdpCodec::In">In</a></code></span></h4>
+<div class='docblock'><p>The type of item this stream will yield on success.</p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error this stream may generate.</p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><C::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.In" title="type tokio_core::net::UdpCodec::In">In</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#72-78' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempt to pull out the next value of this stream, returning <code>None</code> if the stream is finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></h3><code class="content"><span class="where fmt-newline">impl<S> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, <S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>;</span></code></div></div><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait' class='fnname'>wait</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#244-248' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an iterator which blocks the current thread until each item of this stream is resolved. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait">Read more</a></p>
+</div><h4 id='method.into_future' class="method"><span id='into_future.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future' class='fnname'>into_future</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/future/struct.StreamFuture.html" title="struct futures::stream::future::StreamFuture">StreamFuture</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#291-295' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts this stream into a <code>Future</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map' class='fnname'>map</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map/struct.Map.html" title="struct futures::stream::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#316-321' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of type <code>T</code> to a stream of type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err' class='fnname'>map_err</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map_err/struct.MapErr.html" title="struct futures::stream::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#342-347' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of error type <code>T</code> to a stream of error type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err">Read more</a></p>
+</div><h4 id='method.filter' class="method"><span id='filter.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter' class='fnname'>filter</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter/struct.Filter.html" title="struct futures::stream::filter::Filter">Filter</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#372-377' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream according to the provided predicate. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter">Read more</a></p>
+</div><h4 id='method.filter_map' class="method"><span id='filter_map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map' class='fnname'>filter_map</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter_map/struct.FilterMap.html" title="struct futures::stream::filter_map::FilterMap">FilterMap</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><B>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#408-413' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream while simultaneously mapping them to a different type. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then' class='fnname'>then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/then/struct.Then.html" title="struct futures::stream::then::Then">Then</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#447-453' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the resulting item to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then' class='fnname'>and_then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/and_then/struct.AndThen.html" title="struct futures::stream::and_then::AndThen">AndThen</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#494-500' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the successful results to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else' class='fnname'>or_else</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/or_else/struct.OrElse.html" title="struct futures::stream::or_else::OrElse">OrElse</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#521-527' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when an error happens, passing the erroneous result to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else">Read more</a></p>
+</div><h4 id='method.collect' class="method"><span id='collect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect' class='fnname'>collect</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/collect/struct.Collect.html" title="struct futures::stream::collect::Collect">Collect</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#562-566' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Collect all of the values of this stream into a vector, returning a future representing the result of that computation. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect">Read more</a></p>
+</div><h4 id='method.concat2' class="method"><span id='concat2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2' class='fnname'>concat2</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat2.html" title="struct futures::stream::concat::Concat2">Concat2</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#598-603' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2">Read more</a></p>
+</div><h4 id='method.concat' class="method"><span id='concat.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat' class='fnname'>concat</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat.html" title="struct futures::stream::concat::Concat">Concat</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#638-643' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated since 0.1.14<p>: please use <code>Stream::concat2</code> instead</p>
+</div></div><div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat">Read more</a></p>
+</div><h4 id='method.fold' class="method"><span id='fold.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold' class='fnname'>fold</a><F, T, Fut>(self, init: T, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fold/struct.Fold.html" title="struct futures::stream::fold::Fold">Fold</a><Self, F, Fut, T> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(T, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> Fut,<br> Fut: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = T>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<Fut as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#668-675' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute an accumulating computation over a stream, collecting all the values into one final result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/flatten/struct.Flatten.html" title="struct futures::stream::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#710-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flattens a stream of streams into just one continuous stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten">Read more</a></p>
+</div><h4 id='method.skip_while' class="method"><span id='skip_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while' class='fnname'>skip_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip_while/struct.SkipWhile.html" title="struct futures::stream::skip_while::SkipWhile">SkipWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#725-731' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Skip elements on this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while">Read more</a></p>
+</div><h4 id='method.take_while' class="method"><span id='take_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while' class='fnname'>take_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take_while/struct.TakeWhile.html" title="struct futures::stream::take_while::TakeWhile">TakeWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#739-745' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Take elements from this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while">Read more</a></p>
+</div><h4 id='method.for_each' class="method"><span id='for_each.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each' class='fnname'>for_each</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/for_each/struct.ForEach.html" title="struct futures::stream::for_each::ForEach">ForEach</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#761-767' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Runs this stream to completion, executing the provided closure for each element on the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/from_err/struct.FromErr.html" title="struct futures::stream::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#780-784' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this stream's error to any error implementing <code>From</code> for this stream's <code>Error</code>, returning a new stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err">Read more</a></p>
+</div><h4 id='method.take' class="method"><span id='take.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take' class='fnname'>take</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take/struct.Take.html" title="struct futures::stream::take::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#796-800' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream of at most <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take">Read more</a></p>
+</div><h4 id='method.skip' class="method"><span id='skip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip' class='fnname'>skip</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip/struct.Skip.html" title="struct futures::stream::skip::Skip">Skip</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#811-815' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which skips <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fuse/struct.Fuse.html" title="struct futures::stream::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#832-836' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a stream such that <code>poll</code> will never again be called once it has finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse">Read more</a></p>
+</div><h4 id='method.by_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#857-861' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Borrows a stream, rather than consuming it. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/catch_unwind/struct.CatchUnwind.html" title="struct futures::stream::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#897-901' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.buffered' class="method"><span id='buffered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered' class='fnname'>buffered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffered/struct.Buffered.html" title="struct futures::stream::buffered::Buffered">Buffered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#917-922' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered">Read more</a></p>
+</div><h4 id='method.buffer_unordered' class="method"><span id='buffer_unordered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered' class='fnname'>buffer_unordered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffer_unordered/struct.BufferUnordered.html" title="struct futures::stream::buffer_unordered::BufferUnordered">BufferUnordered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#938-943' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures (unordered). <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered">Read more</a></p>
+</div><h4 id='method.merge' class="method"><span id='merge.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge' class='fnname'>merge</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/merge/struct.Merge.html" title="struct futures::stream::merge::Merge">Merge</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#952-957' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated<p>: functionality provided by <code>select</code> now</p>
+</div></div><div class='docblock'><p>An adapter for merging the output of two streams. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge">Read more</a></p>
+</div><h4 id='method.zip' class="method"><span id='zip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip' class='fnname'>zip</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/zip/struct.Zip.html" title="struct futures::stream::zip::Zip">Zip</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#964-969' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adapter for zipping two streams together. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip">Read more</a></p>
+</div><h4 id='method.chain' class="method"><span id='chain.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain' class='fnname'>chain</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chain/struct.Chain.html" title="struct futures::stream::chain::Chain">Chain</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#990-995' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Adapter for chaining two stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain">Read more</a></p>
+</div><h4 id='method.peekable' class="method"><span id='peekable.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable' class='fnname'>peekable</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/peek/struct.Peekable.html" title="struct futures::stream::peek::Peekable">Peekable</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1000-1004' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which exposes a <code>peek</code> method. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable">Read more</a></p>
+</div><h4 id='method.chunks' class="method"><span id='chunks.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks' class='fnname'>chunks</a>(self, capacity: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chunks/struct.Chunks.html" title="struct futures::stream::chunks::Chunks">Chunks</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1027-1031' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for chunking up items of the stream inside a vector. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select' class='fnname'>select</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/select/struct.Select.html" title="struct futures::stream::select::Select">Select</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1044-1049' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a stream that selects the next element from either this stream or the provided one, whichever is ready first. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select">Read more</a></p>
+</div><h4 id='method.forward' class="method"><span id='forward.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward' class='fnname'>forward</a><S>(self, sink: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/forward/struct.Forward.html" title="struct futures::stream::forward::Forward">Forward</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a><SinkItem = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1065-1071' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes after the given stream has been fully processed into the sink, including flushing. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward">Read more</a></p>
+</div><h4 id='method.split' class="method"><span id='split.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitSink.html" title="struct futures::stream::split::SplitSink">SplitSink</a><Self>, <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitStream.html" title="struct futures::stream::split::SplitStream">SplitStream</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1083-1087' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Splits this <code>Stream + Sink</code> object into separate <code>Stream</code> and <code>Sink</code> objects. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect/struct.Inspect.html" title="struct futures::stream::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1094-1099' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with each item of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect">Read more</a></p>
+</div><h4 id='method.inspect_err' class="method"><span id='inspect_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err' class='fnname'>inspect_err</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect_err/struct.InspectErr.html" title="struct futures::stream::inspect_err::InspectErr">InspectErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1106-1111' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the error of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err">Read more</a></p>
+</div></div><h3 id='impl-Sink' class='impl'><span class='in-band'><code>impl<C: <a class="trait" href="../../tokio_core/net/trait.UdpCodec.html" title="trait tokio_core::net::UdpCodec">UdpCodec</a>> <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a> for <a class="struct" href="../../tokio_core/net/struct.UdpFramed.html" title="struct tokio_core::net::UdpFramed">UdpFramed</a><C></code><a href='#impl-Sink' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#81-127' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.SinkItem' class="type"><span id='SinkItem.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem' class="type">SinkItem</a> = C::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.Out" title="type tokio_core::net::UdpCodec::Out">Out</a></code></span></h4>
+<div class='docblock'><p>The type of value that the sink accepts.</p>
+</div><h4 id='associatedtype.SinkError' class="type"><span id='SinkError.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError' class="type">SinkError</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of value produced by the sink when an error occurs.</p>
+</div><h4 id='method.start_send' class="method"><span id='start_send.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#tymethod.start_send' class='fnname'>start_send</a>(&mut self, item: C::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.Out" title="type tokio_core::net::UdpCodec::Out">Out</a>) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.StartSend.html" title="type futures::poll::StartSend">StartSend</a><C::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.Out" title="type tokio_core::net::UdpCodec::Out">Out</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#85-100' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Begin the process of sending a value to the sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#tymethod.start_send">Read more</a></p>
+</div><h4 id='method.poll_complete' class="method"><span id='poll_complete.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#tymethod.poll_complete' class='fnname'>poll_complete</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#102-121' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flush all output from this sink, if necessary. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#tymethod.poll_complete">Read more</a></p>
+</div><h4 id='method.close' class="method"><span id='close.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.close' class='fnname'>close</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#123-126' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A method to indicate that no more values will ever be pushed into this sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.close">Read more</a></p>
+</div><h4 id='method.wait-1' class="method"><span id='wait.v-1' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.wait' class='fnname'>wait</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/wait/struct.Wait.html" title="struct futures::sink::wait::Wait">Wait</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#296-300' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new object which will produce a synchronous sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.wait">Read more</a></p>
+</div><h4 id='method.with' class="method"><span id='with.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.with' class='fnname'>with</a><U, F, Fut>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/with/struct.With.html" title="struct futures::sink::with::With">With</a><Self, U, F, Fut> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(U) -> Fut,<br> Fut: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>>,<br> <Fut as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#313-320' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Composes a function in front of the sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.with">Read more</a></p>
+</div><h4 id='method.with_flat_map' class="method"><span id='with_flat_map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.with_flat_map' class='fnname'>with_flat_map</a><U, F, St>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/with_flat_map/struct.WithFlatMap.html" title="struct futures::sink::with_flat_map::WithFlatMap">WithFlatMap</a><Self, U, F, St> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(U) -> St,<br> St: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#352-358' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Composes a function in front of the sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.with_flat_map">Read more</a></p>
+</div><h4 id='method.sink_map_err' class="method"><span id='sink_map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.sink_map_err' class='fnname'>sink_map_err</a><F, E>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/map_err/struct.SinkMapErr.html" title="struct futures::sink::map_err::SinkMapErr">SinkMapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>) -> E, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#375-380' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Transforms the error returned by the sink.</p>
+</div><h4 id='method.sink_from_err' class="method"><span id='sink_from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.sink_from_err' class='fnname'>sink_from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/from_err/struct.SinkFromErr.html" title="struct futures::sink::from_err::SinkFromErr">SinkFromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#386-390' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this sink's error to any error implementing <code>From</code> for this sink's <code>Error</code>, returning a new sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.sink_from_err">Read more</a></p>
+</div><h4 id='method.buffer' class="method"><span id='buffer.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.buffer' class='fnname'>buffer</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/buffer/struct.Buffer.html" title="struct futures::sink::buffer::Buffer">Buffer</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#406-410' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Adds a fixed-size buffer to the current sink. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.buffer">Read more</a></p>
+</div><h4 id='method.fanout' class="method"><span id='fanout.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.fanout' class='fnname'>fanout</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/fanout/struct.Fanout.html" title="struct futures::sink::fanout::Fanout">Fanout</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a><SinkItem = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>, SinkError = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#416-422' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fanout items to multiple sinks. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.fanout">Read more</a></p>
+</div><h4 id='method.flush' class="method"><span id='flush.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.flush' class='fnname'>flush</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/flush/struct.Flush.html" title="struct futures::sink::flush::Flush">Flush</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#430-434' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes when the sink has finished processing all pending requests. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.flush">Read more</a></p>
+</div><h4 id='method.send' class="method"><span id='send.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.send' class='fnname'>send</a>(self, item: Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/send/struct.Send.html" title="struct futures::sink::send::Send">Send</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#444-448' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes after the given item has been fully processed into the sink, including flushing. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.send">Read more</a></p>
+</div><h4 id='method.send_all' class="method"><span id='send_all.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.send_all' class='fnname'>send_all</a><S>(self, stream: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/sink/send_all/struct.SendAll.html" title="struct futures::sink::send_all::SendAll">SendAll</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkItem" title="type futures::sink::Sink::SinkItem">SinkItem</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/sink/mod.rs.html#464-470' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes after the given stream has been fully processed into the sink, including flushing. <a href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#method.send_all">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/struct.UdpSocket.html b/tokio_core/net/struct.UdpSocket.html
new file mode 100644
index 0000000..736d0b0
--- /dev/null
+++ b/tokio_core/net/struct.UdpSocket.html
@@ -0,0 +1,299 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `UdpSocket` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, UdpSocket">
+
+ <title>tokio_core::net::UdpSocket - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct UdpSocket</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.bind">bind</a><a href="#method.from_socket">from_socket</a><a href="#method.framed">framed</a><a href="#method.local_addr">local_addr</a><a href="#method.connect">connect</a><a href="#method.send">send</a><a href="#method.recv">recv</a><a href="#method.poll_read">poll_read</a><a href="#method.poll_write">poll_write</a><a href="#method.send_to">send_to</a><a href="#method.send_dgram">send_dgram</a><a href="#method.recv_from">recv_from</a><a href="#method.recv_dgram">recv_dgram</a><a href="#method.broadcast">broadcast</a><a href="#method.set_broadcast">set_broadcast</a><a href="#method.multicast_loop_v4">multicast_loop_v4</a><a href="#method.set_multicast_loop_v4">set_multicast_loop_v4</a><a href="#method.multicast_ttl_v4">multicast_ttl_v4</a><a href="#method.set_multicast_ttl_v4">set_multicast_ttl_v4</a><a href="#method.multicast_loop_v6">multicast_loop_v6</a><a href="#method.set_multicast_loop_v6">set_multicast_loop_v6</a><a href="#method.ttl">ttl</a><a href="#method.set_ttl">set_ttl</a><a href="#method.join_multicast_v4">join_multicast_v4</a><a href="#method.join_multicast_v6">join_multicast_v6</a><a href="#method.leave_multicast_v4">leave_multicast_v4</a><a href="#method.leave_multicast_v6">leave_multicast_v6</a><a href="#method.set_only_v6">set_only_v6</a><a href="#method.only_v6">only_v6</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-AsRawFd">AsRawFd</a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'UdpSocket', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="struct" href=''>UdpSocket</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#11-13' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct UdpSocket { /* fields omitted */ }</pre><div class='docblock'><p>An I/O object representing a UDP socket.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#18-374' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.bind' class="method"><span id='bind.v' class='invisible'><code>pub fn <a href='#method.bind' class='fnname'>bind</a>(addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#23-26' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a new UDP socket bound to the specified address.</p>
+<p>This function will create a new UDP socket and attempt to bind it to the
+<code>addr</code> provided. If the result is <code>Ok</code>, the socket has successfully bound.</p>
+</div><h4 id='method.from_socket' class="method"><span id='from_socket.v' class='invisible'><code>pub fn <a href='#method.from_socket' class='fnname'>from_socket</a>(socket: <a class="struct" href="https://doc.rust-lang.org/nightly/std/net/udp/struct.UdpSocket.html" title="struct std::net::udp::UdpSocket">UdpSocket</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#42-46' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new <code>UdpSocket</code> from the previously bound socket provided.</p>
+<p>The socket given will be registered with the event loop that <code>handle</code> is
+associated with. This function requires that <code>socket</code> has previously
+been bound to an address to work correctly.</p>
+<p>This can be used in conjunction with net2's <code>UdpBuilder</code> interface to
+configure a socket before it's handed off, such as setting options like
+<code>reuse_address</code> or binding to multiple addresses.</p>
+</div><h4 id='method.framed' class="method"><span id='framed.v' class='invisible'><code>pub fn <a href='#method.framed' class='fnname'>framed</a><C: <a class="trait" href="../../tokio_core/net/trait.UdpCodec.html" title="trait tokio_core::net::UdpCodec">UdpCodec</a>>(self, codec: C) -> <a class="struct" href="../../tokio_core/net/struct.UdpFramed.html" title="struct tokio_core::net::UdpFramed">UdpFramed</a><C></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#67-69' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Provides a <code>Stream</code> and <code>Sink</code> interface for reading and writing to this
+<code>UdpSocket</code> object, using the provided <code>UdpCodec</code> to read and write the
+raw data.</p>
+<p>Raw UDP sockets work with datagrams, but higher-level code usually
+wants to batch these into meaningful chunks, called "frames". This
+method layers framing on top of this socket by using the <code>UdpCodec</code>
+trait to handle encoding and decoding of messages frames. Note that
+the incoming and outgoing frame types may be distinct.</p>
+<p>This function returns a <em>single</em> object that is both <code>Stream</code> and
+<code>Sink</code>; grouping this into a single object is often useful for layering
+things which require both read and write access to the underlying
+object.</p>
+<p>If you want to work more directly with the streams and sink, consider
+calling <code>split</code> on the <code>UdpFramed</code> returned by this method, which will
+break them into separate objects, allowing them to interact more
+easily.</p>
+</div><h4 id='method.local_addr' class="method"><span id='local_addr.v' class='invisible'><code>pub fn <a href='#method.local_addr' class='fnname'>local_addr</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#72-74' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns the local address that this stream is bound to.</p>
+</div><h4 id='method.connect' class="method"><span id='connect.v' class='invisible'><code>pub fn <a href='#method.connect' class='fnname'>connect</a>(&self, addr: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#78-80' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Connects the UDP socket setting the default destination for send() and
+limiting packets that are read via recv from the address specified in addr.</p>
+</div><h4 id='method.send' class="method"><span id='send.v' class='invisible'><code>pub fn <a href='#method.send' class='fnname'>send</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#84-97' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sends data on the socket to the address previously bound via connect().
+On success, returns the number of bytes written.</p>
+</div><h4 id='method.recv' class="method"><span id='recv.v' class='invisible'><code>pub fn <a href='#method.recv' class='fnname'>recv</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#101-114' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Receives data from the socket previously bound with connect().
+On success, returns the number of bytes read.</p>
+</div><h4 id='method.poll_read' class="method"><span id='poll_read.v' class='invisible'><code>pub fn <a href='#method.poll_read' class='fnname'>poll_read</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#122-124' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test whether this socket is ready to be read or not.</p>
+<p>If the socket is <em>not</em> readable then the current task is scheduled to
+get a notification when the socket does become readable. That is, this
+is only suitable for calling in a <code>Future::poll</code> method and will
+automatically handle ensuring a retry once the socket is readable again.</p>
+</div><h4 id='method.poll_write' class="method"><span id='poll_write.v' class='invisible'><code>pub fn <a href='#method.poll_write' class='fnname'>poll_write</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#132-134' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test whether this socket is ready to be written to or not.</p>
+<p>If the socket is <em>not</em> writable then the current task is scheduled to
+get a notification when the socket does become writable. That is, this
+is only suitable for calling in a <code>Future::poll</code> method and will
+automatically handle ensuring a retry once the socket is writable again.</p>
+</div><h4 id='method.send_to' class="method"><span id='send_to.v' class='invisible'><code>pub fn <a href='#method.send_to' class='fnname'>send_to</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>, target: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#141-154' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sends data on the socket to the given address. On success, returns the
+number of bytes written.</p>
+<p>Address type can be any implementer of <code>ToSocketAddrs</code> trait. See its
+documentation for concrete examples.</p>
+</div><h4 id='method.send_dgram' class="method"><span id='send_dgram.v' class='invisible'><code>pub fn <a href='#method.send_dgram' class='fnname'>send_dgram</a><T>(self, buf: T, addr: <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>) -> <a class="struct" href="../../tokio_core/net/struct.SendDgram.html" title="struct tokio_core::net::SendDgram">SendDgram</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#171-175' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a future that will write the entire contents of the buffer
+<code>buf</code> provided as a datagram to this socket.</p>
+<p>The returned future will return after data has been written to the
+outbound socket. The future will resolve to the stream as well as the
+buffer (for reuse if needed).</p>
+<p>Any error which happens during writing will cause both the stream and
+the buffer to get destroyed. Note that failure to write the entire
+buffer is considered an error for the purposes of sending a datagram.</p>
+<p>The <code>buf</code> parameter here only requires the <code>AsRef<[u8]></code> trait, which
+should be broadly applicable to accepting data which can be converted
+to a slice. The <code>Window</code> struct is also available in this crate to
+provide a different window into a slice if necessary.</p>
+</div><h4 id='method.recv_from' class="method"><span id='recv_from.v' class='invisible'><code>pub fn <a href='#method.recv_from' class='fnname'>recv_from</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#179-192' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Receives data from the socket. On success, returns the number of bytes
+read and the address from whence the data came.</p>
+</div><h4 id='method.recv_dgram' class="method"><span id='recv_dgram.v' class='invisible'><code>pub fn <a href='#method.recv_dgram' class='fnname'>recv_dgram</a><T>(self, buf: T) -> <a class="struct" href="../../tokio_core/net/struct.RecvDgram.html" title="struct tokio_core::net::RecvDgram">RecvDgram</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsMut.html" title="trait core::convert::AsMut">AsMut</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#208-212' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a future that receive a datagram to be written to the buffer
+provided.</p>
+<p>The returned future will return after a datagram has been received on
+this socket. The future will resolve to the socket, the buffer, the
+amount of data read, and the address the data was received from.</p>
+<p>An error during reading will cause the socket and buffer to get
+destroyed and the socket will be returned.</p>
+<p>The <code>buf</code> parameter here only requires the <code>AsMut<[u8]></code> trait, which
+should be broadly applicable to accepting data which can be converted
+to a slice. The <code>Window</code> struct is also available in this crate to
+provide a different window into a slice if necessary.</p>
+</div><h4 id='method.broadcast' class="method"><span id='broadcast.v' class='invisible'><code>pub fn <a href='#method.broadcast' class='fnname'>broadcast</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#220-222' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>SO_BROADCAST</code> option for this socket.</p>
+<p>For more information about this option, see
+<a href="#method.set_broadcast"><code>set_broadcast</code></a>.</p>
+</div><h4 id='method.set_broadcast' class="method"><span id='set_broadcast.v' class='invisible'><code>pub fn <a href='#method.set_broadcast' class='fnname'>set_broadcast</a>(&self, on: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#228-230' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>SO_BROADCAST</code> option for this socket.</p>
+<p>When enabled, this socket is allowed to send packets to a broadcast
+address.</p>
+</div><h4 id='method.multicast_loop_v4' class="method"><span id='multicast_loop_v4.v' class='invisible'><code>pub fn <a href='#method.multicast_loop_v4' class='fnname'>multicast_loop_v4</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#238-240' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IP_MULTICAST_LOOP</code> option for this socket.</p>
+<p>For more information about this option, see
+<a href="#method.set_multicast_loop_v4"><code>set_multicast_loop_v4</code></a>.</p>
+</div><h4 id='method.set_multicast_loop_v4' class="method"><span id='set_multicast_loop_v4.v' class='invisible'><code>pub fn <a href='#method.set_multicast_loop_v4' class='fnname'>set_multicast_loop_v4</a>(&self, on: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#246-248' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>IP_MULTICAST_LOOP</code> option for this socket.</p>
+<p>If enabled, multicast packets will be looped back to the local socket.
+Note that this may not have any affect on IPv6 sockets.</p>
+</div><h4 id='method.multicast_ttl_v4' class="method"><span id='multicast_ttl_v4.v' class='invisible'><code>pub fn <a href='#method.multicast_ttl_v4' class='fnname'>multicast_ttl_v4</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#256-258' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IP_MULTICAST_TTL</code> option for this socket.</p>
+<p>For more information about this option, see
+<a href="#method.set_multicast_ttl_v4"><code>set_multicast_ttl_v4</code></a>.</p>
+</div><h4 id='method.set_multicast_ttl_v4' class="method"><span id='set_multicast_ttl_v4.v' class='invisible'><code>pub fn <a href='#method.set_multicast_ttl_v4' class='fnname'>set_multicast_ttl_v4</a>(&self, ttl: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#267-269' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>IP_MULTICAST_TTL</code> option for this socket.</p>
+<p>Indicates the time-to-live value of outgoing multicast packets for
+this socket. The default value is 1 which means that multicast packets
+don't leave the local network unless explicitly requested.</p>
+<p>Note that this may not have any affect on IPv6 sockets.</p>
+</div><h4 id='method.multicast_loop_v6' class="method"><span id='multicast_loop_v6.v' class='invisible'><code>pub fn <a href='#method.multicast_loop_v6' class='fnname'>multicast_loop_v6</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#277-279' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IPV6_MULTICAST_LOOP</code> option for this socket.</p>
+<p>For more information about this option, see
+<a href="#method.set_multicast_loop_v6"><code>set_multicast_loop_v6</code></a>.</p>
+</div><h4 id='method.set_multicast_loop_v6' class="method"><span id='set_multicast_loop_v6.v' class='invisible'><code>pub fn <a href='#method.set_multicast_loop_v6' class='fnname'>set_multicast_loop_v6</a>(&self, on: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#285-287' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value of the <code>IPV6_MULTICAST_LOOP</code> option for this socket.</p>
+<p>Controls whether this socket sees the multicast packets it sends itself.
+Note that this may not have any affect on IPv4 sockets.</p>
+</div><h4 id='method.ttl' class="method"><span id='ttl.v' class='invisible'><code>pub fn <a href='#method.ttl' class='fnname'>ttl</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#294-296' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IP_TTL</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#method.set_ttl"><code>set_ttl</code></a>.</p>
+</div><h4 id='method.set_ttl' class="method"><span id='set_ttl.v' class='invisible'><code>pub fn <a href='#method.set_ttl' class='fnname'>set_ttl</a>(&self, ttl: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#302-304' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IP_TTL</code> option on this socket.</p>
+<p>This value sets the time-to-live field that is used in every packet sent
+from this socket.</p>
+</div><h4 id='method.join_multicast_v4' class="method"><span id='join_multicast_v4.v' class='invisible'><code>pub fn <a href='#method.join_multicast_v4' class='fnname'>join_multicast_v4</a>(<br> &self, <br> multiaddr: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv4Addr.html" title="struct std::net::ip::Ipv4Addr">Ipv4Addr</a>, <br> interface: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv4Addr.html" title="struct std::net::ip::Ipv4Addr">Ipv4Addr</a><br>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#313-317' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes an operation of the <code>IP_ADD_MEMBERSHIP</code> type.</p>
+<p>This function specifies a new multicast group for this socket to join.
+The address must be a valid multicast address, and <code>interface</code> is the
+address of the local interface with which the system should join the
+multicast group. If it's equal to <code>INADDR_ANY</code> then an appropriate
+interface is chosen by the system.</p>
+</div><h4 id='method.join_multicast_v6' class="method"><span id='join_multicast_v6.v' class='invisible'><code>pub fn <a href='#method.join_multicast_v6' class='fnname'>join_multicast_v6</a>(<br> &self, <br> multiaddr: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv6Addr.html" title="struct std::net::ip::Ipv6Addr">Ipv6Addr</a>, <br> interface: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a><br>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#324-328' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes an operation of the <code>IPV6_ADD_MEMBERSHIP</code> type.</p>
+<p>This function specifies a new multicast group for this socket to join.
+The address must be a valid multicast address, and <code>interface</code> is the
+index of the interface to join/leave (or 0 to indicate any interface).</p>
+</div><h4 id='method.leave_multicast_v4' class="method"><span id='leave_multicast_v4.v' class='invisible'><code>pub fn <a href='#method.leave_multicast_v4' class='fnname'>leave_multicast_v4</a>(<br> &self, <br> multiaddr: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv4Addr.html" title="struct std::net::ip::Ipv4Addr">Ipv4Addr</a>, <br> interface: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv4Addr.html" title="struct std::net::ip::Ipv4Addr">Ipv4Addr</a><br>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#336-340' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes an operation of the <code>IP_DROP_MEMBERSHIP</code> type.</p>
+<p>For more information about this option, see
+<a href="#method.join_multicast_v4"><code>join_multicast_v4</code></a>.</p>
+</div><h4 id='method.leave_multicast_v6' class="method"><span id='leave_multicast_v6.v' class='invisible'><code>pub fn <a href='#method.leave_multicast_v6' class='fnname'>leave_multicast_v6</a>(<br> &self, <br> multiaddr: &<a class="struct" href="https://doc.rust-lang.org/nightly/std/net/ip/struct.Ipv6Addr.html" title="struct std::net::ip::Ipv6Addr">Ipv6Addr</a>, <br> interface: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a><br>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#348-352' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes an operation of the <code>IPV6_DROP_MEMBERSHIP</code> type.</p>
+<p>For more information about this option, see
+<a href="#method.join_multicast_v6"><code>join_multicast_v6</code></a>.</p>
+</div><h4 id='method.set_only_v6' class="method"><span id='set_only_v6.v' class='invisible'><code>pub fn <a href='#method.set_only_v6' class='fnname'>set_only_v6</a>(&self, only_v6: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#362-364' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Sets the value for the <code>IPV6_V6ONLY</code> option on this socket.</p>
+<p>If this is set to <code>true</code> then the socket is restricted to sending and
+receiving IPv6 packets only. In this case two IPv4 and IPv6 applications
+can bind the same port at the same time.</p>
+<p>If this is set to <code>false</code> then the socket can be used to send and
+receive packets from an IPv4-mapped IPv6 address.</p>
+</div><h4 id='method.only_v6' class="method"><span id='only_v6.v' class='invisible'><code>pub fn <a href='#method.only_v6' class='fnname'>only_v6</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#371-373' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Gets the value of the <code>IPV6_V6ONLY</code> option for this socket.</p>
+<p>For more information about this option, see <a href="#method.set_only_v6"><code>set_only_v6</code></a>.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-AsRawFd' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html" title="trait std::sys::unix::ext::io::AsRawFd">AsRawFd</a> for <a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code><a href='#impl-AsRawFd' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#444-448' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.as_raw_fd' class="method"><span id='as_raw_fd.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd' class='fnname'>as_raw_fd</a>(&self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/type.RawFd.html" title="type std::sys::unix::ext::io::RawFd">RawFd</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#445-447' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Extracts the raw file descriptor. <a href="https://doc.rust-lang.org/nightly/std/sys/unix/ext/io/trait.AsRawFd.html#tymethod.as_raw_fd">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/net/struct.UdpSocket.html" title="struct tokio_core::net::UdpSocket">UdpSocket</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#376-380' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/net/udp/mod.rs.html#377-379' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/Incoming.t.html b/tokio_core/net/tcp/Incoming.t.html
new file mode 100644
index 0000000..9c81029
--- /dev/null
+++ b/tokio_core/net/tcp/Incoming.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Incoming.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Incoming.html">struct.Incoming.html</a>...</p>
+ <script>location.replace("struct.Incoming.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/TcpListener.t.html b/tokio_core/net/tcp/TcpListener.t.html
new file mode 100644
index 0000000..3434754
--- /dev/null
+++ b/tokio_core/net/tcp/TcpListener.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpListener.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpListener.html">struct.TcpListener.html</a>...</p>
+ <script>location.replace("struct.TcpListener.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/TcpStream.t.html b/tokio_core/net/tcp/TcpStream.t.html
new file mode 100644
index 0000000..4716a01
--- /dev/null
+++ b/tokio_core/net/tcp/TcpStream.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpStream.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpStream.html">struct.TcpStream.html</a>...</p>
+ <script>location.replace("struct.TcpStream.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/TcpStreamNew.t.html b/tokio_core/net/tcp/TcpStreamNew.t.html
new file mode 100644
index 0000000..4b8289d
--- /dev/null
+++ b/tokio_core/net/tcp/TcpStreamNew.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.TcpStreamNew.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.TcpStreamNew.html">struct.TcpStreamNew.html</a>...</p>
+ <script>location.replace("struct.TcpStreamNew.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/struct.Incoming.html b/tokio_core/net/tcp/struct.Incoming.html
new file mode 100644
index 0000000..6dc83cf
--- /dev/null
+++ b/tokio_core/net/tcp/struct.Incoming.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.Incoming.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.Incoming.html">../../../tokio_core/net/struct.Incoming.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.Incoming.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/struct.TcpListener.html b/tokio_core/net/tcp/struct.TcpListener.html
new file mode 100644
index 0000000..65e0f0b
--- /dev/null
+++ b/tokio_core/net/tcp/struct.TcpListener.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.TcpListener.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.TcpListener.html">../../../tokio_core/net/struct.TcpListener.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.TcpListener.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/struct.TcpStream.html b/tokio_core/net/tcp/struct.TcpStream.html
new file mode 100644
index 0000000..820e174
--- /dev/null
+++ b/tokio_core/net/tcp/struct.TcpStream.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.TcpStream.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.TcpStream.html">../../../tokio_core/net/struct.TcpStream.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.TcpStream.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/tcp/struct.TcpStreamNew.html b/tokio_core/net/tcp/struct.TcpStreamNew.html
new file mode 100644
index 0000000..e38d05a
--- /dev/null
+++ b/tokio_core/net/tcp/struct.TcpStreamNew.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.TcpStreamNew.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.TcpStreamNew.html">../../../tokio_core/net/struct.TcpStreamNew.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.TcpStreamNew.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/trait.UdpCodec.html b/tokio_core/net/trait.UdpCodec.html
new file mode 100644
index 0000000..0236a7e
--- /dev/null
+++ b/tokio_core/net/trait.UdpCodec.html
@@ -0,0 +1,176 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `UdpCodec` trait in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, UdpCodec">
+
+ <title>tokio_core::net::UdpCodec - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc trait">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Trait UdpCodec</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#associated-types">Associated Types</a><div class="sidebar-links"><a href="#associatedtype.In">In</a><a href="#associatedtype.Out">Out</a></div><a class="sidebar-title" href="#required-methods">Required Methods</a><div class="sidebar-links"><a href="#tymethod.decode">decode</a><a href="#tymethod.encode">encode</a></div><a class="sidebar-title" href="#implementors">Implementors</a></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a></p><script>window.sidebarCurrent = {name: 'UdpCodec', ty: 'trait', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Trait <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>net</a>::<wbr><a class="trait" href=''>UdpCodec</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/net/udp/frame.rs.html#22-51' title='goto source code'>[src]</a></span></h1>
+<pre class='rust trait'>pub trait UdpCodec {
+ type <a href='#associatedtype.In' class="type">In</a>;
+ type <a href='#associatedtype.Out' class="type">Out</a>;
+ fn <a href='#tymethod.decode' class='fnname'>decode</a>(&mut self, src: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><Self::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.In" title="type tokio_core::net::UdpCodec::In">In</a>>;
+<div class='item-spacer'></div> fn <a href='#tymethod.encode' class='fnname'>encode</a>(&mut self, msg: Self::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.Out" title="type tokio_core::net::UdpCodec::Out">Out</a>, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>;
+}</pre><div class='docblock'><p>Encoding of frames via buffers.</p>
+<p>This trait is used when constructing an instance of <code>UdpFramed</code> and provides
+the <code>In</code> and <code>Out</code> types which are decoded and encoded from the socket,
+respectively.</p>
+<p>Because UDP is a connectionless protocol, the <code>decode</code> method receives the
+address where data came from and the <code>encode</code> method is also responsible for
+determining the remote host to which the datagram should be sent</p>
+<p>The trait itself is implemented on a type that can track state for decoding
+or encoding, which is particularly useful for streaming parsers. In many
+cases, though, this type will simply be a unit struct (e.g. <code>struct HttpCodec</code>).</p>
+</div>
+ <h2 id='associated-types' class='small-section-header'>
+ Associated Types<a href='#associated-types' class='anchor'></a>
+ </h2>
+ <div class='methods'>
+ <h3 id='associatedtype.In' class='method'><span id='In.t' class='invisible'><code>type <a href='#associatedtype.In' class="type">In</a></code></span></h3><div class='docblock'><p>The type of decoded frames.</p>
+</div><h3 id='associatedtype.Out' class='method'><span id='Out.t' class='invisible'><code>type <a href='#associatedtype.Out' class="type">Out</a></code></span></h3><div class='docblock'><p>The type of frames to be encoded.</p>
+</div></div>
+ <h2 id='required-methods' class='small-section-header'>
+ Required Methods<a href='#required-methods' class='anchor'></a>
+ </h2>
+ <div class='methods'>
+ <h3 id='tymethod.decode' class='method'><span id='decode.v' class='invisible'><code>fn <a href='#tymethod.decode' class='fnname'>decode</a>(&mut self, src: &<a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a>, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><Self::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.In" title="type tokio_core::net::UdpCodec::In">In</a>></code></span></h3><div class='docblock'><p>Attempts to decode a frame from the provided buffer of bytes.</p>
+<p>This method is called by <code>UdpFramed</code> on a single datagram which has been
+read from a socket. The <code>buf</code> argument contains the data that was
+received from the remote address, and <code>src</code> is the address the data came
+from. Note that typically this method should require the entire contents
+of <code>buf</code> to be valid or otherwise return an error with trailing data.</p>
+<p>Finally, if the bytes in the buffer are malformed then an error is
+returned indicating why. This informs <code>Framed</code> that the stream is now
+corrupt and should be terminated.</p>
+</div><h3 id='tymethod.encode' class='method'><span id='encode.v' class='invisible'><code>fn <a href='#tymethod.encode' class='fnname'>encode</a>(&mut self, msg: Self::<a class="type" href="../../tokio_core/net/trait.UdpCodec.html#associatedtype.Out" title="type tokio_core::net::UdpCodec::Out">Out</a>, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/std/net/addr/enum.SocketAddr.html" title="enum std::net::addr::SocketAddr">SocketAddr</a></code></span></h3><div class='docblock'><p>Encodes a frame into the buffer provided.</p>
+<p>This method will encode <code>msg</code> into the byte buffer provided by <code>buf</code>.
+The <code>buf</code> provided is an internal buffer of the <code>Framed</code> instance and
+will be written out when possible.</p>
+<p>The encode method also determines the destination to which the buffer
+should be directed, which will be returned as a <code>SocketAddr</code>.</p>
+</div></div>
+ <h2 id='implementors' class='small-section-header'>
+ Implementors<a href='#implementors' class='anchor'></a>
+ </h2>
+ <ul class='item-list' id='implementors-list'>
+ </ul><script type="text/javascript" async
+ src="../../implementors/tokio_core/net/trait.UdpCodec.js">
+ </script></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/RecvDgram.t.html b/tokio_core/net/udp/RecvDgram.t.html
new file mode 100644
index 0000000..6fc423a
--- /dev/null
+++ b/tokio_core/net/udp/RecvDgram.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.RecvDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.RecvDgram.html">struct.RecvDgram.html</a>...</p>
+ <script>location.replace("struct.RecvDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/SendDgram.t.html b/tokio_core/net/udp/SendDgram.t.html
new file mode 100644
index 0000000..b5ad102
--- /dev/null
+++ b/tokio_core/net/udp/SendDgram.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.SendDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.SendDgram.html">struct.SendDgram.html</a>...</p>
+ <script>location.replace("struct.SendDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/UdpSocket.t.html b/tokio_core/net/udp/UdpSocket.t.html
new file mode 100644
index 0000000..2d72edb
--- /dev/null
+++ b/tokio_core/net/udp/UdpSocket.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.UdpSocket.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.UdpSocket.html">struct.UdpSocket.html</a>...</p>
+ <script>location.replace("struct.UdpSocket.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/frame/UdpCodec.t.html b/tokio_core/net/udp/frame/UdpCodec.t.html
new file mode 100644
index 0000000..2274d16
--- /dev/null
+++ b/tokio_core/net/udp/frame/UdpCodec.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=trait.UdpCodec.html">
+</head>
+<body>
+ <p>Redirecting to <a href="trait.UdpCodec.html">trait.UdpCodec.html</a>...</p>
+ <script>location.replace("trait.UdpCodec.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/frame/UdpFramed.t.html b/tokio_core/net/udp/frame/UdpFramed.t.html
new file mode 100644
index 0000000..15a771b
--- /dev/null
+++ b/tokio_core/net/udp/frame/UdpFramed.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.UdpFramed.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.UdpFramed.html">struct.UdpFramed.html</a>...</p>
+ <script>location.replace("struct.UdpFramed.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/frame/struct.UdpFramed.html b/tokio_core/net/udp/frame/struct.UdpFramed.html
new file mode 100644
index 0000000..6733804
--- /dev/null
+++ b/tokio_core/net/udp/frame/struct.UdpFramed.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../../tokio_core/net/struct.UdpFramed.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../../tokio_core/net/struct.UdpFramed.html">../../../../tokio_core/net/struct.UdpFramed.html</a>...</p>
+ <script>location.replace("../../../../tokio_core/net/struct.UdpFramed.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/frame/trait.UdpCodec.html b/tokio_core/net/udp/frame/trait.UdpCodec.html
new file mode 100644
index 0000000..04fb3ac
--- /dev/null
+++ b/tokio_core/net/udp/frame/trait.UdpCodec.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../../tokio_core/net/trait.UdpCodec.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../../tokio_core/net/trait.UdpCodec.html">../../../../tokio_core/net/trait.UdpCodec.html</a>...</p>
+ <script>location.replace("../../../../tokio_core/net/trait.UdpCodec.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/struct.RecvDgram.html b/tokio_core/net/udp/struct.RecvDgram.html
new file mode 100644
index 0000000..8878d5b
--- /dev/null
+++ b/tokio_core/net/udp/struct.RecvDgram.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.RecvDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.RecvDgram.html">../../../tokio_core/net/struct.RecvDgram.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.RecvDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/struct.SendDgram.html b/tokio_core/net/udp/struct.SendDgram.html
new file mode 100644
index 0000000..9850a44
--- /dev/null
+++ b/tokio_core/net/udp/struct.SendDgram.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.SendDgram.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.SendDgram.html">../../../tokio_core/net/struct.SendDgram.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.SendDgram.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/net/udp/struct.UdpSocket.html b/tokio_core/net/udp/struct.UdpSocket.html
new file mode 100644
index 0000000..635d060
--- /dev/null
+++ b/tokio_core/net/udp/struct.UdpSocket.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/net/struct.UdpSocket.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/net/struct.UdpSocket.html">../../../tokio_core/net/struct.UdpSocket.html</a>...</p>
+ <script>location.replace("../../../tokio_core/net/struct.UdpSocket.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/Core.t.html b/tokio_core/reactor/Core.t.html
new file mode 100644
index 0000000..b11842b
--- /dev/null
+++ b/tokio_core/reactor/Core.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Core.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Core.html">struct.Core.html</a>...</p>
+ <script>location.replace("struct.Core.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/CoreId.t.html b/tokio_core/reactor/CoreId.t.html
new file mode 100644
index 0000000..95809b0
--- /dev/null
+++ b/tokio_core/reactor/CoreId.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.CoreId.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.CoreId.html">struct.CoreId.html</a>...</p>
+ <script>location.replace("struct.CoreId.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/Handle.t.html b/tokio_core/reactor/Handle.t.html
new file mode 100644
index 0000000..a1f0164
--- /dev/null
+++ b/tokio_core/reactor/Handle.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Handle.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Handle.html">struct.Handle.html</a>...</p>
+ <script>location.replace("struct.Handle.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/Interval.t.html b/tokio_core/reactor/Interval.t.html
new file mode 100644
index 0000000..e631bee
--- /dev/null
+++ b/tokio_core/reactor/Interval.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Interval.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Interval.html">struct.Interval.html</a>...</p>
+ <script>location.replace("struct.Interval.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/PollEvented.t.html b/tokio_core/reactor/PollEvented.t.html
new file mode 100644
index 0000000..8825548
--- /dev/null
+++ b/tokio_core/reactor/PollEvented.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.PollEvented.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.PollEvented.html">struct.PollEvented.html</a>...</p>
+ <script>location.replace("struct.PollEvented.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/Remote.t.html b/tokio_core/reactor/Remote.t.html
new file mode 100644
index 0000000..88e97ab
--- /dev/null
+++ b/tokio_core/reactor/Remote.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Remote.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Remote.html">struct.Remote.html</a>...</p>
+ <script>location.replace("struct.Remote.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/Timeout.t.html b/tokio_core/reactor/Timeout.t.html
new file mode 100644
index 0000000..d6412e0
--- /dev/null
+++ b/tokio_core/reactor/Timeout.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Timeout.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Timeout.html">struct.Timeout.html</a>...</p>
+ <script>location.replace("struct.Timeout.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/index.html b/tokio_core/reactor/index.html
new file mode 100644
index 0000000..0d7e4a6
--- /dev/null
+++ b/tokio_core/reactor/index.html
@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `reactor` mod in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, reactor">
+
+ <title>tokio_core::reactor - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc mod">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Module reactor</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#structs">Structs</a></li></ul></div><p class='location'><a href='../index.html'>tokio_core</a></p><script>window.sidebarCurrent = {name: 'reactor', ty: 'mod', relpath: '../'};</script><script defer src="../sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Module <a href='../index.html'>tokio_core</a>::<wbr><a class="mod" href=''>reactor</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#1-933' title='goto source code'>[src]</a></span></h1>
+<div class='docblock'><p>The core reactor driving all I/O</p>
+<p>This module contains the <code>Core</code> type which is the reactor for all I/O
+happening in <code>tokio-core</code>. This reactor (or event loop) is used to run
+futures, schedule tasks, issue I/O requests, etc.</p>
+</div><h2 id='structs' class='section-header'><a href="#structs">Structs</a></h2>
+<table>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Core.html"
+ title='struct tokio_core::reactor::Core'>Core</a></td>
+ <td class='docblock-short'>
+ <p>An event loop.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.CoreId.html"
+ title='struct tokio_core::reactor::CoreId'>CoreId</a></td>
+ <td class='docblock-short'>
+ <p>An unique ID for a Core</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Handle.html"
+ title='struct tokio_core::reactor::Handle'>Handle</a></td>
+ <td class='docblock-short'>
+ <p>A non-sendable handle to an event loop, useful for manufacturing instances
+of <code>LoopData</code>.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Interval.html"
+ title='struct tokio_core::reactor::Interval'>Interval</a></td>
+ <td class='docblock-short'>
+ <p>A stream representing notifications at fixed interval</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.PollEvented.html"
+ title='struct tokio_core::reactor::PollEvented'>PollEvented</a></td>
+ <td class='docblock-short'>
+ <p>A concrete implementation of a stream of readiness notifications for I/O
+objects that originates from an event loop.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Remote.html"
+ title='struct tokio_core::reactor::Remote'>Remote</a></td>
+ <td class='docblock-short'>
+ <p>Handle to an event loop, used to construct I/O objects, send messages, and
+otherwise interact indirectly with the event loop itself.</p>
+
+ </td>
+ </tr>
+ <tr class=' module-item'>
+ <td><a class="struct" href="struct.Timeout.html"
+ title='struct tokio_core::reactor::Timeout'>Timeout</a></td>
+ <td class='docblock-short'>
+ <p>A future representing the notification that a timeout has occurred.</p>
+
+ </td>
+ </tr></table></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/interval/Interval.t.html b/tokio_core/reactor/interval/Interval.t.html
new file mode 100644
index 0000000..e631bee
--- /dev/null
+++ b/tokio_core/reactor/interval/Interval.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Interval.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Interval.html">struct.Interval.html</a>...</p>
+ <script>location.replace("struct.Interval.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/interval/struct.Interval.html b/tokio_core/reactor/interval/struct.Interval.html
new file mode 100644
index 0000000..591a4bf
--- /dev/null
+++ b/tokio_core/reactor/interval/struct.Interval.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/reactor/struct.Interval.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/reactor/struct.Interval.html">../../../tokio_core/reactor/struct.Interval.html</a>...</p>
+ <script>location.replace("../../../tokio_core/reactor/struct.Interval.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/poll_evented/PollEvented.t.html b/tokio_core/reactor/poll_evented/PollEvented.t.html
new file mode 100644
index 0000000..8825548
--- /dev/null
+++ b/tokio_core/reactor/poll_evented/PollEvented.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.PollEvented.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.PollEvented.html">struct.PollEvented.html</a>...</p>
+ <script>location.replace("struct.PollEvented.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/poll_evented/struct.PollEvented.html b/tokio_core/reactor/poll_evented/struct.PollEvented.html
new file mode 100644
index 0000000..0d72b5d
--- /dev/null
+++ b/tokio_core/reactor/poll_evented/struct.PollEvented.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/reactor/struct.PollEvented.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/reactor/struct.PollEvented.html">../../../tokio_core/reactor/struct.PollEvented.html</a>...</p>
+ <script>location.replace("../../../tokio_core/reactor/struct.PollEvented.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/sidebar-items.js b/tokio_core/reactor/sidebar-items.js
new file mode 100644
index 0000000..e8696cc
--- /dev/null
+++ b/tokio_core/reactor/sidebar-items.js
@@ -0,0 +1 @@
+initSidebarItems({"struct":[["Core","An event loop."],["CoreId","An unique ID for a Core"],["Handle","A non-sendable handle to an event loop, useful for manufacturing instances of `LoopData`."],["Interval","A stream representing notifications at fixed interval"],["PollEvented","A concrete implementation of a stream of readiness notifications for I/O objects that originates from an event loop."],["Remote","Handle to an event loop, used to construct I/O objects, send messages, and otherwise interact indirectly with the event loop itself."],["Timeout","A future representing the notification that a timeout has occurred."]]});
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.Core.html b/tokio_core/reactor/struct.Core.html
new file mode 100644
index 0000000..4ed641e
--- /dev/null
+++ b/tokio_core/reactor/struct.Core.html
@@ -0,0 +1,183 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Core` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Core">
+
+ <title>tokio_core::reactor::Core - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Core</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.handle">handle</a><a href="#method.remote">remote</a><a href="#method.run">run</a><a href="#method.turn">turn</a><a href="#method.id">id</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Executor%3CF%3E">Executor<F></a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'Core', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>Core</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#48-62' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct Core { /* fields omitted */ }</pre><div class='docblock'><p>An event loop.</p>
+<p>The event loop is the main source of blocking in an application which drives
+all other I/O events and notifications happening. Each event loop can have
+multiple handles pointing to it, each of which can then be used to create
+various I/O objects to interact with the event loop in interesting ways.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/reactor/struct.Core.html" title="struct tokio_core::reactor::Core">Core</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#146-444' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><code>pub fn <a href='#method.new' class='fnname'>new</a>() -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.Core.html" title="struct tokio_core::reactor::Core">Core</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#149-184' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new event loop, returning any error that happened during the
+creation.</p>
+</div><h4 id='method.handle' class="method"><span id='handle.v' class='invisible'><code>pub fn <a href='#method.handle' class='fnname'>handle</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#192-197' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a handle to this event loop which cannot be sent across threads
+but can be used as a proxy to the event loop itself.</p>
+<p>Handles are cloneable and clones always refer to the same event loop.
+This handle is typically passed into functions that create I/O objects
+to bind them to this event loop.</p>
+</div><h4 id='method.remote' class="method"><span id='remote.v' class='invisible'><code>pub fn <a href='#method.remote' class='fnname'>remote</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#201-206' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Generates a remote handle to this event loop which can be used to spawn
+tasks from other threads into this event loop.</p>
+</div><h4 id='method.run' class="method"><span id='run.v' class='invisible'><code>pub fn <a href='#method.run' class='fnname'>run</a><F>(&mut self, f: F) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><F::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, F::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#226-243' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Runs a future until completion, driving the event loop while we're
+otherwise waiting for the future to complete.</p>
+<p>This function will begin executing the event loop and will finish once
+the provided future is resolved. Note that the future argument here
+crucially does not require the <code>'static</code> nor <code>Send</code> bounds. As a result
+the future will be "pinned" to not only this thread but also this stack
+frame.</p>
+<p>This function will return the value that the future resolves to once
+the future has finished. If the future never resolves then this function
+will never return.</p>
+<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
+<p>This method will <strong>not</strong> catch panics from polling the future <code>f</code>. If
+the future panics then it's the responsibility of the caller to catch
+that panic and handle it as appropriate.</p>
+</div><h4 id='method.turn' class="method"><span id='turn.v' class='invisible'><code>pub fn <a href='#method.turn' class='fnname'>turn</a>(&mut self, max_wait: <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#253-255' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Performs one iteration of the event loop, blocking on waiting for events
+for at most <code>max_wait</code> (forever if <code>None</code>).</p>
+<p>It only makes sense to call this method if you've previously spawned
+a future onto this event loop.</p>
+<p><code>loop { lp.turn(None) }</code> is equivalent to calling <code>run</code> with an
+empty future (one that never finishes).</p>
+</div><h4 id='method.id' class="method"><span id='id.v' class='invisible'><code>pub fn <a href='#method.id' class='fnname'>id</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#441-443' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Get the ID of this loop</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Executor%3CF%3E' class='impl'><span class='in-band'><code>impl<F> <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html" title="trait futures::future::Executor">Executor</a><F> for <a class="struct" href="../../tokio_core/reactor/struct.Core.html" title="struct tokio_core::reactor::Core">Core</a> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>> + 'static, </span></code><a href='#impl-Executor%3CF%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#446-452' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.execute' class="method"><span id='execute.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute' class='fnname'>execute</a>(&self, future: F) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://docs.rs/futures/0.1/futures/future/struct.ExecuteError.html" title="struct futures::future::ExecuteError">ExecuteError</a><F>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#449-451' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a future to run on this <code>Executor</code>, typically in the "background". <a href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.Core.html" title="struct tokio_core::reactor::Core">Core</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#454-460' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#455-459' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.CoreId.html b/tokio_core/reactor/struct.CoreId.html
new file mode 100644
index 0000000..6bb6b75
--- /dev/null
+++ b/tokio_core/reactor/struct.CoreId.html
@@ -0,0 +1,155 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `CoreId` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, CoreId">
+
+ <title>tokio_core::reactor::CoreId - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct CoreId</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Copy">Copy</a><a href="#impl-Eq">Eq</a><a href="#impl-PartialEq">PartialEq</a><a href="#impl-Hash">Hash</a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'CoreId', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>CoreId</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#89' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct CoreId(_);</pre><div class='docblock'><p>An unique ID for a Core</p>
+<p>An ID by which different cores may be distinguished. Can be compared and used as an index in
+a <code>HashMap</code>.</p>
+<p>The ID is globally unique and never reused.</p>
+</div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Clone' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-Clone' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
+</div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#112-114' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
+</div></div><h3 id='impl-Copy' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-Copy' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'></div><h3 id='impl-Eq' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-Eq' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'></div><h3 id='impl-PartialEq' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-PartialEq' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.eq' class="method"><span id='eq.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, __arg_0: &<a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
+</div><h4 id='method.ne' class="method"><span id='ne.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, __arg_0: &<a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>This method tests for <code>!=</code>.</p>
+</div></div><h3 id='impl-Hash' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-Hash' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.hash' class="method"><span id='hash.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><__H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>>(&self, __arg_0: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>__H)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
+</div><h4 id='method.hash_slice' class="method"><span id='hash_slice.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a><H>(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>H) <span class="where fmt-newline">where<br> H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.3.0'>1.3.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#202-208' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, __arg_0: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#88' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.Handle.html b/tokio_core/reactor/struct.Handle.html
new file mode 100644
index 0000000..11a9471
--- /dev/null
+++ b/tokio_core/reactor/struct.Handle.html
@@ -0,0 +1,169 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Handle` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Handle">
+
+ <title>tokio_core::reactor::Handle - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Handle</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.remote">remote</a><a href="#method.spawn">spawn</a><a href="#method.spawn_fn">spawn_fn</a><a href="#method.id">id</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Executor%3CF%3E">Executor<F></a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'Handle', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>Handle</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#105-108' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct Handle { /* fields omitted */ }</pre><div class='docblock'><p>A non-sendable handle to an event loop, useful for manufacturing instances
+of <code>LoopData</code>.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#706-752' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.remote' class="method"><span id='remote.v' class='invisible'><code>pub fn <a href='#method.remote' class='fnname'>remote</a>(&self) -> &<a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#708-710' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a reference to the underlying remote handle to the event loop.</p>
+</div><h4 id='method.spawn' class="method"><span id='spawn.v' class='invisible'><code>pub fn <a href='#method.spawn' class='fnname'>spawn</a><F>(&self, f: F) <span class="where fmt-newline">where<br> F: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>> + 'static, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#719-727' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a new future on the event loop this handle is associated with.</p>
+<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
+<p>This method will <strong>not</strong> catch panics from polling the future <code>f</code>. If
+the future panics then it's the responsibility of the caller to catch
+that panic and handle it as appropriate.</p>
+</div><h4 id='method.spawn_fn' class="method"><span id='spawn_fn.v' class='invisible'><code>pub fn <a href='#method.spawn_fn' class='fnname'>spawn_fn</a><F, R>(&self, f: F) <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> R + 'static,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>> + 'static, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#741-746' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a closure on this event loop.</p>
+<p>This function is a convenience wrapper around the <code>spawn</code> function above
+for running a closure wrapped in <code>futures::lazy</code>. It will spawn the
+function <code>f</code> provided onto the event loop, and continue to run the
+future returned by <code>f</code> on the event loop as well.</p>
+<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
+<p>This method will <strong>not</strong> catch panics from polling the future <code>f</code>. If
+the future panics then it's the responsibility of the caller to catch
+that panic and handle it as appropriate.</p>
+</div><h4 id='method.id' class="method"><span id='id.v' class='invisible'><code>pub fn <a href='#method.id' class='fnname'>id</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#749-751' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Return the ID of the represented Core</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Clone' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a></code><a href='#impl-Clone' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#104' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#104' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
+</div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#112-114' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
+</div></div><h3 id='impl-Executor%3CF%3E' class='impl'><span class='in-band'><code>impl<F> <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html" title="trait futures::future::Executor">Executor</a><F> for <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>> + 'static, </span></code><a href='#impl-Executor%3CF%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#754-761' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.execute' class="method"><span id='execute.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute' class='fnname'>execute</a>(&self, future: F) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://docs.rs/futures/0.1/futures/future/struct.ExecuteError.html" title="struct futures::future::ExecuteError">ExecuteError</a><F>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#757-760' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a future to run on this <code>Executor</code>, typically in the "background". <a href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#763-769' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#764-768' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.Interval.html b/tokio_core/reactor/struct.Interval.html
new file mode 100644
index 0000000..acbf68f
--- /dev/null
+++ b/tokio_core/reactor/struct.Interval.html
@@ -0,0 +1,238 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Interval` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Interval">
+
+ <title>tokio_core::reactor::Interval - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Interval</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.new_at">new_at</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Stream">Stream</a><a href="#impl-Drop">Drop</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'Interval', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>Interval</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#25-30' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "streams do nothing unless polled"]
+</div>pub struct Interval { /* fields omitted */ }</pre><div class='docblock'><p>A stream representing notifications at fixed interval</p>
+<p>Intervals are created through the <code>Interval::new</code> or
+<code>Interval::new_at</code> methods indicating when a first notification
+should be triggered and when it will be repeated.</p>
+<p>Note that timeouts are not intended for high resolution timers, but rather
+they will likely fire some granularity after the exact instant that they're
+otherwise indicated to fire at.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/reactor/struct.Interval.html" title="struct tokio_core::reactor::Interval">Interval</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#32-82' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><code>pub fn <a href='#method.new' class='fnname'>new</a>(dur: <a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.Interval.html" title="struct tokio_core::reactor::Interval">Interval</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#39-41' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new interval which will fire at <code>dur</code> time into the future,
+and will repeat every <code>dur</code> interval after</p>
+<p>This function will return a future that will resolve to the actual
+interval object. The interval object itself is then a stream which will
+be set to fire at the specified intervals</p>
+</div><h4 id='method.new_at' class="method"><span id='new_at.v' class='invisible'><code>pub fn <a href='#method.new_at' class='fnname'>new_at</a>(at: <a class="struct" href="https://doc.rust-lang.org/nightly/std/time/struct.Instant.html" title="struct std::time::Instant">Instant</a>, dur: <a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.Interval.html" title="struct tokio_core::reactor::Interval">Interval</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#49-58' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new interval which will fire at the time specified by <code>at</code>,
+and then will repeat every <code>dur</code> interval after</p>
+<p>This function will return a future that will resolve to the actual
+timeout object. The timeout object itself is then a future which will be
+set to fire at the specified point in the future.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Stream' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a> for <a class="struct" href="../../tokio_core/reactor/struct.Interval.html" title="struct tokio_core::reactor::Interval">Interval</a></code><a href='#impl-Stream' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#84-92' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a></code></span></h4>
+<div class='docblock'><p>The type of item this stream will yield on success.</p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error this stream may generate.</p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#88-91' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempt to pull out the next value of this stream, returning <code>None</code> if the stream is finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S></h3><code class="content"><span class="where fmt-newline">impl<S> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, <S as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>;</span></code></div></div><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait' class='fnname'>wait</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/wait/struct.Wait.html" title="struct futures::stream::wait::Wait">Wait</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#244-248' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an iterator which blocks the current thread until each item of this stream is resolved. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.wait">Read more</a></p>
+</div><h4 id='method.into_future' class="method"><span id='into_future.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future' class='fnname'>into_future</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/future/struct.StreamFuture.html" title="struct futures::stream::future::StreamFuture">StreamFuture</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#291-295' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts this stream into a <code>Future</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.into_future">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map' class='fnname'>map</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map/struct.Map.html" title="struct futures::stream::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#316-321' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of type <code>T</code> to a stream of type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err' class='fnname'>map_err</a><U, F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/map_err/struct.MapErr.html" title="struct futures::stream::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#342-347' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Converts a stream of error type <code>T</code> to a stream of error type <code>U</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.map_err">Read more</a></p>
+</div><h4 id='method.filter' class="method"><span id='filter.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter' class='fnname'>filter</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter/struct.Filter.html" title="struct futures::stream::filter::Filter">Filter</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#372-377' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream according to the provided predicate. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter">Read more</a></p>
+</div><h4 id='method.filter_map' class="method"><span id='filter_map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map' class='fnname'>filter_map</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/filter_map/struct.FilterMap.html" title="struct futures::stream::filter_map::FilterMap">FilterMap</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><B>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#408-413' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Filters the values produced by this stream while simultaneously mapping them to a different type. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.filter_map">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then' class='fnname'>then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/then/struct.Then.html" title="struct futures::stream::then::Then">Then</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#447-453' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the resulting item to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then' class='fnname'>and_then</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/and_then/struct.AndThen.html" title="struct futures::stream::and_then::AndThen">AndThen</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#494-500' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a value is ready, passing the successful results to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else' class='fnname'>or_else</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/or_else/struct.OrElse.html" title="struct futures::stream::or_else::OrElse">OrElse</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#521-527' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when an error happens, passing the erroneous result to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.or_else">Read more</a></p>
+</div><h4 id='method.collect' class="method"><span id='collect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect' class='fnname'>collect</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/collect/struct.Collect.html" title="struct futures::stream::collect::Collect">Collect</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#562-566' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Collect all of the values of this stream into a vector, returning a future representing the result of that computation. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.collect">Read more</a></p>
+</div><h4 id='method.concat2' class="method"><span id='concat2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2' class='fnname'>concat2</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat2.html" title="struct futures::stream::concat::Concat2">Concat2</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#598-603' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat2">Read more</a></p>
+</div><h4 id='method.concat' class="method"><span id='concat.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat' class='fnname'>concat</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/concat/struct.Concat.html" title="struct futures::stream::concat::Concat">Concat</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.Extend.html" title="trait core::iter::traits::Extend">Extend</a><<Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#638-643' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated since 0.1.14<p>: please use <code>Stream::concat2</code> instead</p>
+</div></div><div class='docblock'><p>Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.concat">Read more</a></p>
+</div><h4 id='method.fold' class="method"><span id='fold.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold' class='fnname'>fold</a><F, T, Fut>(self, init: T, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fold/struct.Fold.html" title="struct futures::stream::fold::Fold">Fold</a><Self, F, Fut, T> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(T, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> Fut,<br> Fut: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = T>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<Fut as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#668-675' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute an accumulating computation over a stream, collecting all the values into one final result. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fold">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/flatten/struct.Flatten.html" title="struct futures::stream::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#710-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flattens a stream of streams into just one continuous stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.flatten">Read more</a></p>
+</div><h4 id='method.skip_while' class="method"><span id='skip_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while' class='fnname'>skip_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip_while/struct.SkipWhile.html" title="struct futures::stream::skip_while::SkipWhile">SkipWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#725-731' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Skip elements on this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip_while">Read more</a></p>
+</div><h4 id='method.take_while' class="method"><span id='take_while.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while' class='fnname'>take_while</a><P, R>(self, pred: P) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take_while/struct.TakeWhile.html" title="struct futures::stream::take_while::TakeWhile">TakeWhile</a><Self, P, R> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> R,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#739-745' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Take elements from this stream while the predicate provided resolves to <code>true</code>. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take_while">Read more</a></p>
+</div><h4 id='method.for_each' class="method"><span id='for_each.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each' class='fnname'>for_each</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/for_each/struct.ForEach.html" title="struct futures::stream::for_each::ForEach">ForEach</a><Self, F, U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> U,<br> U: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#761-767' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Runs this stream to completion, executing the provided closure for each element on the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.for_each">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/from_err/struct.FromErr.html" title="struct futures::stream::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#780-784' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this stream's error to any error implementing <code>From</code> for this stream's <code>Error</code>, returning a new stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.from_err">Read more</a></p>
+</div><h4 id='method.take' class="method"><span id='take.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take' class='fnname'>take</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/take/struct.Take.html" title="struct futures::stream::take::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#796-800' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream of at most <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.take">Read more</a></p>
+</div><h4 id='method.skip' class="method"><span id='skip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip' class='fnname'>skip</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/skip/struct.Skip.html" title="struct futures::stream::skip::Skip">Skip</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#811-815' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which skips <code>amt</code> items of the underlying stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.skip">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/fuse/struct.Fuse.html" title="struct futures::stream::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#832-836' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a stream such that <code>poll</code> will never again be called once it has finished. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.fuse">Read more</a></p>
+</div><h4 id='method.by_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#857-861' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Borrows a stream, rather than consuming it. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/catch_unwind/struct.CatchUnwind.html" title="struct futures::stream::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#897-901' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.buffered' class="method"><span id='buffered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered' class='fnname'>buffered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffered/struct.Buffered.html" title="struct futures::stream::buffered::Buffered">Buffered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#917-922' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffered">Read more</a></p>
+</div><h4 id='method.buffer_unordered' class="method"><span id='buffer_unordered.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered' class='fnname'>buffer_unordered</a>(self, amt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/buffer_unordered/struct.BufferUnordered.html" title="struct futures::stream::buffer_unordered::BufferUnordered">BufferUnordered</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#938-943' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for creating a buffered list of pending futures (unordered). <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.buffer_unordered">Read more</a></p>
+</div><h4 id='method.merge' class="method"><span id='merge.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge' class='fnname'>merge</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/merge/struct.Merge.html" title="struct futures::stream::merge::Merge">Merge</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#952-957' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab deprecated'>Deprecated<p>: functionality provided by <code>select</code> now</p>
+</div></div><div class='docblock'><p>An adapter for merging the output of two streams. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.merge">Read more</a></p>
+</div><h4 id='method.zip' class="method"><span id='zip.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip' class='fnname'>zip</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/zip/struct.Zip.html" title="struct futures::stream::zip::Zip">Zip</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#964-969' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adapter for zipping two streams together. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.zip">Read more</a></p>
+</div><h4 id='method.chain' class="method"><span id='chain.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain' class='fnname'>chain</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chain/struct.Chain.html" title="struct futures::stream::chain::Chain">Chain</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#990-995' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Adapter for chaining two stream. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chain">Read more</a></p>
+</div><h4 id='method.peekable' class="method"><span id='peekable.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable' class='fnname'>peekable</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/peek/struct.Peekable.html" title="struct futures::stream::peek::Peekable">Peekable</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1000-1004' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new stream which exposes a <code>peek</code> method. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.peekable">Read more</a></p>
+</div><h4 id='method.chunks' class="method"><span id='chunks.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks' class='fnname'>chunks</a>(self, capacity: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/chunks/struct.Chunks.html" title="struct futures::stream::chunks::Chunks">Chunks</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1027-1031' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>An adaptor for chunking up items of the stream inside a vector. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.chunks">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select' class='fnname'>select</a><S>(self, other: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/select/struct.Select.html" title="struct futures::stream::select::Select">Select</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1044-1049' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a stream that selects the next element from either this stream or the provided one, whichever is ready first. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.select">Read more</a></p>
+</div><h4 id='method.forward' class="method"><span id='forward.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward' class='fnname'>forward</a><S>(self, sink: S) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/forward/struct.Forward.html" title="struct futures::stream::forward::Forward">Forward</a><Self, S> <span class="where fmt-newline">where<br> S: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a><SinkItem = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>>,<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<S as <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html#associatedtype.SinkError" title="type futures::sink::Sink::SinkError">SinkError</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1065-1071' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>A future that completes after the given stream has been fully processed into the sink, including flushing. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.forward">Read more</a></p>
+</div><h4 id='method.split' class="method"><span id='split.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitSink.html" title="struct futures::stream::split::SplitSink">SplitSink</a><Self>, <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/split/struct.SplitStream.html" title="struct futures::stream::split::SplitStream">SplitStream</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/futures/0.1/futures/sink/trait.Sink.html" title="trait futures::sink::Sink">Sink</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1083-1087' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Splits this <code>Stream + Sink</code> object into separate <code>Stream</code> and <code>Sink</code> objects. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.split">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect/struct.Inspect.html" title="struct futures::stream::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Item" title="type futures::stream::Stream::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1094-1099' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with each item of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect">Read more</a></p>
+</div><h4 id='method.inspect_err' class="method"><span id='inspect_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err' class='fnname'>inspect_err</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/stream/inspect_err/struct.InspectErr.html" title="struct futures::stream::inspect_err::InspectErr">InspectErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/stream/mod.rs.html#1106-1111' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the error of this stream, afterwards passing it on. <a href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#method.inspect_err">Read more</a></p>
+</div></div><h3 id='impl-Drop' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html" title="trait core::ops::drop::Drop">Drop</a> for <a class="struct" href="../../tokio_core/reactor/struct.Interval.html" title="struct tokio_core::reactor::Interval">Interval</a></code><a href='#impl-Drop' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#94-98' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.drop' class="method"><span id='drop.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&mut self)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/interval.rs.html#95-97' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes the destructor for this type. <a href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.PollEvented.html b/tokio_core/reactor/struct.PollEvented.html
new file mode 100644
index 0000000..a2e7e35
--- /dev/null
+++ b/tokio_core/reactor/struct.PollEvented.html
@@ -0,0 +1,372 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `PollEvented` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, PollEvented">
+
+ <title>tokio_core::reactor::PollEvented - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct PollEvented</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.deregister">deregister</a><a href="#method.poll_read">poll_read</a><a href="#method.poll_write">poll_write</a><a href="#method.poll_ready">poll_ready</a><a href="#method.need_read">need_read</a><a href="#method.need_write">need_write</a><a href="#method.remote">remote</a><a href="#method.get_ref">get_ref</a><a href="#method.get_mut">get_mut</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-Read">Read</a><a href="#impl-Write">Write</a><a href="#impl-AsyncRead">AsyncRead</a><a href="#impl-AsyncWrite">AsyncWrite</a><a href="#impl-Drop">Drop</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'PollEvented', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>PollEvented</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#66-71' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct PollEvented<E> { /* fields omitted */ }</pre><div class='docblock'><p>A concrete implementation of a stream of readiness notifications for I/O
+objects that originates from an event loop.</p>
+<p>Created by the <code>PollEvented::new</code> method, each <code>PollEvented</code> is
+associated with a specific event loop and source of events that will be
+registered with an event loop.</p>
+<p>An instance of <code>PollEvented</code> is essentially the bridge between the <code>mio</code>
+world and the <code>tokio-core</code> world, providing abstractions to receive
+notifications about changes to an object's <code>mio::Ready</code> state.</p>
+<p>Each readiness stream has a number of methods to test whether the underlying
+object is readable or writable. Once the methods return that an object is
+readable/writable, then it will continue to do so until the <code>need_read</code> or
+<code>need_write</code> methods are called.</p>
+<p>That is, this object is typically wrapped in another form of I/O object.
+It's the responsibility of the wrapper to inform the readiness stream when a
+"would block" I/O event is seen. The readiness stream will then take care of
+any scheduling necessary to get notified when the event is ready again.</p>
+<p>You can find more information about creating a custom I/O object <a href="https://tokio.rs/docs/going-deeper-tokio/core-low-level/#custom-io">online</a>.</p>
+<h2 id="readiness-to-readwrite" class="section-header"><a href="#readiness-to-readwrite">Readiness to read/write</a></h2>
+<p>A <code>PollEvented</code> allows listening and waiting for an arbitrary <code>mio::Ready</code>
+instance, including the platform-specific contents of <code>mio::Ready</code>. At most
+two future tasks, however, can be waiting on a <code>PollEvented</code>. The
+<code>need_read</code> and <code>need_write</code> methods can block two separate tasks, one on
+reading and one on writing. Not all I/O events correspond to read/write,
+however!</p>
+<p>To account for this a <code>PollEvented</code> gets a little interesting when working
+with an arbitrary instance of <code>mio::Ready</code> that may not map precisely to
+"write" and "read" tasks. Currently it is defined that instances of
+<code>mio::Ready</code> that do <em>not</em> return true from <code>is_writable</code> are all notified
+through <code>need_read</code>, or the read task.</p>
+<p>In other words, <code>poll_ready</code> with the <code>mio::UnixReady::hup</code> event will block
+the read task of this <code>PollEvented</code> if the <code>hup</code> event isn't available.
+Essentially a good rule of thumb is that if you're using the <code>poll_ready</code>
+method you want to also use <code>need_read</code> to signal blocking and you should
+otherwise probably avoid using two tasks on the same <code>PollEvented</code>.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://docs.rs/mio/0.6.13/mio/event_imp/trait.Evented.html" title="trait mio::event_imp::Evented">Evented</a>> <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#81-116' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><code>pub fn <a href='#method.new' class='fnname'>new</a>(io: E, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#87-94' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new readiness stream associated with the provided
+<code>loop_handle</code> and for the given <code>source</code>.</p>
+<p>This method returns a future which will resolve to the readiness stream
+when it's ready.</p>
+</div><h4 id='method.deregister' class="method"><span id='deregister.v' class='invisible'><code>pub fn <a href='#method.deregister' class='fnname'>deregister</a>(self, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#108-115' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Deregisters this source of events from the reactor core specified.</p>
+<p>This method can optionally be called to unregister the underlying I/O
+object with the event loop that the <code>handle</code> provided points to.
+Typically this method is not required as this automatically happens when
+<code>E</code> is dropped, but for some use cases the <code>E</code> object doesn't represent
+an owned reference, so dropping it won't automatically unregister with
+the event loop.</p>
+<p>This consumes <code>self</code> as it will no longer provide events after the
+method is called, and will likely return an error if this <code>PollEvented</code>
+was created on a separate event loop from the <code>handle</code> specified.</p>
+</div></div><h3 id='impl-1' class='impl'><span class='in-band'><code>impl<E> <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#118-272' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.poll_read' class="method"><span id='poll_read.v' class='invisible'><code>pub fn <a href='#method.poll_read' class='fnname'>poll_read</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#133-136' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Tests to see if this source is ready to be read from or not.</p>
+<p>If this stream is not ready for a read then <code>NotReady</code> will be returned
+and the current task will be scheduled to receive a notification when
+the stream is readable again. In other words, this method is only safe
+to call from within the context of a future's task, typically done in a
+<code>Future::poll</code> method.</p>
+<p>This is mostly equivalent to <code>self.poll_ready(Ready::readable())</code>.</p>
+<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
+<p>This function will panic if called outside the context of a future's
+task.</p>
+</div><h4 id='method.poll_write' class="method"><span id='poll_write.v' class='invisible'><code>pub fn <a href='#method.poll_write' class='fnname'>poll_write</a>(&self) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#152-155' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Tests to see if this source is ready to be written to or not.</p>
+<p>If this stream is not ready for a write then <code>NotReady</code> will be returned
+and the current task will be scheduled to receive a notification when
+the stream is writable again. In other words, this method is only safe
+to call from within the context of a future's task, typically done in a
+<code>Future::poll</code> method.</p>
+<p>This is mostly equivalent to <code>self.poll_ready(Ready::writable())</code>.</p>
+<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
+<p>This function will panic if called outside the context of a future's
+task.</p>
+</div><h4 id='method.poll_ready' class="method"><span id='poll_ready.v' class='invisible'><code>pub fn <a href='#method.poll_ready' class='fnname'>poll_ready</a>(&self, mask: <a class="struct" href="https://docs.rs/mio/0.6.13/mio/event_imp/struct.Ready.html" title="struct mio::event_imp::Ready">Ready</a>) -> <a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="struct" href="https://docs.rs/mio/0.6.13/mio/event_imp/struct.Ready.html" title="struct mio::event_imp::Ready">Ready</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#180-198' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Test to see whether this source fulfills any condition listed in <code>mask</code>
+provided.</p>
+<p>The <code>mask</code> given here is a mio <code>Ready</code> set of possible events. This can
+contain any events like read/write but also platform-specific events
+such as hup and error. The <code>mask</code> indicates events that are interested
+in being ready.</p>
+<p>If any event in <code>mask</code> is ready then it is returned through
+<code>Async::Ready</code>. The <code>Ready</code> set returned is guaranteed to not be empty
+and contains all events that are currently ready in the <code>mask</code> provided.</p>
+<p>If no events are ready in the <code>mask</code> provided then the current task is
+scheduled to receive a notification when any of them become ready. If
+the <code>writable</code> event is contained within <code>mask</code> then this
+<code>PollEvented</code>'s <code>write</code> task will be blocked and otherwise the <code>read</code>
+task will be blocked. This is generally only relevant if you're working
+with this <code>PollEvented</code> object on multiple tasks.</p>
+<h1 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h1>
+<p>This function will panic if called outside the context of a future's
+task.</p>
+</div><h4 id='method.need_read' class="method"><span id='need_read.v' class='invisible'><code>pub fn <a href='#method.need_read' class='fnname'>need_read</a>(&self)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#223-227' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Indicates to this source of events that the corresponding I/O object is
+no longer readable, but it needs to be.</p>
+<p>This function, like <code>poll_read</code>, is only safe to call from the context
+of a future's task (typically in a <code>Future::poll</code> implementation). It
+informs this readiness stream that the underlying object is no longer
+readable, typically because a "would block" error was seen.</p>
+<p><em>All</em> readiness bits associated with this stream except the writable bit
+will be reset when this method is called. The current task is then
+scheduled to receive a notification whenever anything changes other than
+the writable bit. Note that this typically just means the readable bit
+is used here, but if you're using a custom I/O object for events like
+hup/error this may also be relevant.</p>
+<p>Note that it is also only valid to call this method if <code>poll_read</code>
+previously indicated that the object is readable. That is, this function
+must always be paired with calls to <code>poll_read</code> previously.</p>
+<h1 id="panics-3" class="section-header"><a href="#panics-3">Panics</a></h1>
+<p>This function will panic if called outside the context of a future's
+task.</p>
+</div><h4 id='method.need_write' class="method"><span id='need_write.v' class='invisible'><code>pub fn <a href='#method.need_write' class='fnname'>need_write</a>(&self)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#249-253' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Indicates to this source of events that the corresponding I/O object is
+no longer writable, but it needs to be.</p>
+<p>This function, like <code>poll_write</code>, is only safe to call from the context
+of a future's task (typically in a <code>Future::poll</code> implementation). It
+informs this readiness stream that the underlying object is no longer
+writable, typically because a "would block" error was seen.</p>
+<p>The flag indicating that this stream is writable is unset and the
+current task is scheduled to receive a notification when the stream is
+then again writable.</p>
+<p>Note that it is also only valid to call this method if <code>poll_write</code>
+previously indicated that the object is writable. That is, this function
+must always be paired with calls to <code>poll_write</code> previously.</p>
+<h1 id="panics-4" class="section-header"><a href="#panics-4">Panics</a></h1>
+<p>This function will panic if called outside the context of a future's
+task.</p>
+</div><h4 id='method.remote' class="method"><span id='remote.v' class='invisible'><code>pub fn <a href='#method.remote' class='fnname'>remote</a>(&self) -> &<a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#257-259' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a reference to the event loop handle that this readiness stream
+is associated with.</p>
+</div><h4 id='method.get_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='get_ref.v' class='invisible'><code>pub fn <a href='#method.get_ref' class='fnname'>get_ref</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>E</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#263-265' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a shared reference to the underlying I/O object this readiness
+stream is wrapping.</p>
+</div><h4 id='method.get_mut' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='get_mut.v' class='invisible'><code>pub fn <a href='#method.get_mut' class='fnname'>get_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>E</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#269-271' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a mutable reference to the underlying I/O object this readiness
+stream is wrapping.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://docs.rs/mio/0.6.13/mio/event_imp/trait.Evented.html" title="trait mio::event_imp::Evented">Evented</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#73-79' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#74-78' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div><h3 id='impl-Read' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-Read' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#274-285' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.read' class="method"><span id='read.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read' class='fnname'>read</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#275-284' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified buffer, returning how many bytes were read. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read">Read more</a></p>
+</div><h4 id='method.initializer' class="method"><span id='initializer.v' class='invisible'><code>unsafe fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer' class='fnname'>initializer</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Initializer.html" title="struct std::io::Initializer">Initializer</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#553-555' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>read_initializer</code>)</div></div><div class='docblock'><p>Determines if this <code>Read</code>er can work with buffers of uninitialized memory. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer">Read more</a></p>
+</div><h4 id='method.read_to_end' class="method"><span id='read_to_end.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end' class='fnname'>read_to_end</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#600-602' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, placing them into <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end">Read more</a></p>
+</div><h4 id='method.read_to_string' class="method"><span id='read_to_string.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string' class='fnname'>read_to_string</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#638-649' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, appending them to <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string">Read more</a></p>
+</div><h4 id='method.read_exact' class="method"><span id='read_exact.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact' class='fnname'>read_exact</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.6.0'>1.6.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#701-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read the exact number of bytes required to fill <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact">Read more</a></p>
+</div><h4 id='method.by_ref' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#753' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Read</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.bytes' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>>;</span></code></div></div><span id='bytes.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes' class='fnname'>bytes</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#790-792' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over its bytes. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes">Read more</a></p>
+</div><h4 id='method.chars' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/io/enum.CharsError.html" title="enum std::io::CharsError">CharsError</a>>;</span></code></div></div><span id='chars.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars' class='fnname'>chars</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#834-836' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>io</code>)</summary><p>the semantics of a partial read/write of where errors happen is currently unclear and may change</p>
+</details></div></div><div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over [<code>char</code>]s. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars">Read more</a></p>
+</div><h4 id='method.chain' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></h3><code class="content"><span class="where fmt-newline">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>,<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='chain.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain' class='fnname'>chain</a><R>(self, next: R) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><Self, R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#869-871' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will chain this stream with another. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain">Read more</a></p>
+</div><h4 id='method.take' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></h3><code class="content"><span class="where fmt-newline">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='take.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take' class='fnname'>take</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#905-907' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will read at most <code>limit</code> bytes from it. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take">Read more</a></p>
+</div></div><h3 id='impl-Write' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-Write' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#287-309' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.write' class="method"><span id='write.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write' class='fnname'>write</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#288-297' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a buffer into this object, returning how many bytes were written. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write">Read more</a></p>
+</div><h4 id='method.flush' class="method"><span id='flush.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush' class='fnname'>flush</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#299-308' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flush this output stream, ensuring that all intermediately buffered contents reach their destination. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush">Read more</a></p>
+</div><h4 id='method.write_all' class="method"><span id='write_all.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all' class='fnname'>write_all</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1097-1108' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempts to write an entire buffer into this write. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all">Read more</a></p>
+</div><h4 id='method.write_fmt' class="method"><span id='write_fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt' class='fnname'>write_fmt</a>(&mut self, fmt: <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Arguments.html" title="struct core::fmt::Arguments">Arguments</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1149-1181' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Writes a formatted string into this writer, returning any error encountered. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt">Read more</a></p>
+</div><h4 id='method.by_ref-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1205' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Write</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref">Read more</a></p>
+</div></div><h3 id='impl-AsyncRead' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html" title="trait tokio_io::AsyncRead">AsyncRead</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-AsyncRead' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#311-312' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.prepare_uninitialized_buffer' class="method"><span id='prepare_uninitialized_buffer.v' class='invisible'><code>unsafe fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer' class='fnname'>prepare_uninitialized_buffer</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#123-129' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Prepares an uninitialized buffer to be safe to pass to <code>read</code>. Returns <code>true</code> if the supplied buffer was zeroed out. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer">Read more</a></p>
+</div><h4 id='method.read_buf' class="method"><span id='read_buf.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf' class='fnname'>read_buf</a><B>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf_mut/trait.BufMut.html" title="trait bytes::buf::buf_mut::BufMut">BufMut</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#137-156' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified <code>Buf</code>, returning how many bytes were read. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf">Read more</a></p>
+</div><h4 id='method.framed' class="method"><span id='framed.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed' class='fnname'>framed</a><T>(self, codec: T) -> <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/framed/struct.Framed.html" title="struct tokio_io::framed::Framed">Framed</a><Self, T> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>,<br> T: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_read/trait.Decoder.html" title="trait tokio_io::framed_read::Decoder">Decoder</a> + <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_write/trait.Encoder.html" title="trait tokio_io::framed_write::Encoder">Encoder</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#175-179' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Provides a <code>Stream</code> and <code>Sink</code> interface for reading and writing to this <code>Io</code> object, using <code>Decode</code> and <code>Encode</code> to read and write the raw data. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed">Read more</a></p>
+</div><h4 id='method.split' class="method"><span id='split.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.ReadHalf.html" title="struct tokio_io::split::ReadHalf">ReadHalf</a><Self>, <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.WriteHalf.html" title="struct tokio_io::split::WriteHalf">WriteHalf</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#185-189' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Helper method for splitting this read/write object into two halves. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split">Read more</a></p>
+</div></div><h3 id='impl-AsyncWrite' class='impl'><span class='in-band'><code>impl<E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a>> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-AsyncWrite' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#314-318' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.shutdown' class="method"><span id='shutdown.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown' class='fnname'>shutdown</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#315-317' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown">Read more</a></p>
+</div><h4 id='method.write_buf' class="method"><span id='write_buf.v' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf' class='fnname'>write_buf</a><B>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf/trait.Buf.html" title="trait bytes::buf::buf::Buf">Buf</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#296-306' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a <code>Buf</code> into this value, returning how many bytes were written. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf">Read more</a></p>
+</div></div><h3 id='impl-Read-1' class='impl'><span class='in-band'><code>impl<'a, E> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for &'a <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a </a>E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code><a href='#impl-Read-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#331-344' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.read-1' class="method"><span id='read.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read' class='fnname'>read</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#334-343' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified buffer, returning how many bytes were read. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read">Read more</a></p>
+</div><h4 id='method.initializer-1' class="method"><span id='initializer.v-1' class='invisible'><code>unsafe fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer' class='fnname'>initializer</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Initializer.html" title="struct std::io::Initializer">Initializer</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#553-555' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>read_initializer</code>)</div></div><div class='docblock'><p>Determines if this <code>Read</code>er can work with buffers of uninitialized memory. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer">Read more</a></p>
+</div><h4 id='method.read_to_end-1' class="method"><span id='read_to_end.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end' class='fnname'>read_to_end</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#600-602' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, placing them into <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end">Read more</a></p>
+</div><h4 id='method.read_to_string-1' class="method"><span id='read_to_string.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string' class='fnname'>read_to_string</a>(&mut self, buf: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#638-649' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read all bytes until EOF in this source, appending them to <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_string">Read more</a></p>
+</div><h4 id='method.read_exact-1' class="method"><span id='read_exact.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact' class='fnname'>read_exact</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.6.0'>1.6.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#701-716' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Read the exact number of bytes required to fill <code>buf</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_exact">Read more</a></p>
+</div><h4 id='method.by_ref-2' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-2' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#753' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Read</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.by_ref">Read more</a></p>
+</div><h4 id='method.bytes-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>>;</span></code></div></div><span id='bytes.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes' class='fnname'>bytes</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Bytes.html" title="struct std::io::Bytes">Bytes</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#790-792' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over its bytes. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.bytes">Read more</a></p>
+</div><h4 id='method.chars-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R></h3><code class="content"><span class="where fmt-newline">impl<R> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>, <a class="enum" href="https://doc.rust-lang.org/nightly/std/io/enum.CharsError.html" title="enum std::io::CharsError">CharsError</a>>;</span></code></div></div><span id='chars.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars' class='fnname'>chars</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chars.html" title="struct std::io::Chars">Chars</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#834-836' title='goto source code'>[src]</a></span></h4>
+<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>io</code>)</summary><p>the semantics of a partial read/write of where errors happen is currently unclear and may change</p>
+</details></div></div><div class='docblock'><p>Transforms this <code>Read</code> instance to an [<code>Iterator</code>] over [<code>char</code>]s. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chars">Read more</a></p>
+</div><h4 id='method.chain-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U></h3><code class="content"><span class="where fmt-newline">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><T, U> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>,<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='chain.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain' class='fnname'>chain</a><R>(self, next: R) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Chain.html" title="struct std::io::Chain">Chain</a><Self, R> <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#869-871' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will chain this stream with another. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.chain">Read more</a></p>
+</div><h4 id='method.take-1' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T></h3><code class="content"><span class="where fmt-newline">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></span></code></div></div><span id='take.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take' class='fnname'>take</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/struct.Take.html" title="struct std::io::Take">Take</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#905-907' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates an adaptor which will read at most <code>limit</code> bytes from it. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.take">Read more</a></p>
+</div></div><h3 id='impl-Write-1' class='impl'><span class='in-band'><code>impl<'a, E> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for &'a <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a </a>E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a>, </span></code><a href='#impl-Write-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#346-370' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.write-1' class="method"><span id='write.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write' class='fnname'>write</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#349-358' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a buffer into this object, returning how many bytes were written. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write">Read more</a></p>
+</div><h4 id='method.flush-1' class="method"><span id='flush.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush' class='fnname'>flush</a>(&mut self) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#360-369' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flush this output stream, ensuring that all intermediately buffered contents reach their destination. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.flush">Read more</a></p>
+</div><h4 id='method.write_all-1' class="method"><span id='write_all.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all' class='fnname'>write_all</a>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1097-1108' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempts to write an entire buffer into this write. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_all">Read more</a></p>
+</div><h4 id='method.write_fmt-1' class="method"><span id='write_fmt.v-1' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt' class='fnname'>write_fmt</a>(&mut self, fmt: <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Arguments.html" title="struct core::fmt::Arguments">Arguments</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1149-1181' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Writes a formatted string into this writer, returning any error encountered. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.write_fmt">Read more</a></p>
+</div><h4 id='method.by_ref-3' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R</h3><code class="content"><span class="where fmt-newline">impl<'a, R> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>R <span class="where fmt-newline">where<br> R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, W> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>W <span class="where fmt-newline">where<br> W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline">impl<'a, I> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::iterator::Iterator::Item">Item</a>;</span></code></div></div><span id='by_ref.v-3' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/std/io/mod.rs.html#1205' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a "by reference" adaptor for this instance of <code>Write</code>. <a href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html#method.by_ref">Read more</a></p>
+</div></div><h3 id='impl-AsyncRead-1' class='impl'><span class='in-band'><code>impl<'a, E> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html" title="trait tokio_io::AsyncRead">AsyncRead</a> for &'a <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a </a>E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a>, </span></code><a href='#impl-AsyncRead-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#372-375' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.prepare_uninitialized_buffer-1' class="method"><span id='prepare_uninitialized_buffer.v-1' class='invisible'><code>unsafe fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer' class='fnname'>prepare_uninitialized_buffer</a>(&self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#123-129' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Prepares an uninitialized buffer to be safe to pass to <code>read</code>. Returns <code>true</code> if the supplied buffer was zeroed out. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.prepare_uninitialized_buffer">Read more</a></p>
+</div><h4 id='method.read_buf-1' class="method"><span id='read_buf.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf' class='fnname'>read_buf</a><B>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf_mut/trait.BufMut.html" title="trait bytes::buf::buf_mut::BufMut">BufMut</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#137-156' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Pull some bytes from this source into the specified <code>Buf</code>, returning how many bytes were read. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.read_buf">Read more</a></p>
+</div><h4 id='method.framed-1' class="method"><span id='framed.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed' class='fnname'>framed</a><T>(self, codec: T) -> <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/framed/struct.Framed.html" title="struct tokio_io::framed::Framed">Framed</a><Self, T> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>,<br> T: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_read/trait.Decoder.html" title="trait tokio_io::framed_read::Decoder">Decoder</a> + <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/framed_write/trait.Encoder.html" title="trait tokio_io::framed_write::Encoder">Encoder</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#175-179' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Provides a <code>Stream</code> and <code>Sink</code> interface for reading and writing to this <code>Io</code> object, using <code>Decode</code> and <code>Encode</code> to read and write the raw data. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.framed">Read more</a></p>
+</div><h4 id='method.split-1' class="method"><span id='split.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split' class='fnname'>split</a>(self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.ReadHalf.html" title="struct tokio_io::split::ReadHalf">ReadHalf</a><Self>, <a class="struct" href="https://docs.rs/tokio-io/0.1/tokio_io/split/struct.WriteHalf.html" title="struct tokio_io::split::WriteHalf">WriteHalf</a><Self><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#185-189' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Helper method for splitting this read/write object into two halves. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html#method.split">Read more</a></p>
+</div></div><h3 id='impl-AsyncWrite-1' class='impl'><span class='in-band'><code>impl<'a, E> <a class="trait" href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html" title="trait tokio_io::AsyncWrite">AsyncWrite</a> for &'a <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E> <span class="where fmt-newline">where<br> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a </a>E: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a>, </span></code><a href='#impl-AsyncWrite-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#377-383' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.shutdown-1' class="method"><span id='shutdown.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown' class='fnname'>shutdown</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#380-382' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#tymethod.shutdown">Read more</a></p>
+</div><h4 id='method.write_buf-1' class="method"><span id='write_buf.v-1' class='invisible'><code>fn <a href='https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf' class='fnname'>write_buf</a><B>(&mut self, buf: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>B) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="enum" href="https://docs.rs/futures/0.1/futures/poll/enum.Async.html" title="enum futures::poll::Async">Async</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/bytes/0.4.6/bytes/buf/buf/trait.Buf.html" title="trait bytes::buf::buf::Buf">Buf</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/tokio-io/0.1/src/tokio_io/lib.rs.html#296-306' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Write a <code>Buf</code> into this value, returning how many bytes were written. <a href="https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncWrite.html#method.write_buf">Read more</a></p>
+</div></div><h3 id='impl-Drop' class='impl'><span class='in-band'><code>impl<E> <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html" title="trait core::ops::drop::Drop">Drop</a> for <a class="struct" href="../../tokio_core/reactor/struct.PollEvented.html" title="struct tokio_core::reactor::PollEvented">PollEvented</a><E></code><a href='#impl-Drop' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#405-409' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.drop' class="method"><span id='drop.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&mut self)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/poll_evented.rs.html#406-408' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes the destructor for this type. <a href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.Remote.html b/tokio_core/reactor/struct.Remote.html
new file mode 100644
index 0000000..24bb778
--- /dev/null
+++ b/tokio_core/reactor/struct.Remote.html
@@ -0,0 +1,175 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Remote` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Remote">
+
+ <title>tokio_core::reactor::Remote - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Remote</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.spawn">spawn</a><a href="#method.id">id</a><a href="#method.handle">handle</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Executor%3CF%3E">Executor<F></a><a href="#impl-Debug">Debug</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'Remote', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>Remote</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#97-100' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'>pub struct Remote { /* fields omitted */ }</pre><div class='docblock'><p>Handle to an event loop, used to construct I/O objects, send messages, and
+otherwise interact indirectly with the event loop itself.</p>
+<p>Handles can be cloned, and when cloned they will still refer to the
+same underlying event loop.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#577-687' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.spawn' class="method"><span id='spawn.v' class='invisible'><code>pub fn <a href='#method.spawn' class='fnname'>spawn</a><F, R>(&self, f: F) <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(&<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> R + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + 'static,<br> R: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>,<br> R::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>: 'static, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#645-654' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a new future into the event loop this remote is associated with.</p>
+<p>This function takes a closure which is executed within the context of
+the I/O loop itself. The future returned by the closure will be
+scheduled on the event loop and run to completion.</p>
+<p>Note that while the closure, <code>F</code>, requires the <code>Send</code> bound as it might
+cross threads, the future <code>R</code> does not.</p>
+<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
+<p>This method will <strong>not</strong> catch panics from polling the future <code>f</code>. If
+the future panics then it's the responsibility of the caller to catch
+that panic and handle it as appropriate.</p>
+</div><h4 id='method.id' class="method"><span id='id.v' class='invisible'><code>pub fn <a href='#method.id' class='fnname'>id</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.CoreId.html" title="struct tokio_core::reactor::CoreId">CoreId</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#657-659' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Return the ID of the represented Core</p>
+</div><h4 id='method.handle' class="method"><span id='handle.v' class='invisible'><code>pub fn <a href='#method.handle' class='fnname'>handle</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#673-686' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Attempts to "promote" this remote to a handle, if possible.</p>
+<p>This function is intended for structures which typically work through a
+<code>Remote</code> but want to optimize runtime when the remote doesn't actually
+leave the thread of the original reactor. This will attempt to return a
+handle if the <code>Remote</code> is on the same thread as the event loop and the
+event loop is running.</p>
+<p>If this <code>Remote</code> has moved to a different thread or if the event loop is
+running, then <code>None</code> may be returned. If you need to guarantee access to
+a <code>Handle</code>, then you can call this function and fall back to using
+<code>spawn</code> above if it returns <code>None</code>.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Clone' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code><a href='#impl-Clone' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#96' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#96' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
+</div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#112-114' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
+</div></div><h3 id='impl-Executor%3CF%3E' class='impl'><span class='in-band'><code>impl<F> <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html" title="trait futures::future::Executor">Executor</a><F> for <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, Error = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + 'static, </span></code><a href='#impl-Executor%3CF%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#689-696' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.execute' class="method"><span id='execute.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute' class='fnname'>execute</a>(&self, future: F) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://docs.rs/futures/0.1/futures/future/struct.ExecuteError.html" title="struct futures::future::ExecuteError">ExecuteError</a><F>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#692-695' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Spawns a future to run on this <code>Executor</code>, typically in the "background". <a href="https://docs.rs/futures/0.1/futures/future/trait.Executor.html#tymethod.execute">Read more</a></p>
+</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.Remote.html" title="struct tokio_core::reactor::Remote">Remote</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#698-704' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/mod.rs.html#699-703' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/struct.Timeout.html b/tokio_core/reactor/struct.Timeout.html
new file mode 100644
index 0000000..635965e
--- /dev/null
+++ b/tokio_core/reactor/struct.Timeout.html
@@ -0,0 +1,217 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="API documentation for the Rust `Timeout` struct in crate `tokio_core`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang, Timeout">
+
+ <title>tokio_core::reactor::Timeout - Rust</title>
+
+ <link rel="stylesheet" type="text/css" href="../../normalize.css">
+ <link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle">
+
+ <link rel="stylesheet" type="text/css" href="../../dark.css">
+ <link rel="stylesheet" type="text/css" href="../../main.css" id="themeStyle">
+ <script src="../../storage.js"></script>
+
+
+
+
+</head>
+<body class="rustdoc struct">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <nav class="sidebar">
+ <div class="sidebar-menu">☰</div>
+
+ <p class='location'>Struct Timeout</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.new_at">new_at</a><a href="#method.reset">reset</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-Future">Future</a><a href="#impl-Drop">Drop</a></div></div><p class='location'><a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a></p><script>window.sidebarCurrent = {name: 'Timeout', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
+ </nav>
+
+ <div class="theme-picker">
+ <button id="theme-picker" aria-label="Pick another theme!">
+ <img src="../../brush.svg" width="18" alt="Pick another theme!">
+ </button>
+ <div id="theme-choices"></div>
+ </div>
+ <script src="../../theme.js"></script>
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content">
+<h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>tokio_core</a>::<wbr><a href='index.html'>reactor</a>::<wbr><a class="struct" href=''>Timeout</a></span><span class='out-of-band'><span id='render-detail'>
+ <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#23-27' title='goto source code'>[src]</a></span></h1>
+<pre class='rust struct'><div class="docblock attributes">#[must_use = "futures do nothing unless polled"]
+</div>pub struct Timeout { /* fields omitted */ }</pre><div class='docblock'><p>A future representing the notification that a timeout has occurred.</p>
+<p>Timeouts are created through the <code>Timeout::new</code> or
+<code>Timeout::new_at</code> methods indicating when a timeout should fire at.
+Note that timeouts are not intended for high resolution timers, but rather
+they will likely fire some granularity after the exact instant that they're
+otherwise indicated to fire at.</p>
+</div>
+ <h2 id='methods' class='small-section-header'>
+ Methods<a href='#methods' class='anchor'></a>
+ </h2>
+ <h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#29-90' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><code>pub fn <a href='#method.new' class='fnname'>new</a>(dur: <a class="struct" href="https://doc.rust-lang.org/nightly/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#35-37' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new timeout which will fire at <code>dur</code> time into the future.</p>
+<p>This function will return a Result with the actual timeout object or an
+error. The timeout object itself is then a future which will be
+set to fire at the specified point in the future.</p>
+</div><h4 id='method.new_at' class="method"><span id='new_at.v' class='invisible'><code>pub fn <a href='#method.new_at' class='fnname'>new_at</a>(at: <a class="struct" href="https://doc.rust-lang.org/nightly/std/time/struct.Instant.html" title="struct std::time::Instant">Instant</a>, handle: &<a class="struct" href="../../tokio_core/reactor/struct.Handle.html" title="struct tokio_core::reactor::Handle">Handle</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a><<a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#44-50' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Creates a new timeout which will fire at the time specified by <code>at</code>.</p>
+<p>This function will return a Result with the actual timeout object or an
+error. The timeout object itself is then a future which will be
+set to fire at the specified point in the future.</p>
+</div><h4 id='method.reset' class="method"><span id='reset.v' class='invisible'><code>pub fn <a href='#method.reset' class='fnname'>reset</a>(&mut self, at: <a class="struct" href="https://doc.rust-lang.org/nightly/std/time/struct.Instant.html" title="struct std::time::Instant">Instant</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#65-68' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Resets this timeout to an new timeout which will fire at the time
+specified by <code>at</code>.</p>
+<p>This method is usable even of this instance of <code>Timeout</code> has "already
+fired". That is, if this future has resolved, calling this method means
+that the future will still re-resolve at the specified instant.</p>
+<p>If <code>at</code> is in the past then this future will immediately be resolved
+(when <code>poll</code> is called).</p>
+<p>Note that if any task is currently blocked on this future then that task
+will be dropped. It is required to call <code>poll</code> again after this method
+has been called to ensure that a task is blocked on this future.</p>
+</div></div>
+ <h2 id='implementations' class='small-section-header'>
+ Trait Implementations<a href='#implementations' class='anchor'></a>
+ </h2>
+ <h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#22' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, __arg_0: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#22' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
+</div></div><h3 id='impl-Future' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html" title="trait futures::future::Future">Future</a> for <a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a></code><a href='#impl-Future' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#92-100' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='associatedtype.Item' class="type"><span id='Item.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a></code></span></h4>
+<div class='docblock'><p>The type of value that this future will resolved with if it is successful. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item">Read more</a></p>
+</div><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></code></span></h4>
+<div class='docblock'><p>The type of error that this future will resolve with if it fails in a normal fashion. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error">Read more</a></p>
+</div><h4 id='method.poll' class="method"><span id='poll.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll' class='fnname'>poll</a>(&mut self) -> <a class="type" href="https://docs.rs/futures/0.1/futures/poll/type.Poll.html" title="type futures::poll::Poll">Poll</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#96-99' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Query this future to see if its value has become available, registering interest if it is not. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll">Read more</a></p>
+</div><h4 id='method.wait' class="method"><span id='wait.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait' class='fnname'>wait</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#296-300' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Block the current thread until this future is resolved. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.wait">Read more</a></p>
+</div><h4 id='method.map' class="method"><span id='map.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map' class='fnname'>map</a><F, U>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map/struct.Map.html" title="struct futures::future::map::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> U, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#370-375' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's result to a different type, returning a new future of the resulting type. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map">Read more</a></p>
+</div><h4 id='method.map_err' class="method"><span id='map_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err' class='fnname'>map_err</a><F, E>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/map_err/struct.MapErr.html" title="struct futures::future::map_err::MapErr">MapErr</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> E, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#410-415' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to a different error, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.map_err">Read more</a></p>
+</div><h4 id='method.from_err' class="method"><span id='from_err.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err' class='fnname'>from_err</a><E>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/from_err/struct.FromErr.html" title="struct futures::future::from_err::FromErr">FromErr</a><Self, E> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#440-444' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Map this future's error to any error implementing <code>From</code> for this future's <code>Error</code>, returning a new future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.from_err">Read more</a></p>
+</div><h4 id='method.then' class="method"><span id='then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then' class='fnname'>then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/then/struct.Then.html" title="struct futures::future::then::Then">Then</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#484-490' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Chain on a computation for when a future finished, passing the result of the future to the provided closure <code>f</code>. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.then">Read more</a></p>
+</div><h4 id='method.and_then' class="method"><span id='and_then.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then' class='fnname'>and_then</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/and_then/struct.AndThen.html" title="struct futures::future::and_then::AndThen">AndThen</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#525-531' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future after this one has resolved successfully. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.and_then">Read more</a></p>
+</div><h4 id='method.or_else' class="method"><span id='or_else.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else' class='fnname'>or_else</a><F, B>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/or_else/struct.OrElse.html" title="struct futures::future::or_else::OrElse">OrElse</a><Self, B, F> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>) -> B, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#566-572' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Execute another future if this one resolves with an error. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.or_else">Read more</a></p>
+</div><h4 id='method.select' class="method"><span id='select.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select' class='fnname'>select</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select/struct.Select.html" title="struct futures::future::select::Select">Select</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Item = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>, Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#624-631' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select">Read more</a></p>
+</div><h4 id='method.select2' class="method"><span id='select2.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2' class='fnname'>select2</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/select2/struct.Select2.html" title="struct futures::future::select2::Select2">Select2</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#670-674' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Waits for either one of two differently-typed futures to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.select2">Read more</a></p>
+</div><h4 id='method.join' class="method"><span id='join.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join' class='fnname'>join</a><B>(self, other: B) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join.html" title="struct futures::future::join::Join">Join</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#715-721' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Joins the result of two futures, waiting for them both to complete. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join">Read more</a></p>
+</div><h4 id='method.join3' class="method"><span id='join3.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join3' class='fnname'>join3</a><B, C>(<br> self, <br> b: B, <br> c: C<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join3.html" title="struct futures::future::join::Join3">Join3</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#724-730' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join4' class="method"><span id='join4.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join4' class='fnname'>join4</a><B, C, D>(<br> self, <br> b: B, <br> c: C, <br> d: D<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join4.html" title="struct futures::future::join::Join4">Join4</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#733-741' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.join5' class="method"><span id='join5.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.join5' class='fnname'>join5</a><B, C, D, E>(<br> self, <br> b: B, <br> c: C, <br> d: D, <br> e: E<br>) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/join/struct.Join5.html" title="struct futures::future::join::Join5">Join5</a><Self, <B as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <C as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <D as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>, <E as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Future" title="type futures::future::IntoFuture::Future">Future</a>> <span class="where fmt-newline">where<br> B: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> C: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> D: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>,<br> E: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a><Error = Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#744-754' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Same as <code>join</code>, but with more futures.</p>
+</div><h4 id='method.into_stream' class="method"><span id='into_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream' class='fnname'>into_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/into_stream/struct.IntoStream.html" title="struct futures::future::into_stream::IntoStream">IntoStream</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#777-781' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Convert this future into a single element stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.into_stream">Read more</a></p>
+</div><h4 id='method.flatten' class="method"><span id='flatten.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten' class='fnname'>flatten</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten/struct.Flatten.html" title="struct futures::future::flatten::Flatten">Flatten</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html" title="trait futures::future::IntoFuture">IntoFuture</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.IntoFuture.html#associatedtype.Error" title="type futures::future::IntoFuture::Error">Error</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#819-829' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is itself another future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten">Read more</a></p>
+</div><h4 id='method.flatten_stream' class="method"><span id='flatten_stream.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream' class='fnname'>flatten_stream</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/flatten_stream/struct.FlattenStream.html" title="struct futures::future::flatten_stream::FlattenStream">FlattenStream</a><Self> <span class="where fmt-newline">where<br> Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>: <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>,<br> <Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a> as <a class="trait" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html" title="trait futures::stream::Stream">Stream</a>>::<a class="type" href="https://docs.rs/futures/0.1/futures/stream/trait.Stream.html#associatedtype.Error" title="type futures::stream::Stream::Error">Error</a> == Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Error" title="type futures::future::Future::Error">Error</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#859-864' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Flatten the execution of this future when the successful result of this future is a stream. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.flatten_stream">Read more</a></p>
+</div><h4 id='method.fuse' class="method"><span id='fuse.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse' class='fnname'>fuse</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/fuse/struct.Fuse.html" title="struct futures::future::fuse::Fuse">Fuse</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#899-904' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Fuse a future such that <code>poll</code> will never again be called once it has completed. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.fuse">Read more</a></p>
+</div><h4 id='method.inspect' class="method"><span id='inspect.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect' class='fnname'>inspect</a><F>(self, f: F) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/inspect/struct.Inspect.html" title="struct futures::future::inspect::Inspect">Inspect</a><Self, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(&Self::<a class="type" href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#associatedtype.Item" title="type futures::future::Future::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#922-927' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Do something with the item of a future, passing it on. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.inspect">Read more</a></p>
+</div><h4 id='method.catch_unwind' class="method"><span id='catch_unwind.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind' class='fnname'>catch_unwind</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/catch_unwind/struct.CatchUnwind.html" title="struct futures::future::catch_unwind::CatchUnwind">CatchUnwind</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#961-965' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Catches unwinding panics while polling the future. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.catch_unwind">Read more</a></p>
+</div><h4 id='method.shared' class="method"><span id='shared.v' class='invisible'><code>fn <a href='https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared' class='fnname'>shared</a>(self) -> <a class="struct" href="https://docs.rs/futures/0.1/futures/future/shared/struct.Shared.html" title="struct futures::future::shared::Shared">Shared</a><Self></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='https://docs.rs/futures/0.1/src/futures/future/mod.rs.html#1010-1014' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Create a cloneable handle to this future where all handles will resolve to the same result. <a href="https://docs.rs/futures/0.1/futures/future/trait.Future.html#method.shared">Read more</a></p>
+</div></div><h3 id='impl-Drop' class='impl'><span class='in-band'><code>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html" title="trait core::ops::drop::Drop">Drop</a> for <a class="struct" href="../../tokio_core/reactor/struct.Timeout.html" title="struct tokio_core::reactor::Timeout">Timeout</a></code><a href='#impl-Drop' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#102-106' title='goto source code'>[src]</a></span></h3>
+<div class='impl-items'><h4 id='method.drop' class="method"><span id='drop.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&mut self)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/tokio_core/reactor/timeout.rs.html#103-105' title='goto source code'>[src]</a></span></h4>
+<div class='docblock'><p>Executes the destructor for this type. <a href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop">Read more</a></p>
+</div></div></section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <aside id="help" class="hidden">
+ <div>
+ <h1 class="hidden">Help</h1>
+
+ <div class="shortcuts">
+ <h2>Keyboard Shortcuts</h2>
+
+ <dl>
+ <dt><kbd>?</kbd></dt>
+ <dd>Show this help dialog</dd>
+ <dt><kbd>S</kbd></dt>
+ <dd>Focus the search field</dd>
+ <dt><kbd>↑</kbd></dt>
+ <dd>Move up in search results</dd>
+ <dt><kbd>↓</kbd></dt>
+ <dd>Move down in search results</dd>
+ <dt><kbd>↹</kbd></dt>
+ <dd>Switch tab</dd>
+ <dt><kbd>⏎</kbd></dt>
+ <dd>Go to active search result</dd>
+ <dt><kbd>+</kbd></dt>
+ <dd>Expand all sections</dd>
+ <dt><kbd>-</kbd></dt>
+ <dd>Collapse all sections</dd>
+ </dl>
+ </div>
+
+ <div class="infos">
+ <h2>Search Tricks</h2>
+
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>type</code>, <code>macro</code>,
+ and <code>const</code>.
+ </p>
+
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code> or <code>* -> vec</code>)
+ </p>
+ </div>
+ </div>
+ </aside>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "tokio_core";
+ </script>
+ <script src="../../main.js"></script>
+ <script defer src="../../search-index.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/timeout/Timeout.t.html b/tokio_core/reactor/timeout/Timeout.t.html
new file mode 100644
index 0000000..d6412e0
--- /dev/null
+++ b/tokio_core/reactor/timeout/Timeout.t.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=struct.Timeout.html">
+</head>
+<body>
+ <p>Redirecting to <a href="struct.Timeout.html">struct.Timeout.html</a>...</p>
+ <script>location.replace("struct.Timeout.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/reactor/timeout/struct.Timeout.html b/tokio_core/reactor/timeout/struct.Timeout.html
new file mode 100644
index 0000000..ddcb202
--- /dev/null
+++ b/tokio_core/reactor/timeout/struct.Timeout.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=../../../tokio_core/reactor/struct.Timeout.html">
+</head>
+<body>
+ <p>Redirecting to <a href="../../../tokio_core/reactor/struct.Timeout.html">../../../tokio_core/reactor/struct.Timeout.html</a>...</p>
+ <script>location.replace("../../../tokio_core/reactor/struct.Timeout.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tokio_core/sidebar-items.js b/tokio_core/sidebar-items.js
new file mode 100644
index 0000000..3e51560
--- /dev/null
+++ b/tokio_core/sidebar-items.js
@@ -0,0 +1 @@
+initSidebarItems({"macro":[["try_nb","A convenience macro for working with `io::Result<T>` from the `Read` and `Write` traits."]],"mod":[["net","TCP/UDP bindings for `tokio-core`"],["reactor","The core reactor driving all I/O"]]});
\ No newline at end of file
diff --git a/tokio_core/try_nb.m.html b/tokio_core/try_nb.m.html
new file mode 100644
index 0000000..cc31fa3
--- /dev/null
+++ b/tokio_core/try_nb.m.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta http-equiv="refresh" content="0;URL=macro.try_nb.html">
+</head>
+<body>
+ <p>Redirecting to <a href="macro.try_nb.html">macro.try_nb.html</a>...</p>
+ <script>location.replace("macro.try_nb.html" + location.search + location.hash);</script>
+</body>
+</html>
\ No newline at end of file
