terse Namespace Reference

Namespaces
namespace	impl
namespace	traits

Classes
struct	Anchor
class	Archive
struct	ArchiveOffset
struct	ArchiveSize
class	BinaryInputArchive
class	BinaryOutputArchive
class	Blob
struct	ByteSwapper
struct	ByteSwapper< Endianness::Big >
struct	ByteSwapper< Endianness::Little >
class	CharInputStreamBuf
class	CharOutputStreamBuf
class	DynArray
	Resizable array-like abstraction for trivial-types only. More...
class	ExtendableBinaryInputArchive
class	ExtendableBinaryOutputArchive
class	ExtendableJSONInputArchive
class	ExtendableJSONOutputArchive
class	JSONInputArchive
class	JSONOutputArchive
struct	Transparent
class	VirtualSerializerProxy

Typedefs
template<Endianness EByteOrder>
using	SwapTo = ByteSwapper< EByteOrder >
template<Endianness EByteOrder>
using	SwapFrom = ByteSwapper< EByteOrder >

Enumerations
enum class	Endianness { Little , Big , Network = Big }

Functions
template<typename TOffset >
ArchiveOffset< TOffset >::Proxy	proxy (ArchiveOffset< TOffset > &offset)
template<typename TSize , typename TOffset >
ArchiveSize< TSize, TOffset >::Proxy	proxy (ArchiveSize< TSize, TOffset > &size, Anchor< TOffset > &base)
template<typename T >
Transparent< T >	transparent (T &data)
constexpr std::size_t	base64encode (std::size_t size)
std::size_t	base64encode (char *destination, const char *source, std::size_t size)
constexpr std::size_t	base64decode (std::size_t size)
std::size_t	base64decode (char *destination, const char *source, std::size_t size)
template<typename T >
void	networkToHost (T &value)
template<typename T >
void	networkToHost128 (T *values)
template<typename T >
void	hostToNetwork (T &value)
template<typename T >
void	hostToNetwork128 (T *values)

Variables
static const char *	alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Typedef Documentation

SwapFrom

template<Endianness EByteOrder>

using terse::SwapFrom = typedef ByteSwapper<EByteOrder>

SwapTo

template<Endianness EByteOrder>

using terse::SwapTo = typedef ByteSwapper<EByteOrder>

Enumeration Type Documentation

Endianness

enum class terse::Endianness

strong

Enumerator
Little
Big
Network

                      {
    Little,
    Big,
    Network = Big
};

Function Documentation

base64decode() [1/2]

std::size_t terse::base64decode ( char *  destination, const char *  source, std::size_t  size  )

inline

                                                                                     {
    char* out = destination;
 
    int buffer[256];
    std::fill_n(buffer, 256, -1);
    for (int i = 0; i < 64; i++) {
        buffer[static_cast<std::size_t>(alphabet[i])] = i;
    }
 
    int val = 0;
    int valb = -8;
 
    for (std::size_t pos = {}; pos < size; ++pos) {
        const auto c = static_cast<unsigned char>(source[pos]);
        if (buffer[c] == -1) {
            break;
        }
        val = (val << 6) + buffer[c];
        valb += 6;
        if (valb >= 0) {
            *out++ = static_cast<char>((val >> valb) & 0xFF);
            valb -= 8;
        }
    }
 
    // Length of base64decoded data
    return static_cast<std::size_t>(out - destination);
}

References alphabet.

base64decode() [2/2]

constexpr std::size_t terse::base64decode ( std::size_t  size )

constexpr

                                                 {
    return (size * 3ul) / 4ul;
}

Referenced by terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process().

base64encode() [1/2]

std::size_t terse::base64encode ( char *  destination, const char *  source, std::size_t  size  )

inline

                                                                                     {
    char* out = destination;
 
    int val = 0;
    int valb = -6;
 
    for (std::size_t pos = {}; pos < size; ++pos) {
        const auto c = static_cast<unsigned char>(source[pos]);
        val = (val << 8) + c;
        valb += 8;
        while (valb >= 0) {
            *out++ = (alphabet[(val >> valb) & 0x3F]);
            valb -= 6;
        }
    }
 
    if (valb > -6) {
        *out++ = alphabet[((val << 8) >> (valb + 8)) & 0x3F];
    }
 
    while (static_cast<std::size_t>(out - destination) % 4) {
        *out++ = '=';
    }
 
    // Length of base64encoded data
    return static_cast<std::size_t>(out - destination);
}

References alphabet.

base64encode() [2/2]

constexpr std::size_t terse::base64encode ( std::size_t  size )

constexpr

                                                 {
    return ((4ul * size / 3ul) + 3ul) & ~3ul;
}

Referenced by terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process(), and terse::ExtendableJSONOutputArchive< TExtender, TStream, TSize, TOffset >::process().

hostToNetwork()

template<typename T >

void terse::hostToNetwork ( T &  value )

inline

                                    {
    SwapTo<Endianness::Network>::swap(value);
}

hostToNetwork128()

template<typename T >

void terse::hostToNetwork128 ( T *  values )

inline

                                        {
    SwapTo<Endianness::Network>::swap(values);
}

networkToHost()

template<typename T >

void terse::networkToHost ( T &  value )

inline

                                    {
    SwapFrom<Endianness::Network>::swap(value);
}

networkToHost128()

template<typename T >

void terse::networkToHost128 ( T *  values )

inline

                                        {
    SwapFrom<Endianness::Network>::swap(values);
}

proxy() [1/2]

template<typename TOffset >

ArchiveOffset< TOffset >::Proxy terse::proxy

(

ArchiveOffset< TOffset > &

offset

)

                                                                           {
    return typename ArchiveOffset<TOffset>::Proxy{offset};
}

proxy() [2/2]

template<typename TSize , typename TOffset >

ArchiveSize< TSize, TOffset >::Proxy terse::proxy	(	ArchiveSize< TSize, TOffset > &	size,
		Anchor< TOffset > &	base
	)

                                                                                                          {
    return typename ArchiveSize<TSize, TOffset>::Proxy{size, base};
}

transparent()

template<typename T >

Transparent< T > terse::transparent

(

T &

data

)

                                    {
    return Transparent<T>{data};
}

Referenced by terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::popTransparency(), terse::ExtendableJSONOutputArchive< TExtender, TStream, TSize, TOffset >::popTransparency(), terse::ExtendableJSONOutputArchive< TExtender, TStream, TSize, TOffset >::process(), and terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process().

Variable Documentation

alphabet

const char* terse::alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

static

Referenced by base64decode(), and base64encode().