Base64 format specifiers

Typedefs
using	c4::fmt::const_base64_wrapper = detail::base64_wrapper_<cbyte>
	a tag type to mark a payload to be encoded as base64
using	c4::fmt::base64_wrapper = detail::base64_wrapper_<byte>
	a tag type to mark a payload to be decoded as base64
template<class Container>
using	c4::fmt::const_base64_container_wrapper = detail::base64_container_wrapper_<const Container, cbyte>
	a tag type to mark a payload as base64-encoded
template<class Container>
using	c4::fmt::base64_container_wrapper = detail::base64_container_wrapper_<Container, byte>
	a tag type to mark a payload to be encoded as base64

Functions
const_base64_wrapper	c4::fmt::cbase64 (csubstr s, size_t *reqsize=nullptr)
	a tag function to mark a csubstr payload to be encoded in base64 format
const_base64_wrapper	c4::fmt::base64 (csubstr s, size_t *reqsize=nullptr)
	a tag function to mark a csubstr payload to be encoded in base64 format
base64_wrapper	c4::fmt::base64 (substr s, size_t *reqsize=nullptr)
	a tag function to mark a variable to be decoded from base64
template<class T>
const_base64_wrapper	c4::fmt::cbase64 (T const *arg, size_t sz, size_t *reqsize=nullptr)
	a tag function to mark a payload to be encoded in base64 format
template<class T>
auto	c4::fmt::base64 (T *arg, size_t sz, size_t *reqsize=nullptr) -> typename std::conditional< std::is_const< typename std::remove_reference< typename std::remove_pointer< T >::type >::type >::value, const_base64_wrapper, base64_wrapper >::type
	a tag function to mark a payload to be encoded in base64 format
template<class T>
auto	c4::fmt::cbase64 (T const &arg, size_t *reqsize=nullptr) -> typename std::enable_if< ! detail::has_resize< T >::value, const_base64_wrapper >::type
	a tag function to mark a payload to be encoded in base64 format
template<class T>
auto	c4::fmt::base64 (T &arg, size_t *reqsize=nullptr) -> typename std::enable_if< ! detail::has_resize< T >::value, typename std::conditional< std::is_const< typename std::remove_reference< typename std::remove_pointer< T >::type >::type >::value, const_base64_wrapper, base64_wrapper >::type >::type
	a tag function to mark a payload to be encoded or decoded in base64 format
template<class T>
auto	c4::fmt::cbase64 (T const &arg, size_t *reqsize=nullptr) -> typename std::enable_if< detail::has_resize< T >::value, const_base64_container_wrapper< T > >::type
	a tag function to mark a container (payload with a .resize() method) to be encoded in base64 format.
template<class T>
auto	c4::fmt::base64 (T &arg, size_t *reqsize=nullptr) -> typename std::enable_if< detail::has_resize< T >::value, typename std::conditional< std::is_const< typename std::remove_reference< typename std::remove_pointer< T >::type >::type >::value, const_base64_container_wrapper< T >, base64_container_wrapper< T > >::type >::type
	a tag function to mark a container (payload with a .resize() method) to be encoded or decoded in base64 format.

Detailed Description

// given these variables:
T var = {};
T &ref = var;
std::vector<T> vec = ...;
substr buf = ...;
 
// there are different approaches to encode/decode base64:
size_t numchars = to_chars(buf, base64(var)); // encode var as base64
size_t numchars = to_chars(buf, base64(ref)); // same as above
size_t numchars = to_chars(buf, base64(&var, 1)); // same as above
size_t numchars = to_chars(buf, base64(vec.data(), vec.size())); // for the container, but same call form as above
size_t numchars = to_chars(buf, base64(vec)); // same effect as prev call
 
// using cbase64() (the `c` prefix is for const) is equivalent
// for encoding, but quicker to compile:
size_t numchars = to_chars(buf, cbase64(var)); // encode var as base64
size_t numchars = to_chars(buf, cbase64(ref)); // same as above
size_t numchars = to_chars(buf, cbase64(&var, 1)); // same as above
size_t numchars = to_chars(buf, cbase64(vec.data(), vec.size())); // for the container, but same call as above
size_t numchars = to_chars(buf, cbase64(vec)); // same effect as prev call
 
// to decode:
csubstr buf = ...;
size_t reqbytes = 0; // number of bytes of decoded data
bool ok = from_chars(buf, base64(var)); // decode base64 to var
bool ok = from_chars(buf, base64(var, &reqbytes)); // same. reqbytes will be sizeof(var)
bool ok = from_chars(buf, base64(ref)); // same as above
bool ok = from_chars(buf, base64(ref, &reqbytes)); // same. reqbytes will be sizeof(var)
bool ok = from_chars(buf, base64(&var, 1, &reqbytes)); // same
bool ok = from_chars(buf, base64(vec.data(), vec.size(), &reqbytes)); // for the container, but same call as above
bool ok = from_chars(buf, base64(vec, &reqbytes)); // same effect as prev call

Typedef Documentation

const_base64_wrapper

using c4::fmt::const_base64_wrapper = detail::base64_wrapper_<cbyte>

a tag type to mark a payload to be encoded as base64

Definition at line 103 of file format_base64.hpp.

base64_wrapper

using c4::fmt::base64_wrapper = detail::base64_wrapper_<byte>

a tag type to mark a payload to be decoded as base64

Definition at line 105 of file format_base64.hpp.

