689 lines
213 KiB
Plaintext
689 lines
213 KiB
Plaintext
|
rust
|
|||
|
|
QQ #rustc 1.93.0 (254b59607 2026-01-19)Á“õ…·fÊvŠ ¦%g- -c48c539199cbc88bÁ ³VOÐêùÿ²?ÑL¼�§Ì± -a7a40eb546f9e2b0Á á\ƒ¦è3$|]åŒ[IÚ tæ -14b12edc9f8cd90bÁ ë&Gf·Ã ¬ëñq:¤»b -bb76018b1173caf6Áà 9m Ù„«ÐÒþá•c‘B; -030c5b0bba47cc8fÁ rustc_std_workspace_coreÁÛ¹þÓ7>H%¸ÚÉ’› -4b81d37a5530864dÁ üÃùs<Uß7VyóHr#QÏ -c66cc7807550ce25Á miniz_oxideÁõFÖˆÚ™ª‹"ÞXzLVª -62cbc7af83058505Á adler2Á—wÉD‘嵯�|6¨%Œ
|
|||
|
|
+ -2f171dd2394b4b62Á hashbrownÁ,ïcV¼¨ø¢:Ê\'È߈ -9571ba9e0f6c7a90Á rustc_std_workspace_allocÁ%¥Èxµù·¼5Ä3Bœ -aac566ad65903fa4Á
|
|||
|
|
std_detectÁMmáýZ^9õ Îà§e˜÷e -2edb296e590136d8Á rustc_demangleÁ@¼§VÉNb˜æ¨fHÌ+V3 -53b132e4a2fa6e26Á cfg_ifÁfÝv�.Å"ÒÜuPp¹ˆ¶ -f76b385d7d4d7f3eÁ addr2lineÁÕú-WiúQVÓ¬
|
|||
|
|
µT§�5 -fe25100bd73e48e4Á gimliÁ¹xLáÇí÷‘o ±Ñ8£Å -265ba9e6e4f70b3fÁ objectÁÔ³ÝzÓÿ¶ò°öM›¼òü` -9ae0d1f8ea52a318Á memchrÁRÎ÷׎™te~QÓ¿ØC\Ò -0bff3c8e8f4e489eÁ –©H�tGNÏ ·ˆ!á -d69228d077d46f36Á rstest_reuseÁd¿L à$´L testsÁ,¢à$“ &æ,„à$ù
|
|||
|
|
H
|
|||
|
|
decoder_testsÁl‡à$| ºæ,Þ à$Ó €
|
|||
|
|
encoder_testsÁlìà$á ýæ,°Kà$¥K æ naiveÁ,®à$£ ææ,Çà$¼ úæ,º5à$¯5 ’æ,…( à$ú' µæ,·)
|
|||
|
|
à$¬)
|
|||
|
|
µ coverage_gamingÁ|ÖZ
|
|||
|
|
à$ËZ
|
|||
|
|
æ,¨R à$�R “ á chunked_encoderÁ SinkÁ ” write_encoded_bytesÁ ChunkedEncoderÁ 'eÁ EÁ engineÁ ¼ Å • Î SÁ BUF_SIZEÁ
|
|||
|
|
CHUNK_SIZEÁ
|
|||
|
|
StringSinkÁ 'aÁ stringÁ · • "· "” "� displayÁ & &&&&&&&&
|
|||
|
|
Base64DisplayÁ /· /¼ /Å / bytesÁ /É
|
|||
|
|
& 5· 5¼ 5Å 5• &:· :¼ :Å :Í &
|
|||
|
|
FormatterSinkÁ ?· ? 'bÁ ?þ &C· C½ C” C� readÁ H decoderÁ I IIIIIIIII‚ I BASE64_CHUNK_SIZEÁ I DECODED_CHUNK_SIZEÁ I
|
|||
|
|
DecoderReaderÁ V¼ VÅ V RÁ VÍ V innerÁ V
|
|||
|
|
b64_bufferÁ \ V
|
|||
|
|
b64_offsetÁ V b64_lenÁ V decoded_chunk_bufferÁ ` V decoded_offsetÁ V decoded_lenÁ V input_consumed_lenÁ V padding_offsetÁ I f¼ fÅ f„ fÍ Ik¼ kÅ k„ k• o o k flush_decoded_bufÁ k read_from_delegateÁ k
|
|||
|
|
decode_to_bufÁ t t t k
|
|||
|
|
into_innerÁ Iy¼ yÅ y„ yí } H writeÁ € encoderÁ � ��������‚ �
|
|||
|
|
MAX_INPUT_LENÁ � MIN_ENCODE_CHUNK_SIZEÁ �
|
|||
|
|
EncoderWriterÁ �¼ �Å � WÁ �Í � delegateÁ � extra_inputÁ “ � extra_input_occupied_lenÁ � outputÁ – � output_occupied_lenÁ � panickedÁ � š¼ šÅ š¼ šÍ �Ÿ¼ ŸÅ Ÿ¼ Ÿ• £ £ Ÿ finishÁ Ÿ write_final_leftoversÁ Ÿ write_to_delegateÁ ¨ Ÿ write_all_encoded_outputÁ Ÿà �¬¼ ¬Å ¬¼ ¬™ ° ° ° ¬ flushÁ �µ¼ µÅ µ¼ µ² € encoder_string_writerÁ º ººº EncoderStringWriterÁ ¾¼ ¾Å ¾ú ¾¦ º ü ÃÅ Ãú Ã
|
|||
|
|
from_consumerÁ Ãà ºÉ¼ ÉÅ É• ºÍ¼ ÍÅ Íú Í™ ÍÌ º StrConsumerÁ Ó consumeÁ ºÕú Õü ºØü º Utf8SingleCodeUnitWriterÁ Úú Ú str_consumerÁ ºÝú Ý™ ÝÌ € €€€€ Í æ æææææææææ æ
|
|||
|
|
æ æ general_purposeÁ ó óóóóóóóóóï ý ýýýýýýýýý GeneralPurposeEstimateÁ ‡Ï
|
|||
|
|
‡ conservative_decoded_lenÁ ý Š• ýŒ decoded_len_estimateÁ ý
|
|||
|
|
decode_helperÁ Ž Ž UNROLLED_INPUT_CHUNK_SIZEÁ Ž UNROLLED_OUTPUT_CHUNK_SIZEÁ ý complete_quads_lenÁ ’ ý decode_chunk_8Á ” ý decode_chunk_4Á – ó
|
|||
|
|
decode_suffixÁ ˜ ˜˜˜˜˜˜˜˜� ¡ ¡ ó ó
|
|||
|
|
INVALID_VALUEÁ ó ¦• ó¨ ConfigÁ ¨ DecodeEstimateÁ ¨ internal_encodeÁ « BLOCKS_PER_FAST_LOOPÁ « LOW_SIX_BITSÁ « LOW_SIX_BITS_U8Á ¨ internal_decoded_len_estimateÁ ¨ internal_decodeÁ ¨ configÁ ó encode_tableÁ ² ² ó decode_tableÁ µ µ ó read_u64Á ó¹• ¹ with_encode_paddingÁ ¹ with_decode_allow_trailing_bitsÁ ¹ with_decode_padding_modeÁ ó¾> óÀ encode_paddingÁ ó STANDARDÁ ó STANDARD_NO_PADÁ ó URL_SAFEÁ ó URL_SAFE_NO_PADÁ ó PADÁ ó NO_PADÁ æ æ
|
|||
|
|
ææ EngineÁ Ëü ËŠ Ë Ëþ Ë£! ˺! ËÎ Ò™ Ò“ ÔÅ Ë
|
|||
|
|
encode_stringÁ Ö™ Ö“ ØÅ Ë encode_sliceÁ Ú™ Ú“ ÜÅ Ëï Þ™ Þ“ àÅ à Ë
|
|||
|
|
decode_vecÁ ã™ ã“ åÅ å Ë decode_sliceÁ è™ è“ êÅ ê Ë decode_slice_uncheckedÁ í™ í“ ïÅ ï ï æü ó”# æŠ õ³ æ ÷• alphabetÁ ú úúúúú
|
|||
|
|
ALPHABET_SIZEÁ ú � from_str_uncheckedÁ ‚ �• �‡ ú†” †‰ ú‰Í úúª# úÑ# ú CRYPTÁ ú BCRYPTÁ ú
|
|||
|
|
IMAP_MUTF7Á ú BIN_HEXÁ Î ’ ’’’’’’’’Î ›™ ’
|
|||
|
|
encode_engineÁ �Å �™ ’ encode_engine_stringÁ Å ™ ’ encode_engine_sliceÁ £Å £™ ’ encode_with_paddingÁ ¦Å ’ encoded_lenÁ ’ add_paddingÁ ’ ªÍ ’ ï µ µµµµµµµ ½Í µµÀÍ µÂ sourceÁ µÄï µï Æ™ µ
|
|||
|
|
decode_engineÁ ÈÅ È™ µ decode_engine_vecÁ ËÅ Ë™ µ decode_engine_sliceÁ ÎŠΙ µ³
|
|||
|
|
|
|||
|
|
â Û ÛÛÛÛ PAD_BYTEÁ ó GeneralPurposeÁ âÈ! ã âæ! å âº! óèÍ óêÈ ó GeneralPurposeConfigÁ ì”# ì decode_allow_trailing_bitsÁ ì decode_padding_modeÁ óóñÈ ó ó
|
|||
|
|
ôÍ æ DecodePaddingModeÁ ö IndifferentÁ ÷
|
|||
|
|
ö RequireCanonicalÁ ù
|
|||
|
|
ö RequireNoneÁ û
|
|||
|
|
ææþÈ ææ�Í ææ„Õ æ†˜ æ DecodeMetadataÁ ˆ‡ ˆ² ææ ŒÕ æ
|
|||
|
|
Ž˜ æ �Í ú AlphabetÁ ’ symbolsÁ “ ú•È ú—Í ú™˜ š úú�Õ ú ParseAlphabetErrorÁ Ÿ
|
|||
|
|
InvalidLengthÁ
|
|||
|
|
Ÿ DuplicatedByteÁ ¢
|
|||
|
|
¢ì Ÿ UnprintableByteÁ ¥
|
|||
|
|
¥ì Ÿ ReservedByteÁ ¨
|
|||
|
|
¨ì ú «Í ú
|
|||
|
|
˜ ú ú °Õ ’ EncodeSliceErrorÁ ² OutputSliceTooSmallÁ ³
|
|||
|
|
’µÈ ’·Í ’’ºÕ ’¼˜ µ DecodeErrorÁ ¾ InvalidByteÁ ¿
|
|||
|
|
¿ì ¿í ¾‚3 Ã
|
|||
|
|
Ãì ¾ InvalidLastSymbolÁ Æ
|
|||
|
|
Æì Æí ¾ InvalidPaddingÁ Ê
|
|||
|
|
µÌÈ µÎÍ µµÑÕ µ Ó˜ µ DecodeSliceErrorÁ Õ¡5 Ö
|
|||
|
|
Öì ÕÈ4 Ù
|
|||
|
|
µ
|
|||
|
|
ÛÈ µ ÝÍ µ µ
|
|||
|
|
àÕ µâ˜
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
!
|
|||
|
|
%
|
|||
|
|
%
|
|||
|
|
>
|
|||
|
|
>
|
|||
|
|
>
|
|||
|
|
G
|
|||
|
|
G
|
|||
|
|
j
|
|||
|
|
j
|
|||
|
|
j
|
|||
|
|
r
|
|||
|
|
r
|
|||
|
|
s
|
|||
|
|
t
|
|||
|
|
t
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
ž
|
|||
|
|
ž
|
|||
|
|
ž
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
¨
|
|||
|
|
ª
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
´
|
|||
|
|
¹
|
|||
|
|
Ñ
|
|||
|
|
Ñ
|
|||
|
|
Ò
|
|||
|
|
Ô
|
|||
|
|
Ô
|
|||
|
|
Õ
|
|||
|
|
×
|
|||
|
|
×
|
|||
|
|
Ù
|
|||
|
|
Ù
|
|||
|
|
ß
|
|||
|
|
ß
|
|||
|
|
à
|
|||
|
|
�
|
|||
|
|
Ž
|
|||
|
|
Ž
|
|||
|
|
Ž
|
|||
|
|
’
|
|||
|
|
’
|
|||
|
|
”
|
|||
|
|
”
|
|||
|
|
”
|
|||
|
|
–
|
|||
|
|
–
|
|||
|
|
–
|
|||
|
|
¡
|
|||
|
|
¡
|
|||
|
|
¡
|
|||
|
|
§
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
¯
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
±
|
|||
|
|
²
|
|||
|
|
µ
|
|||
|
|
¸
|
|||
|
|
Á
|
|||
|
|
Î
|
|||
|
|
Î
|
|||
|
|
Î
|
|||
|
|
Ï
|
|||
|
|
Ð
|
|||
|
|
Ð
|
|||
|
|
Ð
|
|||
|
|
Ñ
|
|||
|
|
Ò
|
|||
|
|
Ô
|
|||
|
|
Ô
|
|||
|
|
Ö
|
|||
|
|
Ö
|
|||
|
|
Ø
|
|||
|
|
Ø
|
|||
|
|
Ø
|
|||
|
|
Ú
|
|||
|
|
Ú
|
|||
|
|
Ü
|
|||
|
|
Ü
|
|||
|
|
Ü
|
|||
|
|
Þ
|
|||
|
|
à
|
|||
|
|
à
|
|||
|
|
ã
|
|||
|
|
ã
|
|||
|
|
å
|
|||
|
|
å
|
|||
|
|
å
|
|||
|
|
è
|
|||
|
|
è
|
|||
|
|
ê
|
|||
|
|
ê
|
|||
|
|
ê
|
|||
|
|
í
|
|||
|
|
í
|
|||
|
|
ï
|
|||
|
|
ï
|
|||
|
|
ï
|
|||
|
|
ô
|
|||
|
|
ö
|
|||
|
|
‚
|
|||
|
|
„
|
|||
|
|
…
|
|||
|
|
†
|
|||
|
|
ˆ
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
Š
|
|||
|
|
�
|
|||
|
|
|
|||
|
|
|
|||
|
|
£
|
|||
|
|
£
|
|||
|
|
¦
|
|||
|
|
¦
|
|||
|
|
¦
|
|||
|
|
©
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
¾
|
|||
|
|
¾
|
|||
|
|
¾
|
|||
|
|
Á
|
|||
|
|
Á
|
|||
|
|
Á
|
|||
|
|
Ã
|
|||
|
|
È
|
|||
|
|
Ë
|
|||
|
|
Ë
|
|||
|
|
Î
|
|||
|
|
Î
|
|||
|
|
é
|
|||
|
|
é
|
|||
|
|
é
|
|||
|
|
ë
|
|||
|
|
ò
|
|||
|
|
õ
|
|||
|
|
õ
|
|||
|
|
õ
|
|||
|
|
ÿ
|
|||
|
|
‚
|
|||
|
|
‚
|
|||
|
|
‚
|
|||
|
|
…
|
|||
|
|
…
|
|||
|
|
‡
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
‘
|
|||
|
|
‘
|
|||
|
|
‘
|
|||
|
|
–
|
|||
|
|
˜
|
|||
|
|
˜
|
|||
|
|
˜
|
|||
|
|
š
|
|||
|
|
ž
|
|||
|
|
ž
|
|||
|
|
¬
|
|||
|
|
¬
|
|||
|
|
¬
|
|||
|
|
®
|
|||
|
|
±
|
|||
|
|
±
|
|||
|
|
¶
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
»
|
|||
|
|
»
|
|||
|
|
½
|
|||
|
|
Í
|
|||
|
|
Ï
|
|||
|
|
Ï
|
|||
|
|
Ï
|
|||
|
|
Ò
|
|||
|
|
Ò
|
|||
|
|
Ô
|
|||
|
|
Ü
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
Þ
|
|||
|
|
á
|
|||
|
|
á
|
|||
|
|
ã
|
|||
|
|
ÓËóõ ¦ À ”¥].N1¯� · å` / / ¦
|
|||
|
|
3Ï
|
|||
|
|
& 4É
|
|||
|
|
& ‚Ú ÿ“P · ¼ Å ? ? ¢ Bþ & Ó,Ë©[= · ½ à` V V â
|
|||
|
|
ZÍ I [“ I \Ÿ I ^´ I _Å I `Ó I bò I c‡ I d™ I e² I ŽòNDЙ9 ¼ Å „ ‹B à` � � — ‘Í � ’Í � “Ý � •õ � –• � ˜¨ � ™Ã � �èÌ”Ìm! ¼ ”C¼ ß ±C � ±C ß ¾ ¾ ª ¦ º ºå|jÁhö ¼ ”Cú Ó 8ú ÓÉHÉH ’ ÊHœÜ3 ËÚ¢×€JÜ ß Ú Ú ÜÕ º ;?çqhàxÒ ú õ ‡ ‡ Û ˆÏ
|
|||
|
|
ý ‰� ý K³ŠzFÆ à` â â ´. ãÈ! ó åæ! ó çº! ó ª0J‹+Ç´> ÞÔF ËÔF á ì ì †/ í”# ó îª/ ó ïÌ/ ó Ç-•ºyv—Ì Þ´G þ ´G à`´G Ä´G ó´G á ö ÷ ø¤0 ù ú¼0 û üÙ0 >h\Dª©T Þ²H þ ²H à`²H ¬â²H ž²H²H £²H ¬â ˆ ˆ ´1 ‰‡ Š² i±]¬žÏí ž¿I¿I £¿I à`¿I Þ ’ ’ †2 “–2 ½í¬„À
|
|||
|
|
à`žJ £žJ ¬âžJ žžJžJ �žJ 8 à` Ÿ ¡‚3 ¢ £œ3 ¤ì ¥ ¦¿3 §ì ¨ ©ã3 ªì D¸ýrk²
|
|||
|
|
å £�K ¬â�K ž�K�K å`�K Ï�K Þ ² ³ ´È4 ¶G|«¹$ à`¼L ¬â¼L ž¼L¼L £¼L å`¼L ϼL Þ ¾ ¿ À´5 Áì Âí à Ă3 Åì Æ Çñ5 Èì Éí Ê ËŸ6 »Æ_j_ªO à`¨M ¬â¨M ž¨M¨M £¨M å`¨M ϨM Þ Õ Ö ×¡5 Øì Ù ÚÈ4 G£bOž.˜� à`ñN ¬âñN žñNñN £ñN å`ñN ÏñN úñN¨M " C ?: /‰ Ÿª ²½ ¾À Õf Vš �è âô ì� ö� ˆ— ’« Ÿ· ²Î ¾Ý Õy V¬ �Í ¾Ý Úµ �Õ
|
|||
|
|
ØÉHŒ ‡ê âñ ìþ ö• ’µ ²Ì ¾Û Õ¨ âð ìý öó ì€ ö¾ ìÀ ìƒ ö‹ ˆœ ’¯ Ÿ¹ ²Ð ¾ß Õ„ öŒ ˆ� ’° Ÿº ²Ñ ¾à Õ† öŽ ˆ™ ’ Ÿ¼ ²Ó ¾â Õ† ’‹ Ÿ¬ ²¿ ¾Â ÕÄ Õ Éå`
|
|||
|
|
à` ! Kß � Ó õ Þ Ë1áþ Ä ó¬âž1£1�1Ïú 1024Ád� Œ ·T% ·T 9 D� ·T S ·TV ·T „� � ·T $ ' ·T J ·T K üç+ ·T ,ù ·T þ ·T – <× ·Tá ·T _Á ·T BUF_SIZEÁ ·T 1024Á ·T 4Á ·T 3Á ·T BUF_SIZEÁ ·T DECODED_CHUNK_SIZEÁ ·T BUF_SIZEÁ ·T DECODED_CHUNK_SIZEÁ ·T DECODED_CHUNK_SIZEÁ ·T 1024ÁdØ ã ·T% ·T 9 DØ Š ·T T Š ·TX ·T „Ø ç ·T $ ' ·T J ·T K ü». ‹ ·T ,Ð ·T ÎV • ;Ø Š ·Tã Š ·T _Á ·T 3Á ·T MIN_ENCODE_CHUNK_SIZEÁ ·T BUF_SIZEÁ ·T MIN_ENCODE_CHUNK_SIZEÁ ·T BUF_SIZEÁ ·T 256Á ·T 32Áìº Ö ·T% ·T 9 ̺ � ·T T � ·TX ·T üº ! Ú ·T % ' ·T K ·T K ü� L ‘ ·T ,² ·T ÎV – ;Ù � ·Tä � ·T _Á ·T 256Á ·T 256Á ·T 256Á ·T 256Á ·T 4Á ÿ 255Á @ ·T 64Á ·T 256Á´¹ DÆ
|
|||
|
|
$ d¹
|
|||
|
|
² 1 A Î ´ë Dø
|
|||
|
|
$ dë
|
|||
|
|
µ 1 A €
|
|||
|
|
4�
|
|||
|
|
ü˜ ˆ
|
|||
|
|
â Ÿ
|
|||
|
|
¦
|
|||
|
|
§ üÂä ÔF $‰ žJ DÓ ´G 4è Ï`·T @ , �c , Ï`·T ý �c ü ´G ¾ Ì'V º!Z ˆ ·T 4Á ? 0x3FÁ ?Ï` 0x3FÁ„©H T¼H $½H Ï`·T @ üÌHš LÚH æH
|
|||
|
|
·T üñHo T÷H ,÷H ÿH @ ·T = €I ¼¦I ,·I
|
|||
|
|
' ·T·T @ =
|
|||
|
|
G ·T·T @ a ¢c ,�I œ�I ·T·T @ $ . ·T·T @ ü�I- ¼I ½I TËI
|
|||
|
|
ÔI ·T $
|
|||
|
|
' ·T J
|
|||
|
|
·T ü‚I^ “ßI Ç
|
|||
|
|
Ï ‚ ø“ñHo Þh < B åI dìI ùI úI ² üƒG÷ ü¥HÕ üÖH� ¢c D¼G �c D¤G ¢c Ë Þh w ·T ¥Þh M ƒ ·T ƒ Ï` @ ·T @ O ·T ä Ø ÎV r ì Þh ó ù Ì'{ È!J ö É @ ·T 64Á @ ·T 64Á„¨L ¤»L l¼L ¥ Ï`·T LÐM ÜM
|
|||
|
|
·T üãMú TéM ,éM ñM @ ·T = òM ,·O ü“O ¼“O
|
|||
|
|
,¤O ' ·T·T @ = G ·T·T @ a
|
|||
|
|
¢c |
|
|||
|
|
·T ²O
|
|||
|
|
ü†O.
|
|||
|
|
·T·T %
|
|||
|
|
/ ·T·T ü†O< Ï` ÁO ÂO TÌO ÕO ·T $ ' ·T J ·T üôMé Þh ”ÜO ô
|
|||
|
|
ü ¦ ø”ãMú Þh = C ÜO dãO ðO ñO µ üÛK– ü¤LÍ üÌM¥ Àc L”L �c DüK Àc î ·T É Þh Þh M ¨ ·T ¨ ·T e ·T Z Ï` Y ·T Y h æ ÎV | õ Þh ü Ì'„ æ!v öU Ò} ¥ Ï` ·T 256Á ·T 256ÁüŠZ#
|
|||
|
|
ö üÏXé
|
|||
|
|
ì $´Y ,âY ·Z ¾Z º üªX” ´G $ÀX ²H | <é_ üÆ_H
|
|||
|
|
ì ²H �` ”` » üþ^– ´G $·_ ´G $Ÿ_ <¥_ y paddingÁ% O ,Ðe ü¡eR
|
|||
|
|
ì ²H òe ùe ¼ üÏdª ´G $’e ´G $üd ,‚e y è H $Üm ü´mJ
|
|||
|
|
ì ým „n ½ üÝl§ ´G $¥m ´G $ƒm ²H $‰m ²H z modeÁ# N œ¥q  �c # 0 ü‘q-
|
|||
|
|
|
|||
|
|
œ‘q
|
|||
|
|
§ \ ºq Æ ´G
|
|||
|
|
7 ½q üìpS  ÔF t€q �c �c ´ žJ ”¦q �c Ä C Œ žJ{ Æ ´G _Á: B Œ žJ  �c 3 žJ € BŒ Œ žJ œãr à �c # 0 üÏr0
|
|||
|
|
|
|||
|
|
œÏr �y Y4ør Ç ´G
|
|||
|
|
4 þr ü£r] à ÔF t¾r �c ª �c ± žJ ”är �c Á C Œ žJ{ Ç ´G _Á: B Œ žJ à �c 0 žJ € ?Œ Œ žJ œšt Ä �c # 0 ü†t-
|
|||
|
|
|
|||
|
|
œ†t �y Y ¯t Æ ´G
|
|||
|
|
4 ²t üásS Ä ÔF tõs �c ª �c ± žJ ”›t �c Á C � žJ{ Æ ´G _Á: B � žJ Ä �c 0 žJ € ?Œ � žJ œØu Å �c # 0 üÄu0
|
|||
|
|
|
|||
|
|
œÄu �y Y4íu Ç ´G
|
|||
|
|
4 óu ü˜u] Å ÔF t³u �c ª �c ± žJ ”Ùu �c Á C � žJ{ Ç ´G _Á: B � žJ Å �c 0 žJ € ?Œ � žJ Üýw
|
|||
|
|
Ìýw
|
|||
|
|
º ! ü×wB Æ ´G ¤æw % _Á ü�y; Ü�y
|
|||
|
|
Ì�y °ƒ % 2
|
|||
|
|
9 ϡy
|
|||
|
|
» E,Äy Ô°y Éy ôéy
|
|||
|
|
ö ü�yy
|
|||
|
|
|
|||
|
|
ÄÐy
|
|||
|
|
½ ª = üÐy8 ‡z üæx£ Ç ´G ¤øx ´G ô ´G ò ²H � ; _Á @ ·T 64Á @ ·T
|
|||
|
|
ALPHABET_SIZEÁ @ ·T
|
|||
|
|
ALPHABET_SIZEÁ\… ¬“ $” Ï`·T @ d¶ DÅ œÅ
|
|||
|
|
DÎ
|
|||
|
|
¹y 3 TÎ × L› §
|
|||
|
|
·T ü²q ¬¸ ,¸ lÀ € ·T 7 Ì œí
|
|||
|
|
,ú '
|
|||
|
|
8
|
|||
|
|
K
|
|||
|
|
,ä tÜ ·T·T @ $ . ·T·T @ üÜ$
|
|||
|
|
ÿ
|
|||
|
|
€ TŽ — ·T $ ' ·T J ·T üÎU Þh ¡¢ ¯
|
|||
|
|
·
|
|||
|
|
h ø¡²q Þh < B ¢ <´ „
|
|||
|
|
’ ¼  à ‚ üÃ
|
|||
|
|
€ ü� ü²‘ ü—¬ žJ $ò
|
|||
|
|
Dß
|
|||
|
|
¢c .
|
|||
|
|
Ï` �� ·T Î Þh ² Þh n ® ·T ® Ï` q ·T q ·T � ˆ ·T 7 + ÎV Å ? Þh G N ¢c ' Ì'£ –2Õ source_bytesÁÁ ö| - € ·T @ ·T
|
|||
|
|
ALPHABET_SIZEÁ ,² Dº œº
|
|||
|
|
Dà ˇ 1 TÃ Ì ü×f äÚ \Ú ,Ú
|
|||
|
|
$ à
|
|||
|
|
ÝpÏ` 4 ,à ä Z lé € ·T v õ ü�!
|
|||
|
|
Ÿ üŒ&
|
|||
|
|
곞J�K ± ¼ ^ ½
|
|||
|
|
Þh . 4 üÇü
|
|||
|
|
|
|||
|
|
LÙ å
|
|||
|
|
·T üôÅ
|
|||
|
|
¬ú
|
|||
|
|
,ú
|
|||
|
|
l‚ € ·T 7
|
|||
|
|
Ž $¦ ,³ d 2 ¹ üé„ lî $î ,ö Ï` 6 ú tÿ $ÿ 4‡ ~Ï` 6
|
|||
|
|
|
|||
|
|
Œ í
|
|||
|
|
Þh ì üËo „Î $Î DÖ á Ï` 7
|
|||
|
|
| 3 Ø C
|
|||
|
|
ü°) $Ô
|
|||
|
|
Ÿ Ø ü¬.
|
|||
|
|
곞J�K Ù à æ ì ½
|
|||
|
|
Ý ü€& $¡
|
|||
|
|
Ÿ ¥ üü+
|
|||
|
|
곞J�K ¦ ¹ ; ~ º
|
|||
|
|
Þh 0 6 |²! Ä !
|
|||
|
|
·T ü×·" ÜÝ# \Ý$ $ ! # $ lë € ·T 7# ÷$ ü�{% ¤’& \’' ' ! ,¡( ( . & ' ( ?& ¥( ' „Á * ! Ð ·T $ * ! ' ·T J ! * ·T ‰ & % £� # À
|
|||
|
|
È
|
|||
|
|
�( •' Š %
|
|||
|
|
Þh F& L% T¤ + \· , , ! ”± - . , - . - , 2 + , à , üÚ {/ ”Ý 0 $Ý 1 1 Tå 2 2 + . 0 1 2 ?0 î 2 1 ü• (4 $¸ 5 5 4
|
|||
|
|
Ÿ 5 ¼ 5 ü‘ -
|
|||
|
|
곞J�K 4 ½ 4 Ô 0 / � + # " ¸ ! L ¡2 §1 Õ /
|
|||
|
|
Þh S0 Y/ „ë 6 ! ú ·T $ 6 ! ' ·T J ! 6 ·T üù• Þh ¾+ ;# m
|
|||
|
|
u %$ ø£×·8 " Þh u8 |# " T : © ·T $ : ' ·T J : ·T ü�©
|
|||
|
|
Þh k! r ¢¸
|
|||
|
|
k
|
|||
|
|
s + ø¢ôÅ
|
|||
|
|
<
|
|||
|
|
Þh =< C
|
|||
|
|
Â
|
|||
|
|
üÐ "> Dé ? ?
|
|||
|
|
%ÄÐ
|
|||
|
|
‚ ? 1> B ñ ? üÍ &
|
|||
|
|
ê³ žJ�K > ò > ø ù W å
|
|||
|
|
¢ ¨
|
|||
|
|
´ 6 4 = „ üßš
|
|||
|
|
ü®Ë üÕî
|
|||
|
|
ü¢—
|
|||
|
|
ü®‹ ü î @ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘žJ�K üƒ �� Dð � ¶
|
|||
|
|
�� ·
|
|||
|
|
Þh x
|
|||
|
|
v
|
|||
|
|
·T v
|
|||
|
|
� w
|
|||
|
|
ü÷F �K
|
|||
|
|
Þh j ·T ˜ Þh ù u ·T u Ï` 8 ·T 8 ·T - 4 Þh ô ñ Ï` ñ ´ Ï` ´ ü�^ �K í Ï` ì Þh k i Ï` i üß[ �K › Ï` š ·T Þh õ é ·T é Þh ¬ ª ·T ª ·T Ÿ ü§c ÎV p Ï` Í ·T Í ·T Â É Þh ‰ ‡ Ï` ‡ Ï` | üð e �K M Ï` L ÎV Þh % ÎV ü g Þh o v žJ H �� H Ì'ö Ï
|
|||
|
|
° öT byteÁæ
|
|||
|
|
probe_indexÁH !
|
|||
|
|
probe_byteÁË + óI € ·TS € ·TÞ á Ï`2 € ·T üÃ*B @�� " ü¡*g
|
|||
|
|
|
|||
|
|
ä¡* ¢ L % ‡+ ü‚*‡ Œ žJ D–* �� � �� — 6 _Á üà,B @�� " ü¾,g
|
|||
|
|
|
|||
|
|
ä¾, ¢ L % ¤- üŸ,‡ � žJ D³, �� � �� — 6 _Á ü˜/B @�� " üö.g
|
|||
|
|
|
|||
|
|
äö. ¢ L % Ü/ üÚ.„ Ž žJ Dë. �� � �� — 6 _Á ü¸0B @�� " ü–0g
|
|||
|
|
|
|||
|
|
ä–0 ¢ L % ü0 üù/… � žJ D‹0 �� � �� — 6 _Á üÎ2B @�� " ü¬2g
|
|||
|
|
|
|||
|
|
ä¬2 ¢ L % ’3 ü‹2‰ � žJ D¡2 �� � �� — 6 _Á üà4C @�� " ü¾4h
|
|||
|
|
|
|||
|
|
ä¾4 ¢ L % ¥5 ü 4‡ ‘ žJ D³4 �� � �� — 6 _Á ‰ L� l� › ·T ·T 3 C
|
|||
|
|
D ·T V ¬§ L¿ l¿ Ë ·T ·T 3 C D ·T V ¬Ö ü›$
|
|||
|
|
¬›
|
|||
|
|
#\±
|
|||
|
|
ùÍ 0 ½ ·T
|
|||
|
|
t± ¾ e
|
|||
|
|
Üý ¬‚
|
|||
|
|
|
|||
|
|
|
|||
|
|
� ·T ¬Î
|
|||
|
|
ì
|
|||
|
|
—
|
|||
|
|
<¡ ¡ § ·T = $ˆ
|
|||
|
|
ø° ·T j
|
|||
|
|
ÿ € ` <¶
|
|||
|
|
‰ ¬â ÜÝ
|
|||
|
|
ø°·T ÷ üžà ¬Ì üÌ$
|
|||
|
|
|
|||
|
|
\â
|
|||
|
|
îÍ 3 î ·T tâ ï ü³” \’ L ñ
|
|||
|
|
·T
|
|||
|
|
Á
|
|||
|
|
·T
|
|||
|
|
¬� \± ü� .
|
|||
|
|
|
|||
|
|
\¥ ý· C 5 Ä¥ ¼ Æ Ý X ý í ô û î ø ¨ ü´Ì ü…û ü£Ý üÒ® üÀ- üŽ ¹ ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>·T lñ ·T LÍ <ß ·T ê ·T ê Þ ·T ·T s ·T ž» ·T ´ ·T ¬ üó$ ‚ ·T ‚ ·T ¡ ·T =·T á ·T Ö ·T bytes_lenÁ» ËtÀ Ï
|
|||
|
|
® complete_input_chunksÁM complete_chunk_outputÁì î¼p
|
|||
|
|
encoded_remÁé Ñ =Ï` b'='Át§#
|
|||
|
|
Ÿ £ % �K 0 Ï` 7 > |ÿ#
|
|||
|
|
Ÿ ¦ % �K 0 Ï` 7 > d³$
|
|||
|
|
Ÿ © % �K 0 Ï` 7 > \Ø
|
|||
|
|
|
|||
|
|
¾ À ( ¨M 3 ·T : Ï` A H l€
|
|||
|
|
|
|||
|
|
¾ Ä % ¨M 0 ·T 7 > Œú
|
|||
|
|
|
|||
|
|
¾ Ç ( ¨M 3 ·T : Ï` A H \ä
|
|||
|
|
|
|||
|
|
Õ × % ñN 0 ¨M 7 > &H€æú’µÛá“ á,ÐK $4øM Ë ùÎ4òN › ®ð)lúN � ¯•*¤‰O °Á*œÍO £ ²�+\âO ¨ ³°4„ïO ² ´ï4áP Æ Óà,léP È Ô…-ŒøP Ë Õ®-œ¹Q Π׳ ¤ÎQ Ñ Ø¡5\äQ ¾ Ùó6„ñQ Õ Úü ÊR ü L I Correct, fast, and configurable [base64][] decoding and encoding. Base64Á üMK H transports binary data efficiently in contexts where only plain text isÁ d™ allowed.Á ¦ Ë üªF C [base64]: https://developer.mozilla.org/en-US/docs/Glossary/Base64Á ñ Ë \õ # UsageÁ � Ë ü…L I Use an [`Engine`] to decode or encode base64, configured with the base64Á üÒB ? alphabet and padding behavior best suited to your application.Á • Ë œ™ ## Engine setupÁ Ë ü±K H There is more than one way to encode a stream of bytes as “base64â€�.Á üý1 . Different applications use different encodingÁ ü¯' $ [alphabets][alphabet::Alphabet] andÁ ü×G D [padding behaviors][engine::general_purpose::GeneralPurposeConfig].Á Ÿ Ë Ì£ ### Encoding alphabetÁ ½ Ë üÁK H Almost all base64 [alphabets][alphabet::Alphabet] use `A-Z`, `a-z`, andÁ ü�P M `0-9`, which gives nearly 64 characters (26 + 26 + 10 = 62), but they differÁ üÞ% " in their choice of their final 2.Á „ Ë üˆO L Most applications use the [standard][alphabet::STANDARD] alphabet specifiedÁ üØO L in [RFC 4648][rfc-alphabet]. If that’s all you need, you can get startedÁ ü¨' $ quickly by using the pre-configuredÁ üÐS P [`STANDARD`][engine::general_purpose::STANDARD] engine, which is also availableÁ ü¤ J G in the [`prelude`] module as shown here, if you prefer a minimal `use`Á tï footprint.Á þ Ë¡ ¡
|
|||
|
|
¥
|
|||
|
|
```Á ¥Ð ,§
|
|||
|
|
\¡
|
|||
|
|
Üç
|
|||
|
|
use base64::prelude::*;Á ƒ Ë ü‡ 4 1 # fn main() -> Result<(), base64::DecodeError> {Á ü¼ L I assert_eq!(BASE64_STANDARD.decode(b"+uwgVQA=")?, b"\xFA\xEC\x20\x55\0");Á ü‰ J G assert_eq!(BASE64_STANDARD.encode(b"\xFF\xEC\x20\x55\0"), "/+wgVQA=");Á dÔ # Ok(())Á <á # }Á <é ```Á ñ Ë üõ K H [rfc-alphabet]: https://datatracker.ietf.org/doc/html/rfc4648#section-4Á Á
|
|||
|
|
Ë üÅ
|
|||
|
|
D A Other common alphabets are available in the [`alphabet`] module.Á Š Ë ÔŽ #### URL-safe alphabetÁ © Ë üN K The standard alphabet uses `+` and `/` as its two non-alphanumeric tokens,Á üüM J which cannot be safely used in URL’s without encoding them as `%2B` andÁ TÊ `%2F`.Á Õ Ë üÙY V To avoid that, some applications use a [“URL-safeâ€� alphabet][alphabet::URL_SAFE],Á ü³M J which uses `-` and `_` instead. To use that alternative alphabet, use theÁ ü�P M [`URL_SAFE`][engine::general_purpose::URL_SAFE] engine. This example doesn'tÁ üÒG D use [`prelude`] to show what a more explicit `use` would look like.Á š Ë¡ ½ Á ¥Ð ¥Ð ,à \½ üƒA > use base64::{engine::general_purpose::URL_SAFE, Engine as _};Á Å Ë üÉ4 òÐ üþE B assert_eq!(URL_SAFE.decode(b"-uwgVQA=")?, b"\xFA\xEC\x20\x55\0");Á üÄC @ assert_eq!(URL_SAFE.encode(b"\xFF\xEC\x20\x55\0"), "_-wgVQA=");Á dˆ ÖÒ <• êÒ <� ùÒ ¥ Ë Ô© ### Padding charactersÁ Ä Ë üÈN K Each base64 character represents 6 bits (2â�¶ = 64) of the original binaryÁ ü—H E data, and every 3 bytes of input binary data will encode to 4 base64Á üà5 2 characters (8 bits × 3 = 6 bits × 4 = 24 bits).Á – Ë üšN K When the input is not an even multiple of 3 bytes in length, [canonical][]Á üéL I base64 encoders insert padding characters at the end, so that the outputÁ ü¶% " length is always a multiple of 4:Á Ü Ë üàJ G [canonical]: https://datatracker.ietf.org/doc/html/rfc4648#section-3.5Á « Ë¡ Î Ò ¥Ð ¥Ð ,Ô \Î ü”A > use base64::{engine::general_purpose::STANDARD, Engine as _};Á Ö Ë üÚ, ) assert_eq!(STANDARD.encode(b""), "");Á ü‡0 - assert_eq!(STANDARD.encode(b"f"), "Zg==");Á ü¸0 - assert_eq!(STANDARD.encode(b"fo"), "Zm8=");Á üé0 - assert_eq!(STANDARD.encode(b"foo"), "Zm9v");Á <š ùÒ ¢ Ë ü¦ N K Canonical encoding ensures that base64 encodings will be exactly the same,Á üõ M J byte-for-byte, regardless of input length. But the `=` padding charactersÁ üà G D aren’t necessary for decoding, and they may be omitted by using aÁ ü‹ > ; [`NO_PAD`][engine::general_purpose::NO_PAD] configuration:Á Ê Ë¡ í ñ ¥Ð ¥Ð ,ó \í ü³ H E use base64::{engine::general_purpose::STANDARD_NO_PAD, Engine as _};Á ü Ë ü€ 3 0 assert_eq!(STANDARD_NO_PAD.encode(b""), "");Á ü´ 5 2 assert_eq!(STANDARD_NO_PAD.encode(b"f"), "Zg");Á üê 6 3 assert_eq!(STANDARD_NO_PAD.encode(b"fo"), "Zm8");Á ü¡!7 4 assert_eq!(STANDARD_NO_PAD.encode(b"foo"), "Zm9v");Á <Ù! ùÒ á! Ë üå!M J The pre-configured `NO_PAD` engines will reject inputs containing paddingÁ ü³"L I `=` characters. To encode without padding and still accept padding whileÁ ü€#N K decoding, create an [engine][engine::general_purpose::GeneralPurpose] withÁ üÏ#3 0 that [padding mode][engine::DecodePaddingMode].Á ƒ$ Ë¡ ¦$ ª$ ¥Ð ¥Ð ,¬$ \¦$ üì$J G # use base64::{engine::general_purpose::STANDARD_NO_PAD, Engine as _};Á ü·%Z W assert_eq!(STANDARD_NO_PAD.decode(b"Zm8="), Err(base64::DecodeError::InvalidPadding));Á <’& ùÒ š& Ë ìž& ### Further customizationÁ ¼& Ë üÀ&C @ Decoding and encoding behavior can be customized by creating anÁ ü„'O L [engine][engine::GeneralPurpose] with an [alphabet][alphabet::Alphabet] andÁ üÔ': 7 [padding configuration][engine::GeneralPurposeConfig]:Á �( Ë¡ ²( ¶( ¥Ð ¥Ð ,¸( \²( üø(0 - use base64::{engi
|
|||
|
|
)
|
|||
|
|
)”ÃK )œÎL |ÒL ¢+\ © ü 43 ó $4; Ë ’4 ÉH
|
|||
|
|
œ ¶ ›s üAœ_ QSCE¬p8L°,tù $ƒ ªâ üù´ É– É–
|
|||
|
|
|
|||
|
|
©â Ñ–
|
|||
|
|
\Ž ý– TŽ,“ üÞMœá ä å äÑ– å¢� ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Þh…— õ
|
|||
|
|
Ñ–$ú encodedÁ<€ü€1 t‹ ¼ Å ªâ”C ž Ë”C 4¡ ”C ¼ l¸ § Í |æùùô› ¼ ”C |æùùô› šmo ]4¸ ¼ ”C üÊ2 ¼ Å ª™ Ó º™4ÖÖ™ Ï üƒ2 Š Ú֙
|
|||
|
|
¼ ”CÍ 4ŽüåQ4ì æ ç è æÖ™ ç¢� è†Eê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Þh †E
|
|||
|
|
ú ü ©â†E ó †E $ö
|
|||
|
|
¼ ”C†E$ýÏ
|
|||
|
|
,ƒ sinkÁ$‘=? ¬ÁDÇ ·T¼çTí ·TD® ·Tü®
|
|||
|
|
» ‹
|
|||
|
|
Ž
|
|||
|
|
«
|
|||
|
|
8÷ �
|
|||
|
|
’
|
|||
|
|
ª
|
|||
|
|
8¶ <“
|
|||
|
|
›
|
|||
|
|
7á <�
|
|||
|
|
$ ¤
|
|||
|
|
8à $¦
|
|||
|
|
ü‰
|
|||
|
|
$ TÀ
|
|||
|
|
· Î@ ”¥].N1¯� Ë
|
|||
|
|
´Õ
|
|||
|
|
4Õ
|
|||
|
|
· ¦E¼•» ò
|
|||
|
|
õ
|
|||
|
|
’ 8÷ ö
|
|||
|
|
ù
|
|||
|
|
‘ 8¶ <ú
|
|||
|
|
‚ 7á <„ $ ‹ 8à $� üð
|
|||
|
|
$ · Î@! šü³/ Á é é¦E ¦ À ”¥].N1¯� é È
|
|||
|
|
! · ö Åü´ » ‘ ” ± 8÷ • ˜ ° 8¶ <™ ¡ 7á <£ $ ª 8à $¬ ü�$ · # # Î@$%
|
|||
|
|
% ¹TÛ,à " " ÞhüñFœô ê ë êÎ@ ë¢� ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Þh Î@
|
|||
|
|
" ˆ "
|
|||
|
|
% · $�ö “|ãL ü d a Enables base64'd output anywhere you might use a `Display` implementation, like a format string.Á eË <iùÒ üqLöŽ ¾Ë üÂ( % let data = vec![0x0, 0x1, 0x2, 0x3];Á üë7 4 let wrapper = Base64Display::new(&data, &STANDARD);Á £Ë ü§C @ assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));Á <ëùÒ <ëL /?§ t� & ' $4³ Ë & (‹<Ë å` & *œLÔ Á` & +Í ë Á] & -œ ð ›s & .üø&s¬¤gü¿ []LN„äAC24üÔ+ ü÷\ Y A convenience wrapper for base64'ing bytes into a format string without heap allocation.Á lß · 0 ¼ 1 Å 2 1 2 0 ©âÃA õ ËÃA 4ø ÃA ¼ �„A ‚Ú ÿ“P 34íñDF |†,†& / / · ¢� ü›&|›& / / § Í |æùùô› ¼ ÃAüÆ0 · 6 ¼ 7 Å 8 8 6 7 ºª Ó Êª4Ö„A9 ËÏ ü¸F üý6 3 Create a `Base64Display` with the provided engine.Á ¿ ¬« ¼ ÃA „A 5 5
|
|||
|
|
9 · ¼ ÃAÏ
|
|||
|
|
,ÃÍ 4Ôüù< · ; ¼ < Å = < = ; ºª † ʪ4‰„A> æ` > þ‚$& ü¼B ¿ ì í î ì„A íÁ`Á` œ Ã`è Á] Ä` bufÁÁ] Ê\É:• îê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ÞhѼѼҼ” štÀ. : à :
|
|||
|
|
> · ¼ ÃA$Ä formatterÁLÊüü lƒ
|
|||
|
|
& · @ ½ A A @ ½ · ™
|
|||
|
|
ӱģ
|
|||
|
|
½ ½íô°ÏA Ó,Ë©[= B‘
|
|||
|
|
•
|
|||
|
|
: £
|
|||
|
|
& ? ? · Á`Á` œ Ã`è Á] Ä`É®Á] Ê\É:• ½üÀ
|
|||
|
|
G · D ½ E D E Ó±Í
|
|||
|
|
ÏAFG
|
|||
|
|
G Å
|
|||
|
|
É
|
|||
|
|
TŽ ,“ C C À°ü¬ Lœ¯ ï ð ïÏA ð¢� ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Þh ÏA
|
|||
|
|
C Ã C
|
|||
|
|
G · ½$È î—<Î d—M » öL ùL ”M 8÷ úL ýL “M 8¶ <þL †M 7“ ,ˆM $ �M 8à $�M üôL" ü A > Implementations of `io::Read` to transparently decode base64.Á $ŸM Iâlf V \B <FHSTUV $4
|
|||
|
|
Ë I K¡5\
|
|||
|
|
¾ I L Ùó6„)
|
|||
|
|
Õ I M Ú¤.D;
|
|||
|
|
á I NÐ P
|
|||
|
|
‘ I PÍ U
|
|||
|
|
ï+ I Q ioÁZ
|
|||
|
|
ç I Rü@
|
|||
|
|
t
|
|||
|
|
Œ|~jlXZœJ
|
|||
|
|
MO?A/1ü™
|
|||
|
|
Dª
|
|||
|
|
·TôŠ
|
|||
|
|
Œ�
|
|||
|
|
I ·Tü®
|
|||
|
|
”´
|
|||
|
|
I ·Tüí4
|
|||
|
|
üÔT
|
|||
|
|
Q A `Read` implementation that decodes base64 data read from an underlying reader.Á ©
|
|||
|
|
Ë t
|
|||
|
|
# ExamplesÁ ¼
|
|||
|
|
Ë <À
|
|||
|
|
ùÒ ´È
|
|||
|
|
use std::io::Read;Á Äß
|
|||
|
|
use std::io::Cursor;Á üø(
|
|||
|
|
% use base64::engine::general_purpose;Á ¡
|
|||
|
|
Ë ü¥a
|
|||
|
|
^ // use a cursor as the simplest possible `Read` -- in real code this is probably a file, etc.Á ü‡6
|
|||
|
|
3 let mut wrapped_reader = Cursor::new(b"YXNkZg==");Á ü¾7
|
|||
|
|
4 let mut decoder = base64::read::DecoderReader::new(Á äö
|
|||
|
|
&mut wrapped_reader,Á ü“$
|
|||
|
|
! &general_purpose::STANDARD);Á ¸
|
|||
|
|
Ë ü¼*
|
|||
|
|
' // handle errors as you normally wouldÁ üç
|
|||
|
|
let mut result = Vec::new();Á üˆ.
|
|||
|
|
+ decoder.read_to_end(&mut result).unwrap();Á ·
|
|||
|
|
Ë ü»%
|
|||
|
|
" assert_eq!(b"asdf", &result[..]);Á á
|
|||
|
|
Ë <å
|
|||
|
|
ùÒ lø
|
|||
|
|
¼ W Å X „ Y X W Y ©â”C Š
|
|||
|
|
©âšC •
|
|||
|
|
º™4�
|
|||
|
|
šC D˜
|
|||
|
|
É™l¨
|
|||
|
|
‹B ŽòNDЙ9 Z[\^_`bcde†
|
|||
|
|
Y[ VX D4¨
|
|||
|
|
I V V ÚDß
|
|||
|
|
,ß
|
|||
|
|
I V V šCÔ¤
|
|||
|
|
T¤
|
|||
|
|
I V V Ï` ] Dµ
|
|||
|
|
·TŒ„
|
|||
|
|
|
|||
|
|
T„
|
|||
|
|
|
|||
|
|
I V V ·Ttä
|
|||
|
|
|
|||
|
|
<ä
|
|||
|
|
|
|||
|
|
I V V ·TüÉ.
|
|||
|
|
¤É
|
|||
|
|
I V V Ï` a ”ä
|
|||
|
|
·T¬¾
|
|||
|
|
t¾
|
|||
|
|
I V V ·T”©
|
|||
|
|
\©
|
|||
|
|
I V V ·TÌš
|
|||
|
|
”š
|
|||
|
|
I V V ·Tìë
|
|||
|
|
të
|
|||
|
|
I V V ž»ü»G
|
|||
|
|
¼ g Å h „ i g h i ß¿ Ä
|
|||
|
|
ï¿ Ï
|
|||
|
|
º™4Ç
|
|||
|
|
‡ÀDÒ
|
|||
|
|
‹Bj á` j À
|
|||
|
|
.0 35 ü‰4
|
|||
|
|
Œ
|
|||
|
|
ñ ò ó ñ‹B òÁ`Á` œ Ã`è Á] Ä`É®Á] Ê\É:• óï¯ f �
|
|||
|
|
f
|
|||
|
|
j ¼ ”CšC$‘
|
|||
|
|
þ —
|
|||
|
|
üœ8
|
|||
|
|
¼ l Å m „ n n m l ß¿ ¥
|
|||
|
|
ï¿ °
|
|||
|
|
º™4¨
|
|||
|
|
‡ÀD³
|
|||
|
|
‹Borstx ¡
|
|||
|
|
/1 46 ü¥,
|
|||
|
|
üÛE
|
|||
|
|
B Create a new decoder that will read from the provided reader `r`.Á ¬
|
|||
|
|
šCÚ‹B k k
|
|||
|
|
o ¼ ”CšC readerÁ4°
|
|||
|
|
Í 4»
|
|||
|
|
D·
|
|||
|
|
o o ·T”›
|
|||
|
|
o o ·Tü¯ D
|
|||
|
|
Œ²
|
|||
|
|
I ô õ ô‹B õ¢�ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘·T ” ¡Ñ
|
|||
|
|
í Ó¶neò¢Ëf k Ä
|
|||
|
|
k
|
|||
|
|
r ¼ ”CšC$É
|
|||
|
|
É® Ï
|
|||
|
|
üì#5
|
|||
|
|
ӕ#
|
|||
|
|
I ö ö‹BÊÈ k ‚$
|
|||
|
|
k
|
|||
|
|
s ¼ ”CšC$‡$
|
|||
|
|
ü²)Z
|
|||
|
|
lµ)
|
|||
|
|
I ÷ ø ÷‹B·T ø¢�ÊÈ k Ã)
|
|||
|
|
k
|
|||
|
|
t ¼ ”CšC$È)
|
|||
|
|
b64_len_to_decodeÁŒÎ)
|
|||
|
|
É® è)
|
|||
|
|
,“.
|
|||
|
|
t <closure_kind>Á u <closure_signature>Á u <upvars>Á u u t u ”CšC ñN¨M V V â
|
|||
|
|
ZÍ I [“ I \Ÿ I ^´ I _Å I `Ó I bò I c‡ I d™ I e² I ŽòNDЙ9 ”CšC ½;
|
|||
|
|
tŒË v ¤Ë v ÁË v v t v ”CšC ¨M›É ÞhDž@
|
|||
|
|
tŒË w ¤Ë w ÁË w w t w ”CšC ·T·T ùÌäçE
|
|||
|
|
üÒBY
|
|||
|
|
V Unwraps this `DecoderReader`, returning the base reader which it reads base64 encodedÁ |°C
|
|||
|
|
input from.Á ÄC
|
|||
|
|
Ë üÌCY
|
|||
|
|
V Because `DecoderReader` performs internal buffering, the state of the inner reader isÁ üªD[
|
|||
|
|
X unspecified. This function is mainly provided because the inner reader type may provideÁ üŠEX
|
|||
|
|
U additional functionality beyond the `Read` implementation which may still be useful.ÁTîE
|
|||
|
|
‹BšC k k
|
|||
|
|
x ¼ ”CšC$ùE
|
|||
|
|
ü¢FE
|
|||
|
|
¼ z Å { „ | | z { ß¿ «F
|
|||
|
|
ï¿ ¶F
|
|||
|
|
º™4®F
|
|||
|
|
‡ÀD¹F
|
|||
|
|
‹B} ¡ } §F
|
|||
|
|
.0 35 üòJ7
|
|||
|
|
üîF)
|
|||
|
|
& Decode input from the wrapped reader.Á œG
|
|||
|
|
Ë ü¤G]
|
|||
|
|
Z Under non-error circumstances, this returns `Ok` with the value being the number of bytesÁ ¬†H
|
|||
|
|
written in `buf`.Á H
|
|||
|
|
Ë ü¨H^
|
|||
|
|
[ Where possible, this function buffers base64 to minimize the number of read() calls to theÁ ¤‹I
|
|||
|
|
delegate reader.Á ¤I
|
|||
|
|
Ë d¬I
|
|||
|
|
# ErrorsÁ ½I
|
|||
|
|
Ë üÅIZ
|
|||
|
|
W Any errors emitted by the delegate reader are returned. Decoding errors due to invalidÁ ü¤JI
|
|||
|
|
F base64 are also possible, and will have `io::ErrorKind::InvalidData`.Á$õJ
|
|||
|
|
ù ú ù‹B ú¢�ÊÈ y úJ
|
|||
|
|
y
|
|||
|
|
} ¼ ”CšC$ÿJ
|
|||
|
|
É® …K
|
|||
|
|
”€`
|
|||
|
|
} } ·TäW¢lÈM » §M ªM ÅM 8÷ «M ®M ÄM 8¶ <¯M ·M 7“ ,¹M $ ¾M 8à $ÀM ü¥M" ü B ? Implementations of `io::Write` to transparently handle base64.Á ,ÐM �º—l‰ � ⪜´ ¾ äé\É Ó å\C <G€Š‹Œ� $4 Ë � ‚Ð * ‘ � „Í / ï+ � …ö¶4 ç � † ErrorKindÁLA ¥H � ˆý4L ž � ‰¬ ‚ü 7 tvdfSU<>,.üY Dj ·TÔ» lÁ � ·TüÁ" ¬Ç � ·Tüë5 üê^ [ A `Write` implementation that base64 encodes data before delegating to the wrapped writer.Á É Ë üÍ_ \ Because base64 has special handling for the end of the input data (padding, etc), there's aÁ ü\ Y `finish()` method on this type that encodes any leftover input bytes and adds padding ifÁ üŠ` ] appropriate. It's called automatically when deallocated (see the `Drop` implementation), butÁ üë` ] any error that occurs when invoking the underlying writer will be suppressed. If you want toÁ üÌ1 . handle such errors, call `finish()` yourself.Á þ Ë t‚ Ḡ‘ Ë <• ùÒ ¼� use std::io::Write;Á üµ( ͹ Þ Ë üâ_ \ // use a vec as the simplest possible `Write` -- in real code this is probably a file, etc.Á üÂ\ Y let mut enc = base64::write::EncoderWriter::new(Vec::new(), &general_purpose::STANDARD);Á Ÿ Ë ü£ * μ üÎ $ ! enc.write_all(b"asdf").unwrap();Á ó Ë ü÷ C @ // could leave this out to be called by Drop, if you don't careÁ ü»
|
|||
|
|
@ = // about handling errors or getting the delegate writer backÁ üü
|
|||
|
|
) & let delegate = enc.finish().unwrap();Á ¦ Ë üª ' $ // base64 was written to the writerÁ üÒ + ( assert_eq!(b"YXNkZg==", &delegate[..]);Á þ Ë <‚ ùÒ Š Ë dŽ €‘ › Ë üŸ _ \ Calling `write()` (or related methods) or `finish()` after `finish()` has completed withoutÁ üÿ $ ! error is invalid and will panic.Á ¤
|
|||
|
|
Ë d¨
|
|||
|
|
³Ö µ
|
|||
|
|
Ë ü¹
|
|||
|
|
_ \ Base64 encoding itself does not generate errors, but errors from the wrapped writer will beÁ ü™, ) returned as per the contract of `Write`.Á Æ Ë ŒÊ # PerformanceÁ Ü Ë üàV S It has some minor performance loss compared to encoding slices (a couple percent).Á ü·' $ It does not do any heap allocation.Á ß Ë Œã # LimitationsÁ õ Ë üù` ] Owing to the specification of the `write` and `flush` methods on the `Write` trait and theirÁ üÚ] Z implications for a buffering implementation, these methods may not behave as expected. InÁ ü¸_ \ particular, calling `write_all` on this interface may fail with `io::ErrorKind::WriteZero`.Á ü˜R O See the documentation of the `Write` trait implementation for further details.Á lö ¼ Ž Å � ¼ � � � Ž ß¿ ˆ ©â¯D “ º™4‹ ß ¯D L– É™l§ ±C �èÌ”Ìm! ‘’“•–˜™ ¹„ `b ]_ K4§ � � � Úœž Dž � � � ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>¯Düù( \ù � � � Ï` ” ¬‹ ·Tüñ Äñ � � � ·T´¬ 4¬ � � � Ï` — D¹ ·TÔ¦ œ¦ � � � ·Tt« D« � � � ü¾H ¼ › Å œ ¼ � � œ › ß¿ Ç Ëð Ò º™4Ê ãðLÕ ±Cž á` ž à 02 57 ü� 4 � û ü ý û±C üÁ`Á` œ Ã`è Á] Ä`É®Á] Ê\É:• ýï¯ š ” š
|
|||
|
|
ž ¼ ”C¯D$• þ › üï 9 ¼ Å ¡ ¼ ¢ ¢ ¡ ß¿ ø Ëð ƒ º™4û ãðL† ±C£¦§¨ª« ô 79 <> üý A ü¯ I F Create a new encoder that will write to the provided delegate writer.Á „ ¯DÚ±C Ÿ Ÿ
|
|||
|
|
£ ¼ ”C¯DÍDˆ Í 4• ¬²! £ £ ·TD�" £ £ ·TüÕ(% üî"\ Y Encode all remaining buffered data and write it, including any trailing incomplete inputÁ üÏ## triples and associated padding.Á ÷# Ë üÿ#N K Once this succeeds, no further writes or calls to this method are allowed.Á Ò$ Ë üÚ$_ \ This may write to the delegate writer multiple times if the delegate writer does not acceptÁ ü¾%6 3 all input provided to its `write` each invocation.Á ù% Ë ü�&] Z If you don't care about error handling, it is not necessary to call this function, as theÁ üã&5 2 equivalent finalization is done by the Drop impl.Á �' Ë ü¥'8 5 Returns the writer that this was constructed around.Á â' Ë dê' ³Ö û' Ë üƒ(M J The first error that is not of `ErrorKind::Interrupted` will be returned.Á4Ü( þ þ±Cê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘¯D›É Ÿ ã( Ÿ
|
|||
|
|
¦ ¼ ”C¯D$è( üø,1 ¬û, � ÿ ÿ±Cê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘Þh›É Ÿ ‘- Ÿ
|
|||
|
|
§ ¼ ”C¯D$–- ü¾7H ŒÁ7 � € €±C·T—� Ÿ Ó7 Ÿ
|
|||
|
|
¨ ¼ ”C¯D$Ø7 current_output_lenÁ”Þ7 T€: ¨ŒË © ¤Ë © ÁË © © ¨ © ”C¯D ÊÏÞh ·T � � — ‘Í � ’Í � “Ý � •õ � –• � ˜¨ � ™Ã � �èÌ”Ìm! ”C¯DüB4 Ä°B � � �±C—� Ÿ ÉB Ÿ
|
|||
|
|
ª ¼ ”C¯D$ÎB ü�M üªG[ X Unwraps this `EncoderWriter`, returning the base writer it writes base64 encoded outputÁ <ŠH
|
|||
|
|
an error.Á ÁU Ë dÉU ³Ö ÚU Ë üâU; 8 Any errors emitted by the delegate writer are returned.Á,¥V ‚ ƒ ‚±C ƒ¢� ÊÈ ¬ «V ¬
|
|||
|
|
° ¼ ”C¯D$°V inputÁ,¶V â] °ŒË ± ¤Ë ± ÁË ± ± ° ± ”C¯D Þh·T Þh ¥ °ŒË ² ¤Ë ² ÁË ² ² ° ² ”C¯DË–ƒ„ƒ„ ñ °ŒË ³ ¤Ë ³ ÁË ³ ³ ° ³ ”C¯D ›É›É ˆ„ƒ„ü®ƒ! ü®�Y V Because this is usually treated as OK to call multiple times, it will *not* flush anyÁ üŒ‚0 - incomplete chunks of input or write padding.Á dÁ‚ ³Ö Ò‚ Ë üÚ‚O L The first error that is not of [`ErrorKind::Interrupted`] will be returned.Á,±ƒ „ „±C—� ¬ ·ƒ ¬
|
|||
|
|
´ ¼ ”C¯D$¼ƒ üô„B ¼ ¶ Å · ¼ ¸ ¶ · ¸ ß¿ ý„ Ëð ˆ… º™4€… ãðL‹… ±C¹ � ¹ ù„ 57 9; ”½… $À… … …±CÞh µ Å… µ
|
|||
|
|
¹ ¼ ”C¯D$Ê… ÌP ¬T€¾ÓÚ—l � º » $46 Ë º ¼ö¶G ç º ½ì=¬'.<B üÍ
|
|||
|
|
= üLc ` A `Write` implementation that base64-encodes data using the provided config and accumulates theÁ ü°a ^ resulting base64 utf8 `&str` in a [StrConsumer] implementation (typically `String`), which isÁ ü’$ ! then exposed via `into_inner()`.Á ·Ë t»á¸ ÊË üÎ" Buffer base64 in a new String:Á ñË <õùÒ ¼ýøá ü•(͹ ¾Ë üÂV S let mut enc = base64::write::EncoderStringWriter::new(&general_purpose::STANDARD);Á ™Ë ü�$•ä ÂË üÆ // get the resulting StringÁ üæ& # let b64_string = enc.into_inner();Á �Ë ü‘( % assert_eq!("YXNkZg==", &b64_string);Á <ºùÒ ÂË üÆG D Or, append to an existing `String`, which implements `StrConsumer`:Á ŽË <’ùÒ ¼šøá ü²(͹ ÛË üß+ ( let mut buf = String::from("base64: ");Á ‹Ë ü�D A let mut enc = base64::write::EncoderStringWriter::from_consumer(Á ŒÔ &mut buf,Á üæ$–¼ ‹Ë ü�$•ä ´Ë ü¸( % // release the &mut reference on bufÁ ìá let _ = enc.into_inner();Á ÿË üƒ ) & assert_eq!("base64: YXNkZg==", &buf);Á < ùÒ µ Ë Œ¹ šê Ë Ë üÏ a ^ Because it has to validate that the base64 is UTF-8, it is about 80% as fast as writing plainÁ ܱ
|
|||
|
|
bytes to a `io::Write`.Á œØ
|
|||
|
|
¼ ¿ Å À ú Á Á ¿ À ß¿ ð
|
|||
|
|
¸� û
|
|||
|
|
º™4ó
|
|||
|
|
Ó†E \þ
|
|||
|
|
É™W ÐD ºå|jÁhö Âì
|
|||
|
|
HJ MO ü‘ :<‘ º ¾ ¾ � � — ‘Í � ’Í � “Ý � •õ � –• � ˜¨ � ™Ã � �èÌ”Ìm! ¼ ”C Ú Ú ÜÕ º ;?çqhàxÒ†EüÐ A ¼ Ä Å Å ú Æ Å Ä Æ ß¿ Ù ¸� ä º™4Ü º©\ç ÐDÇÈ Õ +- 02 üí < ü˜ P M Create a EncoderStringWriter that will append to the provided `StrConsumer`.Álô †EÚÐD à Ã
|
|||
|
|
Ç ¼ ”C†EÕd‚
|