ByteVector.hpp

Go to the documentation of this file.

#ifndef BYTE_VECTOR_HPP
#define BYTE_VECTOR_HPP

#include <cstdint>
#include <limits>
#include <memory>
#include <type_traits>
#include <vector>
#include "Value.hpp"

namespace msp {

struct Packable;

class ByteVector : public std::vector<uint8_t> {
public:
    ByteVector() : offset(0) {}

    template <typename T1>
    ByteVector(T1 arg1) : std::vector<uint8_t>(arg1), offset(0) {}

    template <typename T1, typename T2>
    ByteVector(T1 arg1, T2 arg2) :
        std::vector<uint8_t>(arg1, arg2),
        offset(0) {}

    template <typename T, typename std::enable_if<std::is_integral<T>::value,
                                                  T>::type* = nullptr>
    bool pack(const T& val) {
        // little endian packing
        for(size_t i(0); i < sizeof(val); ++i) {
            this->push_back(val >> (i * 8) & 0xFF);
        }
        return true;
    }

    template <typename T,
              typename std::enable_if<std::is_floating_point<T>::value,
                                      T>::type* = nullptr>
    bool pack(const T& val) {
        ByteVector b(sizeof(val));
        reinterpret_cast<T&>(b.front()) = val;
        return this->pack(b);
    }

    template <typename encoding_T, typename T1, typename T2,
              typename std::enable_if<std::is_arithmetic<T1>::value,
                                      T1>::type* = nullptr,
              typename std::enable_if<std::is_arithmetic<T2>::value,
                                      T2>::type* = nullptr>
    bool pack(const T1 val, const T2 scale, const T2 offset = 0) {
        const T1 tmp = (val + offset) * scale;
        if(tmp <= std::numeric_limits<encoding_T>::min())
            return pack(std::numeric_limits<encoding_T>::min());
        else if(tmp >= std::numeric_limits<encoding_T>::max())
            return pack(std::numeric_limits<encoding_T>::max());
        return pack(static_cast<encoding_T>(tmp));
    }

    bool pack(const std::string& val,
              size_t max_len = std::numeric_limits<size_t>::max()) {
        size_t count = 0;
        for(auto c : val) {
            this->push_back(c);
            if(++count == max_len) break;
        }
        // TODO: validate that this null termination is the right thing to do in
        // all cases definitly correct in tested cases
        this->push_back(0);
        return true;
    }

    bool pack(const ByteVector& data,
              size_t max_len = std::numeric_limits<size_t>::max()) {
        size_t count = 0;
        for(auto c : data) {
            this->push_back(c);
            if(++count == max_len) break;
        }
        return true;
    }

    template <typename T,
              typename std::enable_if<std::is_base_of<Packable, T>::value,
                                      T>::type* = nullptr>
    bool pack(const T& val) {
        return val.pack_into(*this);
    }

    template <typename encoding_T, typename T1, typename T2,
              typename std::enable_if<std::is_arithmetic<T1>::value,
                                      T1>::type* = nullptr,
              typename std::enable_if<std::is_arithmetic<T2>::value,
                                      T2>::type* = nullptr>
    bool pack(const Value<T1> val, const T2 scale, const T2 offset = 0) {
        if(!val.set()) return false;
        return pack<encoding_T>(val(), scale, offset);
    }

    bool pack(const Value<ByteVector>& val,
              size_t max_len = std::numeric_limits<size_t>::max()) {
        if(!val.set()) return false;
        return pack(val(), max_len);
    }

    bool pack(const Value<std::string>& val,
              size_t max_len = std::numeric_limits<size_t>::max()) {
        if(!val.set()) return false;
        return pack(val(), max_len);
    }

    template <class T> bool pack(const Value<T>& val) {
        if(!val.set()) return false;
        return pack(val());
    }

    template <typename T, typename std::enable_if<std::is_integral<T>::value,
                                                  T>::type* = nullptr>
    bool unpack(T& val) const {
        if(unpacking_remaining() < sizeof(val)) return false;
        val = 0;
        for(size_t i(0); i < sizeof(val); ++i) {
            val |= (*this)[offset++] << (8 * i);
        }
        return true;
    }

