Bytes.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Misc/BitOp.h"
#include "Honey/Misc/Range.h"
#include "Honey/Memory/Buffer.h"

namespace honey
{

typedef uint8 byte;

constexpr byte operator"" _b(unsigned long long int i)  { return static_cast<byte>(i); }
constexpr byte operator"" _b(char c)                    { return static_cast<byte>(c); }

typedef Buffer<byte> ByteBuf;
typedef Buffer<const byte> ByteBufConst;

template<szt N> struct ByteArray;

class Bytes : public vector<byte>
{
public:
    using vector::vector;
    
    Bytes() = default;
    Bytes(ByteBufConst bs)                              : vector(bs.begin(), bs.end()) {}
    template<szt N>
    Bytes(const ByteArray<N>& bs)                       : vector(bs.begin(), bs.end()) {}
    
    friend ostream& operator<<(ostream& os, const Bytes& val);
    friend istream& operator>>(istream& is, Bytes& val);
};

inline Bytes operator"" _b(const char* str, szt len)    { return Bytes(str, str+len); }

inline ostream& operator<<(ostream& os, ByteBufConst val)   { os << Bytes(val); return os; }

template<class Int>
typename std::enable_if<std::is_integral<Int>::value, Bytes>::type
    toBytes(Int val, Endian order = Endian::big)
{
    typedef typename std::make_unsigned<Int>::type Unsigned;
    Bytes bs(sizeof(Int));
    switch (order)
    {
    case Endian::little:
        BitOp::toPartsLittle(static_cast<Unsigned>(val), bs.data());
        break;
    case Endian::big:
        BitOp::toPartsBig(static_cast<Unsigned>(val), bs.data());
        break;
    }
    return bs;
}

template<class Int>
typename std::enable_if<std::is_integral<Int>::value, Int>::type
    fromBytes(const Bytes& bs, Endian order = Endian::big)
{
    typedef typename std::make_unsigned<Int>::type Unsigned;
    switch (order)
    {
    case Endian::little:
        return static_cast<Int>(BitOp::fromPartsLittle<Unsigned>(bs.data()));
    case Endian::big:
        return static_cast<Int>(BitOp::fromPartsBig<Unsigned>(bs.data()));
    }
}

template<szt N>
struct ByteArray : array<byte, N>
{
    typedef array<byte, N> Super;
    
    ByteArray() = default;
    template<class... Bytes>
    ByteArray(byte b, Bytes&&... bs)    : Super{b, forward<Bytes>(bs)...} {}
    ByteArray(ByteBufConst bs)          { assert(bs.size() == this->size()); std::copy(bs.begin(), bs.end(), this->begin()); }
    ByteArray(const Bytes& bs)          { assert(bs.size() == this->size()); std::copy(bs.begin(), bs.end(), this->begin()); }
    
    friend ostream& operator<<(ostream& os, const ByteArray& val)   { os << Bytes(val); return os; }
    friend istream& operator>>(istream& is, ByteArray& val)         { Bytes bs; is >> bs; val = bs; return is; }
};

}