ConversationVector.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef CONVERSATIONVECTOR_HPP
#define CONVERSATIONVECTOR_HPP

#include <type_traits>
#include <vector>
#include <duds/hardware/interface/ConversationPart.hpp>

namespace duds { namespace hardware { namespace interface {

struct ConversationBadAdd : ConversationError { };

struct ConversationFixedLength : ConversationError { };

struct ConversationBadOffset : ConversationError { };

class ConversationVector : public ConversationPart {
    std::vector<char> data;
public:
    struct Input { };
    struct Output { };
    struct FixedLength { };
    struct VaribleLength { };
    ConversationVector(const ConversationVector &) = default;
    ConversationVector(Input) : ConversationPart(MpfInput | MpfExtract, 0) { };
    ConversationVector(Output) : ConversationPart(Flags::Zero(), 0) { };
    ConversationVector(bool input) : ConversationPart(
        input ? MpfInput | MpfExtract : Flags::Zero(), 0
    ) { };
    ConversationVector(const std::vector<char> &v) :
        ConversationPart(0), data(v) { }
    ConversationVector(std::vector<char> &&v) :
        ConversationPart(0), data(std::move(v)) { }
    //ConversationVector(char * array, int len, bool input) :
    //  ConversationPart(input), data(v) { }
    ConversationVector(std::size_t length, FixedLength) :
        ConversationPart(
            MpfInput | MpfExtract, 0
        ), data(length + val16) { }
    ConversationVector(std::size_t length, VaribleLength) :
        ConversationPart(
            MpfInput | MpfExtract | MpfVarlen, sizeof(std::size_t)
        ), data(length + val16) { }
    ConversationVector(std::size_t length, bool varlen = false) :
        ConversationPart(
            MpfInput | MpfExtract | (varlen ? MpfVarlen : Flags::Zero()),
            varlen ? sizeof(std::size_t) : 0
        ), data(length + val16) { }
    ConversationVector(std::size_t length, Output) :
        ConversationPart(Flags::Zero(), 0) {
            data.reserve(length);
        };
    std::vector<char>::const_iterator begin() const {
        return data.begin();
    }
    std::vector<char>::const_iterator end() const {
        return data.end();
    }
    void add(char i);
    template <typename Int>
    void addLe(Int i) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be added by this function.");
        if (input()) {
            throw ConversationBadAdd();
        }
        for (std::size_t loop = sizeof(Int); loop; --loop) {
            data.push_back((char)(i & 0xFF));
            i >>= 8;
        }
    }
    template <typename Int>
    void addBe(Int i) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be added by this function.");
        if (input()) {
            throw ConversationBadAdd();
        }
        for (std::size_t loop = sizeof(Int); loop; --loop) {
            data.push_back((char)(i >> (8 * (sizeof(Int) - 1))));
            i <<= 8;
        }
    }
    void addLe(std::int8_t i) {
        add((char)i);
    }
    void addBe(std::int8_t i) {
        add((char)i);
    }
    template <typename Int>
    void add(Int i) {
        if (bigEndian()) {
            addBe(i);
        } else {
            addLe(i);
        }
    }
    void add(const std::string &str);
    void add(std::int8_t *a, std::size_t l);
    template <std::size_t N>
    void add(std::int8_t (&a)[N]) {
        add(a, N);
    }
    template <typename Int>
    void addLe(const Int *a, std::size_t count) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be added by this function.");
        if (input()) {
            throw ConversationBadAdd();
        }
        data.reserve(data.size() + sizeof(Int) * count);
        for (; count; --count) {
            Int i = *(a++);
            for (std::size_t loop = sizeof(Int); loop; --loop) {
                data.push_back((char)(i & 0xFF));
                i >>= 8;
            }
        }
    }
    template <typename Int, std::size_t N>
    void addLe(const Int (&a)[N]) {
        addLe(a, N);
    }
    template <typename Int>
    void addBe(const Int *a, std::size_t count) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be added by this function.");
        if (input()) {
            throw ConversationBadAdd();
        }
        data.reserve(data.size() + sizeof(Int) * count);
        for (; count; --count) {
            Int i = *(a++);
            for (std::size_t loop = sizeof(Int); loop; --loop) {
                data.push_back((char)(i >> (8 * (sizeof(Int) - 1))));
                i <<= 8;
            }
        }
    }
    template <typename Int, std::size_t N>
    void addBe(const Int (&a)[N]) {
        addBe(a, N);
    }
    template <typename Int>
    void add(const Int *a, std::size_t count) {
        if (bigEndian()) {
            addBe(a, count);
        } else {
            addLe(a, count);
        }
    }
    template <typename Int, std::size_t N>
    void add(const Int (&a)[N]) {
        if (bigEndian()) {
            addBe(a, N);
        } else {
            addLe(a, N);
        }
    }
    void setStartOffset(std::int16_t offset);
    void setLength(std::size_t len);
    void reserve(std::size_t len);
    struct BigEndian { };
    struct LittleEndian { };
    struct Reserve {
        int len;
        Reserve(int l) : len(l) { }
    };
    virtual char *start() const;
    virtual std::size_t length() const;
};

template <typename Int>
ConversationVector &operator << (ConversationVector &cv, const Int &i) {
    cv.add(i);
    return cv;
}

template <typename Int, std::size_t N>
ConversationVector &operator << (ConversationVector &cv, const Int (&a)[N]) {
    cv.add(a, N);
    return cv;
}

inline ConversationVector &operator << (
    ConversationVector &cv,
    const ConversationVector::Reserve &cvr
) {
    cv.reserve(cvr.len);
    return cv;
}

inline ConversationVector &operator << (
    ConversationVector &cv,
    const ConversationVector::BigEndian
) {
    cv.bigEndian(true);
    return cv;
}

inline ConversationVector &operator << (
    ConversationVector &cv,
    const ConversationVector::LittleEndian
) {
    cv.bigEndian(false);
    return cv;
}

inline ConversationVector &operator << (
    ConversationVector &cv,
    const std::string &str
) {
    cv.add(str);
    return cv;
}

} } }

#endif        //  #ifndef CONVERSATIONVECTOR_HPP