const_base64_container_wrapper

template<class Container>

using c4::fmt::const_base64_container_wrapper = detail::base64_container_wrapper_<const Container, cbyte>

a tag type to mark a payload as base64-encoded

Definition at line 110 of file format_base64.hpp.

base64_container_wrapper

template<class Container>

using c4::fmt::base64_container_wrapper = detail::base64_container_wrapper_<Container, byte>

a tag type to mark a payload to be encoded as base64

Definition at line 113 of file format_base64.hpp.

Function Documentation

cbase64() [1/4]

const_base64_wrapper c4::fmt::cbase64 ( csubstr s, size_t * reqsize = nullptr )

inline

a tag function to mark a csubstr payload to be encoded in base64 format

Definition at line 117 of file format_base64.hpp.

{
    return const_base64_wrapper(cblob(s.str, s.len), reqsize);
}

base64() [1/5]

const_base64_wrapper c4::fmt::base64 ( csubstr s, size_t * reqsize = nullptr )

inline

a tag function to mark a csubstr payload to be encoded in base64 format

Definition at line 122 of file format_base64.hpp.

{
    return const_base64_wrapper(cblob(s.str, s.len), reqsize);
}

Referenced by sample_base64().

base64() [2/5]

base64_wrapper c4::fmt::base64 ( substr s, size_t * reqsize = nullptr )

inline

a tag function to mark a variable to be decoded from base64

Definition at line 127 of file format_base64.hpp.

{
    return base64_wrapper(blob(s.str, s.len), reqsize);
}

cbase64() [2/4]

template<class T>

const_base64_wrapper c4::fmt::cbase64 ( T const * arg, size_t sz, size_t * reqsize = nullptr )

inline

a tag function to mark a payload to be encoded in base64 format

Definition at line 135 of file format_base64.hpp.

{
    return const_base64_wrapper(cblob(arg, sz), reqsize);
}

base64() [3/5]

template<class T>

auto c4::fmt::base64 ( T * arg, size_t sz, size_t * reqsize = nullptr )->typenamestd::conditional< std::is_const< typenamestd::remove_reference< typenamestd::remove_pointer< T >::type >::type >::value, const_base64_wrapper, base64_wrapper >::type

inline

a tag function to mark a payload to be encoded in base64 format

Definition at line 141 of file format_base64.hpp.

{
    using U = typename std::remove_reference<typename std::remove_pointer<T>::type>::type;
    using ret_type = typename std::conditional<std::is_const<U>::value,
                                               const_base64_wrapper,
                                               base64_wrapper>::type;
    using blob_type = typename std::conditional<std::is_const<U>::value,
                                               cblob,
                                               blob>::type;
    return ret_type(blob_type(arg, sz), reqsize);
}

cbase64() [3/4]

template<class T>

auto c4::fmt::cbase64 ( T const & arg, size_t * reqsize = nullptr )->typenamestd::enable_if<!detail::has_resize< T >::value, const_base64_wrapper >::type

inline

a tag function to mark a payload to be encoded in base64 format

Definition at line 159 of file format_base64.hpp.

{
    return const_base64_wrapper(cblob(arg), reqsize);
}

base64() [4/5]

template<class T>

auto c4::fmt::base64 ( T & arg, size_t * reqsize = nullptr )->typenamestd::enable_if<!detail::has_resize< T >::value, typenamestd::conditional< std::is_const< typenamestd::remove_reference< typenamestd::remove_pointer< T >::type >::type >::value, const_base64_wrapper, base64_wrapper >::type >::type

inline

a tag function to mark a payload to be encoded or decoded in base64 format

Definition at line 166 of file format_base64.hpp.

{
    using U = typename std::remove_reference<typename std::remove_pointer<T>::type>::type;
    using ret_type = typename std::conditional<std::is_const<U>::value,
                                               const_base64_wrapper,
                                               base64_wrapper>::type;
    using blob_type = typename std::conditional<std::is_const<U>::value,
                                               cblob,
                                               blob>::type;
    return ret_type(blob_type(arg), reqsize);
}

cbase64() [4/4]

template<class T>

auto c4::fmt::cbase64 ( T const & arg, size_t * reqsize = nullptr )->typenamestd::enable_if< detail::has_resize< T >::value, const_base64_container_wrapper< T > >::type

inline

a tag function to mark a container (payload with a .resize() method) to be encoded in base64 format.

Definition at line 185 of file format_base64.hpp.

{
    return const_base64_container_wrapper<T>(&arg, reqsize);
}

base64() [5/5]

template<class T>

auto c4::fmt::base64 ( T & arg, size_t * reqsize = nullptr )->typenamestd::enable_if< detail::has_resize< T >::value, typenamestd::conditional< std::is_const< typenamestd::remove_reference< typenamestd::remove_pointer< T >::type >::type >::value, const_base64_container_wrapper< T >, base64_container_wrapper< T > >::type >::type

inline

a tag function to mark a container (payload with a .resize() method) to be encoded or decoded in base64 format.

Subsequently when decoding, from_chars() will resize the container to fit the decoded data.

Definition at line 195 of file format_base64.hpp.

{
    using ret_type = typename std::conditional<std::is_const<typename std::remove_reference<typename std::remove_pointer<T>::type>::type>::value,
                                               const_base64_container_wrapper<T>,
                                               base64_container_wrapper<T>>::type;
    return ret_type(&arg, reqsize);
}