Embedded Template Library 1.0
Loading...
Searching...
No Matches
base64_encoder.h
1//*************************************************************************
3//*************************************************************************///\file
4
5/******************************************************************************
6The MIT License(MIT)
7Embedded Template Library.
8https://github.com/ETLCPP/etl
9https://www.etlcpp.com
10Copyright(c) 2024 John Wellbelove
11Permission is hereby granted, free of charge, to any person obtaining a copy
12of this software and associated documentation files(the "Software"), to deal
13in the Software without restriction, including without limitation the rights
14to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
15copies of the Software, and to permit persons to whom the Software is
16furnished to do so, subject to the following conditions :
17The above copyright notice and this permission notice shall be included in all
18copies or substantial portions of the Software.
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25SOFTWARE.
26******************************************************************************/
27
28#ifndef ETL_BASE64_ENCODER_INCLUDED
29#define ETL_BASE64_ENCODER_INCLUDED
30
31#include "platform.h"
32#include "static_assert.h"
33#include "error_handler.h"
34#include "type_traits.h"
35#include "binary.h"
36#include "algorithm.h"
37#include "integral_limits.h"
38#include "iterator.h"
39#include "enum_type.h"
40#include "delegate.h"
41#include "span.h"
42
43#include "base64.h"
44
45#include <stdint.h>
46
47#if ETL_USING_STL
48 #include <iterator>
49#endif
50
51#define ETL_IS_8_BIT_INTEGRAL(Type) (etl::is_integral<typename etl::remove_cv<Type>::type>::value && \
52 (etl::integral_limits<typename etl::remove_cv<Type>::type>::bits == 8U))
53
54#define ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(Type) (etl::is_integral<typename etl::iterator_traits<typename etl::remove_cv<Type>::type>::value_type>::value && \
55 (etl::integral_limits<typename etl::iterator_traits<typename etl::remove_cv<Type>::type>::value_type>::bits == 8U))
56
57namespace etl
58{
59 //*************************************************************************
61 //*************************************************************************
62 class ibase64_encoder : public base64
63 {
64 public:
65
68
69 //*************************************************************************
71 //*************************************************************************
72 template <typename T>
73 ETL_CONSTEXPR14
74 bool encode(T value)
75 {
76 ETL_STATIC_ASSERT(ETL_IS_8_BIT_INTEGRAL(T), "Input type must be an 8 bit integral");
77
78 push_to_input_buffer(value);
79
80 if (input_buffer_is_full())
81 {
83 reset_input_buffer();
84
85 if (callback.is_valid())
86 {
87 if (output_buffer_is_full())
88 {
89 callback(span());
90 reset_output_buffer();
91 }
92 }
93 }
94
95 return !error();
96 }
97
98 //*************************************************************************
100 //*************************************************************************
101 template <typename TInputIterator>
102 ETL_CONSTEXPR14
104 {
105 ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
106
107 while (input_length-- != 0)
108 {
109 if (!encode(*input_begin++))
110 {
111 return false;
112 }
113 }
114
115 return true;
116 }
117
118 //*************************************************************************
120 //*************************************************************************
121 template <typename TInputIterator>
122 ETL_CONSTEXPR14
124 {
125 ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
126
127 while (input_begin != input_end)
128 {
129 if (!encode(*input_begin++))
130 {
131 return false;
132 }
133 }
134
135 return true;
136 }
137
138 //*************************************************************************
140 //*************************************************************************
141 template <typename TInputIterator>
142 ETL_CONSTEXPR14
147
148 //*************************************************************************
150 //*************************************************************************
151 template <typename TInputIterator>
152 ETL_CONSTEXPR14
157
158 //*************************************************************************
160 //*************************************************************************
161 ETL_CONSTEXPR14
162 bool flush()
163 {
164 // Encode any remaining input data.
165 bool success = encode_block();
166
167 reset_input_buffer();
168
169 if (success)
170 {
171 if (callback.is_valid())
172 {
173 // Send any remaining data.
174 if (size() != 0)
175 {
176 callback(span());
177 }
178
179 // Indicate this was the final block.
181
182 reset_output_buffer();
183 }
184 }
185
186 return success;
187 }
188
189 //*************************************************************************
191 //*************************************************************************
192 ETL_CONSTEXPR14
193 void restart()
194 {
195 reset_input_buffer();
196 reset_output_buffer();
197 }
198
199 //*************************************************************************
201 //*************************************************************************
202 ETL_NODISCARD
203 ETL_CONSTEXPR14
204 const char* begin() const
205 {
206 return p_output_buffer;
207 }
208
209 //*************************************************************************
211 //*************************************************************************
212 ETL_NODISCARD
213 ETL_CONSTEXPR14
214 const char* end() const
215 {
216 return p_output_buffer + output_buffer_length;
217 }
218
219 //*************************************************************************
221 //*************************************************************************
222 ETL_NODISCARD
223 ETL_CONSTEXPR14
224 const char* cbegin() const
225 {
226 return p_output_buffer;
227 }
228
229 //*************************************************************************
231 //*************************************************************************
232 ETL_NODISCARD
233 ETL_CONSTEXPR14
234 const char* cend() const
235 {
236 return p_output_buffer + output_buffer_length;
237 }
238
239 //*************************************************************************
242 //*************************************************************************
243 ETL_NODISCARD
244 ETL_CONSTEXPR14
245 size_t size() const
246 {
247 return output_buffer_length;
248 }
249
250 //*************************************************************************
252 //*************************************************************************
253 ETL_NODISCARD
254 ETL_CONSTEXPR14
255 size_t max_size() const
256 {
257 return output_buffer_max_size;
258 }
259
260 //*************************************************************************
263 //*************************************************************************
264 ETL_NODISCARD
265 ETL_CONSTEXPR14
267 {
268 return span_type(begin(), end());
269 }
270
271 //*************************************************************************
273 //*************************************************************************
274 ETL_NODISCARD
275 ETL_CONSTEXPR14
276 bool overflow() const
277 {
278 return overflowed;
279 }
280
281 //*************************************************************************
283 //*************************************************************************
284 ETL_NODISCARD
285 ETL_CONSTEXPR14
286 bool error() const
287 {
288 return overflow();
289 }
290
291 protected:
292
293 //*************************************************************************
295 //*************************************************************************
296 ETL_CONSTEXPR14
298 bool use_padding_,
299 char* p_output_buffer_,
303 , input_buffer()
304 , input_buffer_length(0)
305 , p_output_buffer(p_output_buffer_)
306 , output_buffer_length(0)
307 , output_buffer_max_size(ouput_buffer_max_size_)
309 , overflowed(false)
310 {
311 }
312
313 //*************************************************************************
315 //*************************************************************************
316 ETL_CONSTEXPR14
318 {
319 switch (input_buffer_length)
320 {
321 // Only triggered on call to flush().
322 case 1:
323 {
324 uint32_t octets = input_buffer[0];
325 octets = octets << 4; // Adjust one octet (8 bits) for two sextets worth of data (12 bits)
326
327 // Write out two sextets + optional padding.
328 push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
329 push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
330
331 if (use_padding)
332 {
333 push_to_output_buffer('=');
334 push_to_output_buffer('=');
335 }
336 break;
337 }
338
339 // Only triggered on call to flush().
340 case 2:
341 {
342 uint32_t octets = (input_buffer[0] << 8) | input_buffer[1];
343 octets <<= 2; // Adjust two octets (16 bits) for three sextets worth of data (18 bits)
344
345 // Write out three sextets + optional padding.
346 push_to_output_buffer(encoder_table[(octets >> 12) & 0x3F]);
347 push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
348 push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
349
350 if (use_padding)
351 {
352 push_to_output_buffer('=');
353 }
354 break;
355 }
356
357 // Only triggered on call to encode().
358 case 3:
359 {
360 uint32_t octets = (input_buffer[0] << 16) | (input_buffer[1] << 8) | input_buffer[2];
361
362 // Write out four sextets
363 push_to_output_buffer(encoder_table[(octets >> 18) & 0x3F]);
364 push_to_output_buffer(encoder_table[(octets >> 12) & 0x3F]);
365 push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
366 push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
367 break;
368 }
369
370 default:
371 {
372 break;
373 }
374 }
375
376 ETL_ASSERT(!overflowed, ETL_ERROR(etl::base64_overflow));
377
378 return !overflowed;
379 }
380
381 //*************************************************************************
383 //*************************************************************************
384 ETL_NODISCARD
385 static
386 ETL_CONSTEXPR14
387 size_t encoded_size(size_t input_length, bool use_padding)
388 {
389 size_t required_output_length = 0;
390
391 if (input_length == 0U)
392 {
393 return 0U;
394 }
395
396 if (use_padding)
397 {
399
400 while ((required_output_length % 4U) != 0)
401 {
403 }
404 }
405 else
406 {
407 required_output_length = input_length + (((input_length - 1U) / 3U) + 1U);
408 }
409
410 while (required_output_length % 4)
411 {
413 }
414
416 }
417
418 private:
419
420 //*************************************************************************
421 // Push to the output buffer.
422 //*************************************************************************
423 ETL_CONSTEXPR14
424 void push_to_output_buffer(char c)
425 {
426 if (output_buffer_length < output_buffer_max_size)
427 {
428 p_output_buffer[output_buffer_length++] = c;
429 }
430 else
431 {
432 overflowed = true;
433 }
434 }
435
436 //*************************************************************************
437 //
438 //*************************************************************************
439 ETL_CONSTEXPR14
440 bool output_buffer_is_full() const
441 {
442 return output_buffer_length == output_buffer_max_size;
443 }
444
445 //*************************************************************************
446 //
447 //*************************************************************************
448 ETL_CONSTEXPR14
449 bool output_buffer_is_empty() const
450 {
451 return output_buffer_length == 0;
452 }
453
454 //*************************************************************************
455 //
456 //*************************************************************************
457 ETL_CONSTEXPR14
458 void reset_output_buffer()
459 {
460 output_buffer_length = 0;
461 }
462
463 //*************************************************************************
464 // Push to the input buffer.
465 //*************************************************************************
466 template <typename T>
467 ETL_CONSTEXPR14
468 void push_to_input_buffer(T value)
469 {
470 input_buffer[input_buffer_length++] = static_cast<uint8_t>(value);
471 }
472
473 //*************************************************************************
474 //
475 //*************************************************************************
476 ETL_CONSTEXPR14
477 bool input_buffer_is_full() const
478 {
479 return input_buffer_length == 3U;
480 }
481
482 //*************************************************************************
483 //
484 //*************************************************************************
485 ETL_CONSTEXPR14
486 void reset_input_buffer()
487 {
488 input_buffer_length = 0;
489 }
490
491 uint8_t input_buffer[3];
492 size_t input_buffer_length;
493
494 char* p_output_buffer;
495 size_t output_buffer_length;
496 const size_t output_buffer_max_size;
497
498 callback_type callback;
499
500 bool overflowed;
501 };
502
503 //*************************************************************************
505 //*************************************************************************
506 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
508 {
509 public:
510
511 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
512 ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
513
514 //*************************************************************************
516 //*************************************************************************
517 ETL_CONSTEXPR14
519 : ibase64_encoder(etl::base64::character_set_1(),
520 etl::base64::Padding::No_Padding,
521 output_buffer,
524 , output_buffer()
525 {
526 }
527
528 //*************************************************************************
530 //*************************************************************************
531 ETL_CONSTEXPR14
533 : ibase64_encoder(etl::base64::character_set_1(),
534 etl::base64::Padding::No_Padding,
535 output_buffer,
537 callback_)
538 , output_buffer()
539 {
540 }
541
542 //*************************************************************************
544 //*************************************************************************
545 ETL_NODISCARD
546 static
547 ETL_CONSTEXPR14
549 {
550 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
551 }
552
553 private:
554
556 char output_buffer[Buffer_Size];
557 };
558
559 //*************************************************************************
561 //*************************************************************************
562 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
564 {
565 public:
566
567 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
568 ETL_STATIC_ASSERT(((Buffer_Size% etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
569
570 //*************************************************************************
572 //*************************************************************************
573 ETL_CONSTEXPR14
575 : ibase64_encoder(etl::base64::character_set_3(),
576 etl::base64::Padding::No_Padding,
577 output_buffer,
580 , output_buffer()
581 {
582 }
583
584 //*************************************************************************
586 //*************************************************************************
587 ETL_CONSTEXPR14
589 : ibase64_encoder(etl::base64::character_set_3(),
590 etl::base64::Padding::No_Padding,
591 output_buffer,
593 callback_)
594 , output_buffer()
595 {
596 }
597
598 //*************************************************************************
600 //*************************************************************************
601 ETL_NODISCARD
602 static
603 ETL_CONSTEXPR14
605 {
606 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
607 }
608
609 private:
610
612 char output_buffer[Buffer_Size];
613 };
614
615 //*************************************************************************
617 //*************************************************************************
618 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
620 {
621 public:
622
623 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
624 ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
625
626 //*************************************************************************
628 //*************************************************************************
629 ETL_CONSTEXPR14
631 : ibase64_encoder(etl::base64::character_set_1(),
632 etl::base64::Padding::No_Padding,
633 output_buffer,
636 , output_buffer()
637 {
638 }
639
640 //*************************************************************************
642 //*************************************************************************
643 ETL_CONSTEXPR14
645 : ibase64_encoder(etl::base64::character_set_1(),
646 etl::base64::Padding::No_Padding,
647 output_buffer,
649 callback_)
650 , output_buffer()
651 {
652 }
653
654 //*************************************************************************
656 //*************************************************************************
657 ETL_NODISCARD
658 static
659 ETL_CONSTEXPR14
661 {
662 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
663 }
664
665 private:
666
668 char output_buffer[Buffer_Size];
669 };
670
671 //*************************************************************************
673 //*************************************************************************
674 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
676 {
677 public:
678
679 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
680 ETL_STATIC_ASSERT(((Buffer_Size% etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
681
682 //*************************************************************************
684 //*************************************************************************
685 ETL_CONSTEXPR14
687 : ibase64_encoder(etl::base64::character_set_1(),
688 etl::base64::Padding::Use_Padding,
689 output_buffer,
692 , output_buffer()
693 {
694 }
695
696 //*************************************************************************
698 //*************************************************************************
699 ETL_CONSTEXPR14
701 : ibase64_encoder(etl::base64::character_set_1(),
702 etl::base64::Padding::Use_Padding,
703 output_buffer,
705 callback_)
706 , output_buffer()
707 {
708 }
709
710 //*************************************************************************
712 //*************************************************************************
713 ETL_NODISCARD
714 static
715 ETL_CONSTEXPR14
717 {
718 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
719 }
720
721 private:
722
724 char output_buffer[Buffer_Size];
725 };
726
727 //*************************************************************************
729 //*************************************************************************
730 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
732 {
733 public:
734
735 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
736 ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
737
738 //*************************************************************************
740 //*************************************************************************
741 ETL_CONSTEXPR14
743 : ibase64_encoder(etl::base64::character_set_2(),
744 etl::base64::Padding::No_Padding,
745 output_buffer,
748 , output_buffer()
749 {
750 }
751
752 //*************************************************************************
754 //*************************************************************************
755 ETL_CONSTEXPR14
757 : ibase64_encoder(etl::base64::character_set_2(),
758 etl::base64::Padding::No_Padding,
759 output_buffer,
761 callback_)
762 , output_buffer()
763 {
764 }
765
766 //*************************************************************************
768 //*************************************************************************
769 ETL_NODISCARD
770 static
771 ETL_CONSTEXPR14
773 {
774 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
775 }
776
777 private:
778
780 char output_buffer[Buffer_Size];
781 };
782
783 //*************************************************************************
785 //*************************************************************************
786 template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
788 {
789 public:
790
791 ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
792 ETL_STATIC_ASSERT(((Buffer_Size% etl::base64::Min_Encode_Buffer_Size) == 0), "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
793
794 //*************************************************************************
796 //*************************************************************************
797 ETL_CONSTEXPR14
799 : ibase64_encoder(etl::base64::character_set_2(),
800 etl::base64::Padding::Use_Padding,
801 output_buffer,
804 , output_buffer()
805 {
806 }
807
808 //*************************************************************************
810 //*************************************************************************
811 ETL_CONSTEXPR14
813 : ibase64_encoder(etl::base64::character_set_2(),
814 etl::base64::Padding::Use_Padding,
815 output_buffer,
817 callback_)
818 , output_buffer()
819 {
820 }
821
822 //*************************************************************************
824 //*************************************************************************
825 ETL_NODISCARD
826 static
827 ETL_CONSTEXPR14
829 {
830 return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
831 }
832
833 private:
834
836 char output_buffer[Buffer_Size];
837 };
838}
839
840#undef ETL_IS_TYPE_8_BIT_INTEGRAL
841#undef ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL
842
843#endif
buffer overflow exception.
Definition base64.h:71
Base64 RFC-2152 Encoder.
Definition base64_encoder.h:508
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:548
ETL_CONSTEXPR14 base64_rfc2152_encoder()
Base64 RFC-2152 constructor.
Definition base64_encoder.h:518
ETL_CONSTEXPR14 base64_rfc2152_encoder(callback_type callback_)
Base64 RFC-2152 constructor.
Definition base64_encoder.h:532
Base64 RFC-3501 Encoder.
Definition base64_encoder.h:564
ETL_CONSTEXPR14 base64_rfc3501_encoder()
Base64 RFC-3501 constructor.
Definition base64_encoder.h:574
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:604
ETL_CONSTEXPR14 base64_rfc3501_encoder(callback_type callback_)
Base64 RFC-3501 constructor.
Definition base64_encoder.h:588
Base64 RFC-4648 Encoder.
Definition base64_encoder.h:620
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:660
ETL_CONSTEXPR14 base64_rfc4648_encoder(callback_type callback_)
Base64 RFC-4648 constructor.
Definition base64_encoder.h:644
ETL_CONSTEXPR14 base64_rfc4648_encoder()
Base64 RFC-4648 constructor.
Definition base64_encoder.h:630
Base64 RFC-4648-Padding Encoder.
Definition base64_encoder.h:676
ETL_CONSTEXPR14 base64_rfc4648_padding_encoder()
Base64 RFC-4648-Padding constructor.
Definition base64_encoder.h:686
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:716
ETL_CONSTEXPR14 base64_rfc4648_padding_encoder(callback_type callback_)
Base64 RFC-4648-Padding constructor.
Definition base64_encoder.h:700
Base64 RFC-4648-URL Encoder.
Definition base64_encoder.h:732
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:772
ETL_CONSTEXPR14 base64_rfc4648_url_encoder()
Base64 RFC-4648-URL constructor.
Definition base64_encoder.h:742
ETL_CONSTEXPR14 base64_rfc4648_url_encoder(callback_type callback_)
Base64 RFC-4648-URL constructor.
Definition base64_encoder.h:756
Base64 RFC-4648-URL_Padding Encoder.
Definition base64_encoder.h:788
ETL_CONSTEXPR14 base64_rfc4648_url_padding_encoder()
Base64 RFC-4648-URL constructor.
Definition base64_encoder.h:798
ETL_CONSTEXPR14 base64_rfc4648_url_padding_encoder(callback_type callback_)
Base64 RFC-4648-URL constructor.
Definition base64_encoder.h:812
static ETL_NODISCARD ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
Calculate the required output encode buffer size.
Definition base64_encoder.h:828
Common Base64 definitions.
Definition base64.h:110
Definition callback.h:45
Declaration.
Definition delegate_cpp03.h:191
Base64 Encoder.
Definition base64_encoder.h:63
ETL_NODISCARD ETL_CONSTEXPR14 span_type span() const
Definition base64_encoder.h:266
ETL_NODISCARD ETL_CONSTEXPR14 const char * cend() const
This only returns a useful value if a callback has not been set or called.
Definition base64_encoder.h:234
ETL_CONSTEXPR14 bool encode(TInputIterator input_begin, size_t input_length)
Encode to Base64.
Definition base64_encoder.h:103
ETL_NODISCARD ETL_CONSTEXPR14 size_t size() const
Definition base64_encoder.h:245
ETL_CONSTEXPR14 bool encode_block()
Encode one block of data.
Definition base64_encoder.h:317
ETL_CONSTEXPR14 void restart()
Reset the encoder.
Definition base64_encoder.h:193
ETL_NODISCARD ETL_CONSTEXPR14 bool overflow() const
Returns true if the output buffer has overflowed.
Definition base64_encoder.h:276
ETL_CONSTEXPR14 bool encode(T value)
Encode to Base64.
Definition base64_encoder.h:74
ETL_NODISCARD ETL_CONSTEXPR14 size_t max_size() const
Returns the maximum size of the output buffer.
Definition base64_encoder.h:255
ETL_NODISCARD ETL_CONSTEXPR14 const char * end() const
This only returns a useful value if a callback has not been set or called.
Definition base64_encoder.h:214
ETL_NODISCARD ETL_CONSTEXPR14 bool error() const
Returns true if an error was detected.
Definition base64_encoder.h:286
ETL_CONSTEXPR14 bool encode(TInputIterator input_begin, TInputIterator input_end)
Encode to Base64.
Definition base64_encoder.h:123
ETL_CONSTEXPR14 ibase64_encoder(const char *encoder_table_, bool use_padding_, char *p_output_buffer_, size_t ouput_buffer_max_size_, callback_type callback_)
Constructor.
Definition base64_encoder.h:297
ETL_CONSTEXPR14 bool flush()
Flush any remaining data to the output.
Definition base64_encoder.h:162
ETL_NODISCARD ETL_CONSTEXPR14 const char * begin() const
Returns the beginning of the output buffer.
Definition base64_encoder.h:204
ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, TInputIterator input_end)
Encode to Base64.
Definition base64_encoder.h:153
ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, size_t input_length)
Encode to Base64.
Definition base64_encoder.h:143
ETL_NODISCARD ETL_CONSTEXPR14 const char * cbegin() const
Returns the beginning of the output buffer.
Definition base64_encoder.h:224
static ETL_NODISCARD ETL_CONSTEXPR14 size_t encoded_size(size_t input_length, bool use_padding)
Calculates the minimum buffer size required to encode to Base64.
Definition base64_encoder.h:387
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
bitset_ext
Definition absolute.h:38
Definition base64.h:140
pair holds two objects of arbitrary type
Definition utility.h:164