MessageBase.h

//
// Copyright 2014 - 2024 (C). Alex Robenko. All rights reserved.
//
 
// This file is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#pragma once
 
#include <type_traits>
#include <cassert>
#include <iterator>
#include <algorithm>
#include <vector>
 
#include "comms/comms.h"
 
#include "Message.h"
#include "MessageHandler.h"
#include "cc_tools_qt.h"
 
namespace cc_tools_qt
{
 
template <template<typename...> class TMessageBase, typename... TOptions>
class MessageBase :
        public cc_tools_qt::Message,
        public TMessageBase<
            comms::option::IdInfoInterface,
            comms::option::ReadIterator<const std::uint8_t*>,
            comms::option::WriteIterator<std::back_insert_iterator<std::vector<std::uint8_t> > >,
            comms::option::Handler<MessageHandler>,
            comms::option::ValidCheckInterface,
            comms::option::LengthInfoInterface,
            comms::option::RefreshInterface,
            comms::option::NameInterface,
            TOptions...>
{
    using CCBase = cc_tools_qt::Message;
    using CommsBase =
        TMessageBase<
            comms::option::IdInfoInterface,
            comms::option::ReadIterator<const std::uint8_t*>,
            comms::option::WriteIterator<std::back_insert_iterator<std::vector<std::uint8_t> > >,
            comms::option::Handler<MessageHandler>,
            comms::option::ValidCheckInterface,
            comms::option::LengthInfoInterface,
            comms::option::RefreshInterface,
            comms::option::NameInterface,
            TOptions...>;
public:
    using Handler = typename CommsBase::Handler;
 
    MessageBase() = default;
 
    MessageBase(const MessageBase&) = default;
 
    MessageBase(MessageBase&&) = default;
 
    ~MessageBase() noexcept = default;
 
    MessageBase& operator=(const MessageBase& other)
    {
        CommsBase::operator=(other);
        return *this;
    }
 
    MessageBase& operator=(MessageBase&& other)
    {
        CommsBase::operator=(std::move(other));
        return *this;
    }
 
protected:
 
    virtual bool refreshMsgImpl() override
    {
        return CommsBase::refresh();
    }
 
    virtual QString idAsStringImpl() const override
    {
        static const bool IsNumeric =
            std::is_enum<typename CommsBase::MsgIdType>::value ||
            std::is_integral<typename CommsBase::MsgIdType>::value;
        using Tag =
            typename std::conditional<
                IsNumeric,
                NumericIdTag,
                NonNumericIdTag
            >::type;
        return idAsStringImplInternal(Tag());
    }
 
    virtual bool isValidImpl() const override
    {
        return CommsBase::valid();
    }
 
    virtual DataSeq encodeDataImpl() const override
    {
        typedef typename CommsBase::WriteIterator Iter;
        typedef typename std::iterator_traits<Iter>::iterator_category Tag;
 
        static_assert(
            std::is_base_of<std::output_iterator_tag, Tag>::value,
            "Iterator is expected to be output iterator.");
 
        static_assert(std::is_same<std::back_insert_iterator<DataSeq>, Iter>::value,
            "Write iterator is expected to back insert iterator");
 
        DataSeq data;
        data.reserve(CommsBase::length());
        auto iter = std::back_inserter(data);
        [[maybe_unused]] auto es = CommsBase::write(iter, data.max_size());
        assert(es == comms::ErrorStatus::Success);
        return data;
    }
 
    virtual bool decodeDataImpl(const DataSeq& data) override
    {
        typedef typename CommsBase::ReadIterator Iter;
        typedef typename std::iterator_traits<Iter>::iterator_category Tag;
        static_assert(
            std::is_base_of<std::random_access_iterator_tag, Tag>::value,
            "Only random access iterator is supported for data decoding.");
 
        static_assert(std::is_pointer<Iter>::value, "Pointer as iterator is expected");
 
        Iter iter = nullptr;
        if (!data.empty()) {
            iter = &data[0];
        }
 
        auto es = CommsBase::read(iter, data.size());
        return es == comms::ErrorStatus::Success;
    }
 
private:
    struct NumericIdTag {};
    struct NonNumericIdTag {};
 
    QString idAsStringImplInternal(NumericIdTag) const
    {
        return QString("%1").arg(static_cast<qlonglong>(CommsBase::getId()));
    }
 
    QString idAsStringImplInternal(NonNumericIdTag) const
    {
        return QString("%1").arg(CommsBase::getId());
    }
};
 
}  // namespace cc_tools_qt