ConversationExtractor.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
 */
#include <duds/hardware/interface/Conversation.hpp>
#include <duds/general/Errors.hpp>

namespace duds { namespace hardware { namespace interface {

struct ConversationReadPastEnd : ConversationError { };

struct ConversationNotSet : ConversationError { };

class ConversationExtractor {
    Conversation::PartVector::const_iterator piter;
    const Conversation *c;
    const char *pos;
    std::size_t remain;
    void set();
public:
    ConversationExtractor() : c(nullptr), pos(nullptr), remain(0) { }
    ConversationExtractor(const Conversation &con) : c(&con) {
        set();
    };
    ConversationExtractor(const ConversationPart &cp) :
    c(nullptr), pos(cp.start()), remain(cp.length()) { }
    void reset() {
        set();
    };
    void reset(const Conversation &con) {
        c = &con;
        set();
    };
    void reset(const ConversationPart &cp) {
        c = nullptr;
        pos = cp.start();
        remain = cp.length();
    }
    bool end() const {
        return !pos;
    }
    std::size_t remaining() const {
        return remain;
    }
    void advance(std::size_t bytes);
    void nextPart();
    template <typename Int>
    void readLe(Int &i) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be read by this function.");
        if (remain < sizeof(Int)) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        const char *p = pos;
        for (std::size_t loop = sizeof(Int); loop; --loop, ++p) {
            // use unsigned type for shift to LSb; signed gives different result
            i = (((typename std::make_unsigned<Int>::type)i >> 8) |
                (((Int)*p) << (8 * (sizeof(Int) - 1)))
            );
        }
        advance(sizeof(Int));
    }
    template <typename Int>
    void readBe(Int &i) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be read by this function.");
        if (remain < sizeof(Int)) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        const char *p = pos;
        for (std::size_t loop = sizeof(Int); loop; --loop, ++p) {
            i = (i << 8) | *p;
        }
        advance(sizeof(Int));
    }
    template <typename Int>
    void read(Int &i) {
        // if at end of all parts, the iterator is c->cend() and pos is null
        if (!pos) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        if ((*piter)->bigEndian()) {
            readBe(i);
        } else {
            readLe(i);
        }
    }
    template <typename Int>
    void readLe(Int *a, std::size_t count) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be read by this function.");
        int len = (int)sizeof(Int) * count;
        if (remain < len) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        const char *p = pos;
        for (; count; --count, ++a) {
            for (std::size_t loop = sizeof(Int); loop; --loop, ++p) {
                // use unsigned type for shift to LSb
                *a = ((((typename std::make_unsigned<Int>::type)*a) >> 8) |
                    (((Int)*p) << (8 * (sizeof(Int) - 1)))
                );
            }
        }
        advance(len);
    }
    template <typename Int>
    void readBe(Int *a, std::size_t count) {
        static_assert(std::is_integral<Int>::value,
            "Only integer values can be read by this function.");
        int len = (int)sizeof(Int) * count;
        if (remain < len) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        const char *p = pos;
        for (; count; --count, ++a) {
            for (std::size_t loop = sizeof(Int); loop; --loop, ++p) {
                *a = (*a << 8) | *p;
            }
        }
        advance(len);
    }
    template <typename Int, std::size_t N>
    void readLe(Int (&a)[N]) {
        readLe(a, N);
    }
    template <typename Int, std::size_t N>
    void readBe(Int (&a)[N]) {
        readBe(a, N);
    }
    template <typename Int>
    void read(Int *a, std::size_t count) {
        // if at end of all parts, the iterator is c->cend() and pos is null
        if (!pos) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        if ((*piter)->bigEndian()) {
            readBe(a, count);
        } else {
            readLe(a, count);
        }
    }
    template <typename Int, std::size_t N>
    void read(Int (&a)[N]) {
        // if at end of all parts, the iterator is c->cend() and pos is null
        if (!pos) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        if ((*piter)->bigEndian()) {
            readBe(a, N);
        } else {
            readLe(a, N);
        }
    }
    void read(char *dest, std::size_t len);
    template <class Cont, typename Iter>
    void read(Cont &cont, Iter &start, std::size_t len) {
        if (remain < len) {
            DUDS_THROW_EXCEPTION(ConversationReadPastEnd());
        }
        cont.insert(start, pos, pos + len);
        advance(len);
    }
};

template <typename Int>
ConversationExtractor &operator >> (ConversationExtractor &ce, Int &i) {
    ce.read(i);
    return ce;
}

template <typename Int, std::size_t N>
ConversationExtractor &operator >> (ConversationExtractor &ce, Int (&a)[N]) {
    ce.read(a, N);
    return ce;
}

} } }