    bool unpack(bool& val) const {
        if(unpacking_remaining() < 1) return false;
        val = (*this)[offset++];
        return true;
    }

    template <typename T,
              typename std::enable_if<std::is_floating_point<T>::value,
                                      T>::type* = nullptr>
    bool unpack(T& val) const {
        if(unpacking_remaining() < sizeof(val)) return false;
        val = reinterpret_cast<const T&>((*this)[offset]);
        offset += sizeof(val);
        return true;
    }

    bool unpack(std::string& val,
                size_t count = std::numeric_limits<size_t>::max()) const {
        if(count == std::numeric_limits<size_t>::max())
            count = unpacking_remaining();
        if(count > unpacking_remaining()) return false;
        bool rc = true;
        val.clear();
        int8_t tmp;
        for(size_t i = 0; i < count; ++i) {
            rc &= unpack(tmp);
            val += tmp;
        }
        return rc;
    }

    bool unpack(ByteVector& val,
                size_t count = std::numeric_limits<size_t>::max()) const {
        if(count == std::numeric_limits<size_t>::max())
            count = unpacking_remaining();
        if(!consume(count)) return false;
        val.clear();
        val.insert(
            val.end(), unpacking_iterator(), unpacking_iterator() + count);
        return true;
    }

    template <typename encoding_T, typename T1, typename T2,
              typename std::enable_if<std::is_arithmetic<T1>::value,
                                      T1>::type* = nullptr,
              typename std::enable_if<std::is_arithmetic<T2>::value,
                                      T2>::type* = nullptr>
    bool unpack(T1& val, T2 scale, T2 offset = 0) const {
        bool rc        = true;
        encoding_T tmp = 0;
        rc &= unpack(tmp);
        val = static_cast<T1>(tmp) / scale;
        val -= offset;
        return rc;
    }

    template <typename T,
              typename std::enable_if<std::is_base_of<Packable, T>::value,
                                      T>::type* = nullptr>
    bool unpack(T& obj) const {
        return obj.unpack_from(*this);
    }

    template <class T> bool unpack(Value<T>& val) const {
        return val.set() = unpack(val());
    }

    bool unpack(Value<std::string>& val,
                size_t count = std::numeric_limits<size_t>::max()) const {
        return val.set() = unpack(val(), count);
    }

    bool unpack(Value<ByteVector>& val,
                size_t count = std::numeric_limits<size_t>::max()) const {
        return val.set() = unpack(val(), count);
    }

    template <typename encoding_T, typename T1, typename T2 = float,
              typename std::enable_if<std::is_arithmetic<T1>::value,
                                      T1>::type* = nullptr,
              typename std::enable_if<std::is_arithmetic<T2>::value,
                                      T2>::type* = nullptr>
    bool unpack(Value<T1>& val, T2 scale = 1, T2 offset = 0) const {
        return val.set() = unpack<encoding_T>(val(), scale, offset);
    }

    std::size_t unpacking_offset() const { return offset; }

    std::vector<uint8_t>::iterator unpacking_iterator() {
        return this->begin() + offset;
    }

    std::vector<uint8_t>::const_iterator unpacking_iterator() const {
        return this->begin() + offset;
    }

    bool consume(std::size_t count) const {
        if(count > unpacking_remaining()) {
            return false;
        }
        offset += count;
        return true;
    }

    std::size_t unpacking_remaining() const { return this->size() - offset; }

protected:
    mutable std::size_t offset;
};

struct Packable {
    virtual ~Packable() {}
    virtual bool pack_into(ByteVector& data) const   = 0;
    virtual bool unpack_from(const ByteVector& data) = 0;
};

typedef std::shared_ptr<ByteVector> ByteVectorPtr;
typedef std::unique_ptr<ByteVector> ByteVectorUptr;

}  // namespace msp

inline std::ostream& operator<<(std::ostream& s, const msp::ByteVector& val) {
    s << std::hex;
    for(const auto& v : val) {
        s << uint32_t(v) << " ";
    }
    s << std::dec << std::endl;
    return s;
}

#endif