static char const encoding[] =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

"+/";

return encoding[static_cast<unsigned int>(value)];

state() : triplet_index(0), last_encoded_value(0) {}

state(state<Value> const& source)

: triplet_index(source.triplet_index),

last_encoded_value(source.last_encoded_value) {}

bool empty() const { return triplet_index == 0; }

void clear() {

// indicate that no rest has been left in the last encoded value

// and no padding is needed for the encoded output

triplet_index = 0;

// the last encoded value, which may have been left from the last

// encoding step, must be zeroed too; it is important before the

// next encoding begins, because it works as a cyclic buffer and

// must start empty - with zero

last_encoded_value = 0;

}

protected:

// number of the octet in the incomplete quantum, which has been

// processed the last time; 0 means that the previous quantum was

// complete 3 octets, 1 that just one octet was avalable and 2 that

// two octets were available

unsigned char triplet_index;

// the value made of the previously shifted and or-ed octets which

// was not completely split to 6-bit codes, because the last quantum

// did not stop on the boundary of three octets

Value last_encoded_value;

// encoding of an input chunk needs to read and update the state

template <typename InputIterator, typename OutputIterator, typename State>

friend OutputIterator encode(InputIterator begin, InputIterator end,

OutputIterator output, State& rest);

// finishing the encoding needs to read and clear the state

template <typename OutputIterator, typename State>

friend OutputIterator encode_rest(OutputIterator output, State& rest);

OutputIterator output, State& rest) {

typedef typename iterator_value<InputIterator>::type value_type;

// continue with the rest of the last chunk - 2 or 4 bits which

// are already shifted to the left and need to be or-ed with the

// continuing data up to the target 6 bits

value_type encoded_value = rest.last_encoded_value;

// if the previous chunk stopped at encoding the first (1) or the

// second

// (2) octet of the three-byte quantum, jump to the right place,

// otherwise start the loop with an empty encoded value buffer

switch (rest.triplet_index) {

// this loop processes the input sequence of bit-octets by bits,

// shifting the current_value (used as a cyclic buffer) left and

// or-ing next bits there, while pulling the bit-sextets from the

// high word of the current_value

for (value_type current_value;;) {

case 0:

// if the input sequence is empty or reached its end at the

// 3-byte boundary, finish with an empty encoding state

if (begin == end) {

rest.triplet_index = 0;

// the last encoded value is not interesting - it would not

// be used, because processing of the next chunk will start

// at the 3-byte boundary

rest.last_encoded_value = 0;

return output;

}

// read the first octet from the current triplet

current_value = *begin++;

// use just the upper 6 bits to encode it to the target alphabet

encoded_value = (current_value & 0xfc) >> 2;

*output++ = detail::encode_value(encoded_value);

// shift the remaining two bits up to make place for the upoming

// part of the next octet

encoded_value = (current_value & 0x03) << 4;

case 1:

// if the input sequence reached its end after the first octet

// from the quantum triplet, store the encoding state and finish

if (begin == end) {

rest.triplet_index = 1;

rest.last_encoded_value = encoded_value;

return output;

}

// read the second first octet from the current triplet

current_value = *begin++;

// combine the upper four bits (as the lower part) with the

// previous two bits to encode it to the target alphabet

encoded_value |= (current_value & 0xf0) >> 4;

*output++ = detail::encode_value(encoded_value);

// shift the remaining four bits up to make place for the

// upoming

// part of the next octet

encoded_value = (current_value & 0x0f) << 2;

case 2:

// if the input sequence reached its end after the second octet

// from the quantum triplet, store the encoding state and finish

if (begin == end) {

rest.triplet_index = 2;

rest.last_encoded_value = encoded_value;

return output;

}

// read the third octet from the current triplet

current_value = *begin++;

// combine the upper two bits (as the lower part) with the

// previous four bits to encode it to the target alphabet

encoded_value |= (current_value & 0xc0) >> 6;

*output++ = detail::encode_value(encoded_value);

// encode the remaining 6 bits to the target alphabet

encoded_value = current_value & 0x3f;

*output++ = detail::encode_value(encoded_value);

}

}

return output;

if (!rest.empty()) {

// process the last part of the trailing octet (either 4 or 2 bits)

// as if the input was padded with zeros - without or-ing the next

// input value to it; it has been already shifted to the left

*output++ = detail::encode_value(rest.last_encoded_value);

// at least one padding '=' will be always needed - at least two

// bits are missing in the finally encoded 6-bit value

*output++ = '=';

// if the last octet was the first in the triplet (the index was

// 1), four bits are missing in the finally encoded 6-bit value;

// another '=' character is needed for the another two bits

if (rest.triplet_index < 2) *output++ = '=';

// clear the state all the time to make sure that another call to

// the encode_rest would not cause damage; the last encoded value,

// which may have been left there, must be zeroed too; it is

// important before the next encoding begins, because it works as

// a cyclic buffer and must start empty - with zero

rest.clear();

}

return output;

OutputIterator output) {

state<typename iterator_value<InputIterator>::type> rest;

output = encode(begin, end, output, rest);

return encode_rest(output, rest);

std::basic_string<Char> result;

encode(value, std::back_inserter(result));

return result;

std::basic_string<Char> result;

encode(value, std::back_inserter(result));

return result;