Base64 Encoder and Boost

typedef base64_from_binary<transform_width<decltype(std::begin(data)),6,8>> base64Iterator

template<class _MyIt, class Elem = typename _MyIt::value_type> class zero_pad_iterator 
	: public boost::iterator_facade<zero_pad_iterator<_MyIt,Elem>,Elem,std::input_iterator_tag,Elem>
{
	friend class boost::iterator_core_access;
	Elem dereference() const {
		if (!_valid) return Elem(); // return "zero" from invalid iterators
		return _current_value; 
	}
	bool equal(const zero_pad_iterator & rhs) const { 
		return _valid == rhs._valid && (_valid ? _source == rhs._source 
			: true ); // two invalid operators are always the same
	}

	void increment(){
		if (!_valid)	return; // don't move past the end
		_valid = ++_source != _end;
		if (_valid)	_current_value = *_source;
	}

	_MyIt _source, _end;
	Elem _current_value;
	bool _valid;
public:
	template<class _Cont> // convenience constructor
	zero_pad_iterator(const _Cont& container) : _source(std::begin(container)), _end(std::end(container)), _current_value(*_source), _valid(true) {}
        // constructor that allows detection of when the source has met the end
	zero_pad_iterator(const _MyIt start, const _MyIt end) : _source(start), _end(end), _current_value(*_source), _valid(start != end) {}
	// helper constructor for making easy ends (invalid iterators are equal to iterators that have reached the end)
	zero_pad_iterator() : _valid(false) {}
};

std::string encode(const std::vector<unsigned char>& data) {
	typedef zero_pad_iterator<decltype(data.begin())> padIt;
	typedef b64::base64_from_binary<b64::transform_width<padIt, 6, 8>> base64Iterator;
	auto out = std::string(base64Iterator(padIt(data)), base64Iterator(padIt()));
	return out + std::string(out.length() % 4, '=');
}

std::vector<unsigned char> decode(const std::string& data) {
	// filter out base64 padding
	auto predicate = [](char c) { return c != '='; };
	typedef boost::filter_iterator<decltype(predicate), decltype(std::begin(data))> filterbase64; 
	filterbase64 begin(predicate,std::begin(data), std::end(data)), 
	             end(predicate, std::end(data), std::end(data)); 

	// create transformer and use it
	typedef b64::transform_width<b64::binary_from_base64<filterbase64>, 8, 6> base64Iterator;
	return std::vector<unsigned char>(base64Iterator(begin), base64Iterator(end));
}

static const std::string encode_base64(byte_sequence_t & buffer)
{
    // Warning : Boost implementation of Base64 is incomplete and missing padding '=' insertion
    // http://lists.boost.org/Archives/boost/2008/07/139814.php
    // Additionally boost have bug when processing sequence which size % 3 != 0
    // we can workaround this by adding extra bytes to the end of it
    std::size_t sequence_len = buffer.size(); // original sequence size
    buffer.resize(sequence_len + sequence_len % 3); // to make boost happy

    using namespace boost::archive::iterators;
    typedef byte_sequence_t::const_iterator itr_type;
    typedef transform_width<itr_type, 6, 8> take_6_bits; // retrieves 6 bit integers from a sequence of 8 bit bytes
    typedef base64_from_binary<take_6_bits> to_base64;   // converts binary values at base64 characters

    std::string base64_encoded(to_base64(buffer.begin()), to_base64(buffer.begin() + sequence_len));
    // here we calculating padding sequence at the end of the sequence:
    // we must add '=' if there is only 2 remaining bytes or '==' if 1
    const std::size_t padding_chars_count = ( 3 - sequence_len % 3 ) % 3;
    return base64_encoded.append(padding_chars_count, '=');
}