/* This file is autogenerated. DO NOT CHANGE. All changes will be lost */

#include "qtprotobufnamespace/tests/basicmessages.qpb.h"
#include <QProtobufSerializer>

namespace qtprotobufnamespace::tests {
EmptyMessage::~EmptyMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 1> qt_protobuf_EmptyMessage_uint_data;
    const char qt_protobuf_EmptyMessage_char_data[40];
} qt_protobuf_EmptyMessage_metadata {
    // data
    {
        0, /* = version */
        0, /* = num fields */
        1, /* = field number offset */
        1, /* = property index offset */
        1, /* = field flags offset */
        38, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        39, /* = end-of-string-marker */
        // Field numbers:
        // Property indices:
        // Field flags:
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.EmptyMessage\0" /* = full message name */
    /* field char_data: */
    ""
};

const QtProtobufPrivate::QProtobufPropertyOrdering EmptyMessage::propertyOrdering = {
    &qt_protobuf_EmptyMessage_metadata.data
};

void EmptyMessage::registerTypes()
{
    qRegisterMetaType<EmptyMessage>();
    qRegisterMetaType<EmptyMessageRepeated>();
}
EmptyMessage::EmptyMessage() : QProtobufMessage(&EmptyMessage::staticMetaObject)
{
}
EmptyMessage::EmptyMessage(const EmptyMessage &other) : QProtobufMessage(other)
{
}
EmptyMessage &EmptyMessage::operator =(const EmptyMessage &other)
{
    QProtobufMessage::operator=(other);
    return *this;
}
EmptyMessage::EmptyMessage(EmptyMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
}
EmptyMessage &EmptyMessage::operator =(EmptyMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    return *this;
}
bool EmptyMessage::operator ==(const EmptyMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other);
}
bool EmptyMessage::operator !=(const EmptyMessage &other) const
{
    return !this->operator ==(other);
}

SimpleBoolMessage::~SimpleBoolMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleBoolMessage_uint_data;
    const char qt_protobuf_SimpleBoolMessage_char_data[59];
} qt_protobuf_SimpleBoolMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        43, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        44, /* = testFieldBool */
        58, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldBool */
        // Property indices:
        0, /* = testFieldBool */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldBool */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleBoolMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldBool\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleBoolMessage::propertyOrdering = {
    &qt_protobuf_SimpleBoolMessage_metadata.data
};

void SimpleBoolMessage::registerTypes()
{
    qRegisterMetaType<SimpleBoolMessage>();
    qRegisterMetaType<SimpleBoolMessageRepeated>();
}
SimpleBoolMessage::SimpleBoolMessage() : QProtobufMessage(&SimpleBoolMessage::staticMetaObject),
    m_testFieldBool(false)
{
}
SimpleBoolMessage::SimpleBoolMessage(const SimpleBoolMessage &other) : QProtobufMessage(other),
    m_testFieldBool(other.m_testFieldBool)
{
}
SimpleBoolMessage &SimpleBoolMessage::operator =(const SimpleBoolMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldBool(other.m_testFieldBool);
    return *this;
}
SimpleBoolMessage::SimpleBoolMessage(SimpleBoolMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldBool(std::exchange(other.m_testFieldBool, 0));
}
SimpleBoolMessage &SimpleBoolMessage::operator =(SimpleBoolMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldBool(std::exchange(other.m_testFieldBool, 0));
    return *this;
}
bool SimpleBoolMessage::operator ==(const SimpleBoolMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldBool == other.m_testFieldBool;
}
bool SimpleBoolMessage::operator !=(const SimpleBoolMessage &other) const
{
    return !this->operator ==(other);
}

SimpleIntMessage::~SimpleIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleIntMessage_uint_data;
    const char qt_protobuf_SimpleIntMessage_char_data[57];
} qt_protobuf_SimpleIntMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        42, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        43, /* = testFieldInt */
        56, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleIntMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleIntMessage::propertyOrdering = {
    &qt_protobuf_SimpleIntMessage_metadata.data
};

void SimpleIntMessage::registerTypes()
{
    qRegisterMetaType<SimpleIntMessage>();
    qRegisterMetaType<SimpleIntMessageRepeated>();
}
SimpleIntMessage::SimpleIntMessage() : QProtobufMessage(&SimpleIntMessage::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleIntMessage::SimpleIntMessage(const SimpleIntMessage &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleIntMessage &SimpleIntMessage::operator =(const SimpleIntMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleIntMessage::SimpleIntMessage(SimpleIntMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleIntMessage &SimpleIntMessage::operator =(SimpleIntMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleIntMessage::operator ==(const SimpleIntMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleIntMessage::operator !=(const SimpleIntMessage &other) const
{
    return !this->operator ==(other);
}

SimpleSIntMessage::~SimpleSIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSIntMessage_uint_data;
    const char qt_protobuf_SimpleSIntMessage_char_data[58];
} qt_protobuf_SimpleSIntMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        43, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        44, /* = testFieldInt */
        57, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSIntMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSIntMessage::propertyOrdering = {
    &qt_protobuf_SimpleSIntMessage_metadata.data
};

void SimpleSIntMessage::registerTypes()
{
    qRegisterMetaType<SimpleSIntMessage>();
    qRegisterMetaType<SimpleSIntMessageRepeated>();
}
SimpleSIntMessage::SimpleSIntMessage() : QProtobufMessage(&SimpleSIntMessage::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleSIntMessage::SimpleSIntMessage(const SimpleSIntMessage &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleSIntMessage &SimpleSIntMessage::operator =(const SimpleSIntMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleSIntMessage::SimpleSIntMessage(SimpleSIntMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleSIntMessage &SimpleSIntMessage::operator =(SimpleSIntMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleSIntMessage::operator ==(const SimpleSIntMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleSIntMessage::operator !=(const SimpleSIntMessage &other) const
{
    return !this->operator ==(other);
}

SimpleUIntMessage::~SimpleUIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUIntMessage_uint_data;
    const char qt_protobuf_SimpleUIntMessage_char_data[58];
} qt_protobuf_SimpleUIntMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        43, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        44, /* = testFieldInt */
        57, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUIntMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUIntMessage::propertyOrdering = {
    &qt_protobuf_SimpleUIntMessage_metadata.data
};

void SimpleUIntMessage::registerTypes()
{
    qRegisterMetaType<SimpleUIntMessage>();
    qRegisterMetaType<SimpleUIntMessageRepeated>();
}
SimpleUIntMessage::SimpleUIntMessage() : QProtobufMessage(&SimpleUIntMessage::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleUIntMessage::SimpleUIntMessage(const SimpleUIntMessage &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleUIntMessage &SimpleUIntMessage::operator =(const SimpleUIntMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleUIntMessage::SimpleUIntMessage(SimpleUIntMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleUIntMessage &SimpleUIntMessage::operator =(SimpleUIntMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleUIntMessage::operator ==(const SimpleUIntMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleUIntMessage::operator !=(const SimpleUIntMessage &other) const
{
    return !this->operator ==(other);
}

SimpleInt64Message::~SimpleInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64Message_uint_data;
    const char qt_protobuf_SimpleInt64Message_char_data[59];
} qt_protobuf_SimpleInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        44, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        45, /* = testFieldInt */
        58, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64Message\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64Message::propertyOrdering = {
    &qt_protobuf_SimpleInt64Message_metadata.data
};

void SimpleInt64Message::registerTypes()
{
    qRegisterMetaType<SimpleInt64Message>();
    qRegisterMetaType<SimpleInt64MessageRepeated>();
}
SimpleInt64Message::SimpleInt64Message() : QProtobufMessage(&SimpleInt64Message::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleInt64Message::SimpleInt64Message(const SimpleInt64Message &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleInt64Message &SimpleInt64Message::operator =(const SimpleInt64Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleInt64Message::SimpleInt64Message(SimpleInt64Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleInt64Message &SimpleInt64Message::operator =(SimpleInt64Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleInt64Message::operator ==(const SimpleInt64Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleInt64Message::operator !=(const SimpleInt64Message &other) const
{
    return !this->operator ==(other);
}

SimpleSInt64Message::~SimpleSInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64Message_uint_data;
    const char qt_protobuf_SimpleSInt64Message_char_data[60];
} qt_protobuf_SimpleSInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        45, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        46, /* = testFieldInt */
        59, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64Message\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64Message::propertyOrdering = {
    &qt_protobuf_SimpleSInt64Message_metadata.data
};

void SimpleSInt64Message::registerTypes()
{
    qRegisterMetaType<SimpleSInt64Message>();
    qRegisterMetaType<SimpleSInt64MessageRepeated>();
}
SimpleSInt64Message::SimpleSInt64Message() : QProtobufMessage(&SimpleSInt64Message::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleSInt64Message::SimpleSInt64Message(const SimpleSInt64Message &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleSInt64Message &SimpleSInt64Message::operator =(const SimpleSInt64Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleSInt64Message::SimpleSInt64Message(SimpleSInt64Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleSInt64Message &SimpleSInt64Message::operator =(SimpleSInt64Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleSInt64Message::operator ==(const SimpleSInt64Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleSInt64Message::operator !=(const SimpleSInt64Message &other) const
{
    return !this->operator ==(other);
}

SimpleUInt64Message::~SimpleUInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64Message_uint_data;
    const char qt_protobuf_SimpleUInt64Message_char_data[60];
} qt_protobuf_SimpleUInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        45, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        46, /* = testFieldInt */
        59, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        // Property indices:
        0, /* = testFieldInt */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64Message\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64Message::propertyOrdering = {
    &qt_protobuf_SimpleUInt64Message_metadata.data
};

void SimpleUInt64Message::registerTypes()
{
    qRegisterMetaType<SimpleUInt64Message>();
    qRegisterMetaType<SimpleUInt64MessageRepeated>();
}
SimpleUInt64Message::SimpleUInt64Message() : QProtobufMessage(&SimpleUInt64Message::staticMetaObject),
    m_testFieldInt(0)
{
}
SimpleUInt64Message::SimpleUInt64Message(const SimpleUInt64Message &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt)
{
}
SimpleUInt64Message &SimpleUInt64Message::operator =(const SimpleUInt64Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    return *this;
}
SimpleUInt64Message::SimpleUInt64Message(SimpleUInt64Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
}
SimpleUInt64Message &SimpleUInt64Message::operator =(SimpleUInt64Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    return *this;
}
bool SimpleUInt64Message::operator ==(const SimpleUInt64Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt;
}
bool SimpleUInt64Message::operator !=(const SimpleUInt64Message &other) const
{
    return !this->operator ==(other);
}

SimpleStringMessage::~SimpleStringMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringMessage_uint_data;
    const char qt_protobuf_SimpleStringMessage_char_data[63];
} qt_protobuf_SimpleStringMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        45, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        46, /* = testFieldString */
        62, /* = end-of-string-marker */
        // Field numbers:
        6, /* = testFieldString */
        // Property indices:
        0, /* = testFieldString */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldString */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldString\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringMessage::propertyOrdering = {
    &qt_protobuf_SimpleStringMessage_metadata.data
};

void SimpleStringMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringMessage>();
    qRegisterMetaType<SimpleStringMessageRepeated>();
}
SimpleStringMessage::SimpleStringMessage() : QProtobufMessage(&SimpleStringMessage::staticMetaObject)
{
}
SimpleStringMessage::SimpleStringMessage(const SimpleStringMessage &other) : QProtobufMessage(other),
    m_testFieldString(other.m_testFieldString)
{
}
SimpleStringMessage &SimpleStringMessage::operator =(const SimpleStringMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldString(other.m_testFieldString);
    return *this;
}
SimpleStringMessage::SimpleStringMessage(SimpleStringMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    m_testFieldString = std::move(other.m_testFieldString);
}
SimpleStringMessage &SimpleStringMessage::operator =(SimpleStringMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    if (m_testFieldString != other.m_testFieldString)
        m_testFieldString = std::move(other.m_testFieldString);
    return *this;
}
bool SimpleStringMessage::operator ==(const SimpleStringMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldString == other.m_testFieldString;
}
bool SimpleStringMessage::operator !=(const SimpleStringMessage &other) const
{
    return !this->operator ==(other);
}

void SimpleStringMessage::setTestFieldString(const QString &testFieldString)
{
    if (m_testFieldString != testFieldString)
        m_testFieldString = testFieldString;
}

SimpleFloatMessage::~SimpleFloatMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFloatMessage_uint_data;
    const char qt_protobuf_SimpleFloatMessage_char_data[61];
} qt_protobuf_SimpleFloatMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        44, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        45, /* = testFieldFloat */
        60, /* = end-of-string-marker */
        // Field numbers:
        7, /* = testFieldFloat */
        // Property indices:
        0, /* = testFieldFloat */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldFloat */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFloatMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldFloat\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFloatMessage::propertyOrdering = {
    &qt_protobuf_SimpleFloatMessage_metadata.data
};

void SimpleFloatMessage::registerTypes()
{
    qRegisterMetaType<SimpleFloatMessage>();
    qRegisterMetaType<SimpleFloatMessageRepeated>();
}
SimpleFloatMessage::SimpleFloatMessage() : QProtobufMessage(&SimpleFloatMessage::staticMetaObject),
    m_testFieldFloat(0.0)
{
}
SimpleFloatMessage::SimpleFloatMessage(const SimpleFloatMessage &other) : QProtobufMessage(other),
    m_testFieldFloat(other.m_testFieldFloat)
{
}
SimpleFloatMessage &SimpleFloatMessage::operator =(const SimpleFloatMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldFloat(other.m_testFieldFloat);
    return *this;
}
SimpleFloatMessage::SimpleFloatMessage(SimpleFloatMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldFloat(std::exchange(other.m_testFieldFloat, 0));
}
SimpleFloatMessage &SimpleFloatMessage::operator =(SimpleFloatMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldFloat(std::exchange(other.m_testFieldFloat, 0));
    return *this;
}
bool SimpleFloatMessage::operator ==(const SimpleFloatMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldFloat == other.m_testFieldFloat;
}
bool SimpleFloatMessage::operator !=(const SimpleFloatMessage &other) const
{
    return !this->operator ==(other);
}

SimpleDoubleMessage::~SimpleDoubleMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleDoubleMessage_uint_data;
    const char qt_protobuf_SimpleDoubleMessage_char_data[63];
} qt_protobuf_SimpleDoubleMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        45, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        46, /* = testFieldDouble */
        62, /* = end-of-string-marker */
        // Field numbers:
        8, /* = testFieldDouble */
        // Property indices:
        0, /* = testFieldDouble */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldDouble */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleDoubleMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldDouble\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleDoubleMessage::propertyOrdering = {
    &qt_protobuf_SimpleDoubleMessage_metadata.data
};

void SimpleDoubleMessage::registerTypes()
{
    qRegisterMetaType<SimpleDoubleMessage>();
    qRegisterMetaType<SimpleDoubleMessageRepeated>();
}
SimpleDoubleMessage::SimpleDoubleMessage() : QProtobufMessage(&SimpleDoubleMessage::staticMetaObject),
    m_testFieldDouble(0.0)
{
}
SimpleDoubleMessage::SimpleDoubleMessage(const SimpleDoubleMessage &other) : QProtobufMessage(other),
    m_testFieldDouble(other.m_testFieldDouble)
{
}
SimpleDoubleMessage &SimpleDoubleMessage::operator =(const SimpleDoubleMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldDouble(other.m_testFieldDouble);
    return *this;
}
SimpleDoubleMessage::SimpleDoubleMessage(SimpleDoubleMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldDouble(std::exchange(other.m_testFieldDouble, 0));
}
SimpleDoubleMessage &SimpleDoubleMessage::operator =(SimpleDoubleMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldDouble(std::exchange(other.m_testFieldDouble, 0));
    return *this;
}
bool SimpleDoubleMessage::operator ==(const SimpleDoubleMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldDouble == other.m_testFieldDouble;
}
bool SimpleDoubleMessage::operator !=(const SimpleDoubleMessage &other) const
{
    return !this->operator ==(other);
}

SimpleBytesMessage::~SimpleBytesMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleBytesMessage_uint_data;
    const char qt_protobuf_SimpleBytesMessage_char_data[61];
} qt_protobuf_SimpleBytesMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        44, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        45, /* = testFieldBytes */
        60, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldBytes */
        // Property indices:
        0, /* = testFieldBytes */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldBytes */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleBytesMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldBytes\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleBytesMessage::propertyOrdering = {
    &qt_protobuf_SimpleBytesMessage_metadata.data
};

void SimpleBytesMessage::registerTypes()
{
    qRegisterMetaType<SimpleBytesMessage>();
    qRegisterMetaType<SimpleBytesMessageRepeated>();
}
SimpleBytesMessage::SimpleBytesMessage() : QProtobufMessage(&SimpleBytesMessage::staticMetaObject)
{
}
SimpleBytesMessage::SimpleBytesMessage(const SimpleBytesMessage &other) : QProtobufMessage(other),
    m_testFieldBytes(other.m_testFieldBytes)
{
}
SimpleBytesMessage &SimpleBytesMessage::operator =(const SimpleBytesMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldBytes(other.m_testFieldBytes);
    return *this;
}
SimpleBytesMessage::SimpleBytesMessage(SimpleBytesMessage &&other) noexcept : QProtobufMessage(std::move(other))
{
    m_testFieldBytes = std::move(other.m_testFieldBytes);
}
SimpleBytesMessage &SimpleBytesMessage::operator =(SimpleBytesMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    if (m_testFieldBytes != other.m_testFieldBytes)
        m_testFieldBytes = std::move(other.m_testFieldBytes);
    return *this;
}
bool SimpleBytesMessage::operator ==(const SimpleBytesMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldBytes == other.m_testFieldBytes;
}
bool SimpleBytesMessage::operator !=(const SimpleBytesMessage &other) const
{
    return !this->operator ==(other);
}

void SimpleBytesMessage::setTestFieldBytes(const QByteArray &testFieldBytes)
{
    if (m_testFieldBytes != testFieldBytes)
        m_testFieldBytes = testFieldBytes;
}

SimpleFixedInt32Message::~SimpleFixedInt32Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixedInt32Message_uint_data;
    const char qt_protobuf_SimpleFixedInt32Message_char_data[71];
} qt_protobuf_SimpleFixedInt32Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        49, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        50, /* = testFieldFixedInt32 */
        70, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldFixedInt32 */
        // Property indices:
        0, /* = testFieldFixedInt32 */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldFixedInt32 */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixedInt32Message\0" /* = full message name */
    /* field char_data: */
    "testFieldFixedInt32\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixedInt32Message::propertyOrdering = {
    &qt_protobuf_SimpleFixedInt32Message_metadata.data
};

void SimpleFixedInt32Message::registerTypes()
{
    qRegisterMetaType<SimpleFixedInt32Message>();
    qRegisterMetaType<SimpleFixedInt32MessageRepeated>();
}
SimpleFixedInt32Message::SimpleFixedInt32Message() : QProtobufMessage(&SimpleFixedInt32Message::staticMetaObject),
    m_testFieldFixedInt32(0)
{
}
SimpleFixedInt32Message::SimpleFixedInt32Message(const SimpleFixedInt32Message &other) : QProtobufMessage(other),
    m_testFieldFixedInt32(other.m_testFieldFixedInt32)
{
}
SimpleFixedInt32Message &SimpleFixedInt32Message::operator =(const SimpleFixedInt32Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldFixedInt32(other.m_testFieldFixedInt32);
    return *this;
}
SimpleFixedInt32Message::SimpleFixedInt32Message(SimpleFixedInt32Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldFixedInt32(std::exchange(other.m_testFieldFixedInt32, 0));
}
SimpleFixedInt32Message &SimpleFixedInt32Message::operator =(SimpleFixedInt32Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldFixedInt32(std::exchange(other.m_testFieldFixedInt32, 0));
    return *this;
}
bool SimpleFixedInt32Message::operator ==(const SimpleFixedInt32Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldFixedInt32 == other.m_testFieldFixedInt32;
}
bool SimpleFixedInt32Message::operator !=(const SimpleFixedInt32Message &other) const
{
    return !this->operator ==(other);
}

SimpleFixedInt64Message::~SimpleFixedInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixedInt64Message_uint_data;
    const char qt_protobuf_SimpleFixedInt64Message_char_data[71];
} qt_protobuf_SimpleFixedInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        49, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        50, /* = testFieldFixedInt64 */
        70, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldFixedInt64 */
        // Property indices:
        0, /* = testFieldFixedInt64 */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldFixedInt64 */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixedInt64Message\0" /* = full message name */
    /* field char_data: */
    "testFieldFixedInt64\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixedInt64Message::propertyOrdering = {
    &qt_protobuf_SimpleFixedInt64Message_metadata.data
};

void SimpleFixedInt64Message::registerTypes()
{
    qRegisterMetaType<SimpleFixedInt64Message>();
    qRegisterMetaType<SimpleFixedInt64MessageRepeated>();
}
SimpleFixedInt64Message::SimpleFixedInt64Message() : QProtobufMessage(&SimpleFixedInt64Message::staticMetaObject),
    m_testFieldFixedInt64(0)
{
}
SimpleFixedInt64Message::SimpleFixedInt64Message(const SimpleFixedInt64Message &other) : QProtobufMessage(other),
    m_testFieldFixedInt64(other.m_testFieldFixedInt64)
{
}
SimpleFixedInt64Message &SimpleFixedInt64Message::operator =(const SimpleFixedInt64Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldFixedInt64(other.m_testFieldFixedInt64);
    return *this;
}
SimpleFixedInt64Message::SimpleFixedInt64Message(SimpleFixedInt64Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldFixedInt64(std::exchange(other.m_testFieldFixedInt64, 0));
}
SimpleFixedInt64Message &SimpleFixedInt64Message::operator =(SimpleFixedInt64Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldFixedInt64(std::exchange(other.m_testFieldFixedInt64, 0));
    return *this;
}
bool SimpleFixedInt64Message::operator ==(const SimpleFixedInt64Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldFixedInt64 == other.m_testFieldFixedInt64;
}
bool SimpleFixedInt64Message::operator !=(const SimpleFixedInt64Message &other) const
{
    return !this->operator ==(other);
}

SimpleSFixedInt32Message::~SimpleSFixedInt32Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixedInt32Message_uint_data;
    const char qt_protobuf_SimpleSFixedInt32Message_char_data[72];
} qt_protobuf_SimpleSFixedInt32Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        50, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        51, /* = testFieldFixedInt32 */
        71, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldFixedInt32 */
        // Property indices:
        0, /* = testFieldFixedInt32 */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldFixedInt32 */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixedInt32Message\0" /* = full message name */
    /* field char_data: */
    "testFieldFixedInt32\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixedInt32Message::propertyOrdering = {
    &qt_protobuf_SimpleSFixedInt32Message_metadata.data
};

void SimpleSFixedInt32Message::registerTypes()
{
    qRegisterMetaType<SimpleSFixedInt32Message>();
    qRegisterMetaType<SimpleSFixedInt32MessageRepeated>();
}
SimpleSFixedInt32Message::SimpleSFixedInt32Message() : QProtobufMessage(&SimpleSFixedInt32Message::staticMetaObject)
{
}
SimpleSFixedInt32Message::SimpleSFixedInt32Message(const SimpleSFixedInt32Message &other) : QProtobufMessage(other),
    m_testFieldFixedInt32(other.m_testFieldFixedInt32)
{
}
SimpleSFixedInt32Message &SimpleSFixedInt32Message::operator =(const SimpleSFixedInt32Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldFixedInt32(other.m_testFieldFixedInt32);
    return *this;
}
SimpleSFixedInt32Message::SimpleSFixedInt32Message(SimpleSFixedInt32Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldFixedInt32(std::exchange(other.m_testFieldFixedInt32, 0));
}
SimpleSFixedInt32Message &SimpleSFixedInt32Message::operator =(SimpleSFixedInt32Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldFixedInt32(std::exchange(other.m_testFieldFixedInt32, 0));
    return *this;
}
bool SimpleSFixedInt32Message::operator ==(const SimpleSFixedInt32Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldFixedInt32 == other.m_testFieldFixedInt32;
}
bool SimpleSFixedInt32Message::operator !=(const SimpleSFixedInt32Message &other) const
{
    return !this->operator ==(other);
}

SimpleSFixedInt64Message::~SimpleSFixedInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixedInt64Message_uint_data;
    const char qt_protobuf_SimpleSFixedInt64Message_char_data[72];
} qt_protobuf_SimpleSFixedInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        50, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        51, /* = testFieldFixedInt64 */
        71, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldFixedInt64 */
        // Property indices:
        0, /* = testFieldFixedInt64 */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldFixedInt64 */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixedInt64Message\0" /* = full message name */
    /* field char_data: */
    "testFieldFixedInt64\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixedInt64Message::propertyOrdering = {
    &qt_protobuf_SimpleSFixedInt64Message_metadata.data
};

void SimpleSFixedInt64Message::registerTypes()
{
    qRegisterMetaType<SimpleSFixedInt64Message>();
    qRegisterMetaType<SimpleSFixedInt64MessageRepeated>();
}
SimpleSFixedInt64Message::SimpleSFixedInt64Message() : QProtobufMessage(&SimpleSFixedInt64Message::staticMetaObject)
{
}
SimpleSFixedInt64Message::SimpleSFixedInt64Message(const SimpleSFixedInt64Message &other) : QProtobufMessage(other),
    m_testFieldFixedInt64(other.m_testFieldFixedInt64)
{
}
SimpleSFixedInt64Message &SimpleSFixedInt64Message::operator =(const SimpleSFixedInt64Message &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldFixedInt64(other.m_testFieldFixedInt64);
    return *this;
}
SimpleSFixedInt64Message::SimpleSFixedInt64Message(SimpleSFixedInt64Message &&other) noexcept : QProtobufMessage(std::move(other))
{
    setTestFieldFixedInt64(std::exchange(other.m_testFieldFixedInt64, 0));
}
SimpleSFixedInt64Message &SimpleSFixedInt64Message::operator =(SimpleSFixedInt64Message &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldFixedInt64(std::exchange(other.m_testFieldFixedInt64, 0));
    return *this;
}
bool SimpleSFixedInt64Message::operator ==(const SimpleSFixedInt64Message &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldFixedInt64 == other.m_testFieldFixedInt64;
}
bool SimpleSFixedInt64Message::operator !=(const SimpleSFixedInt64Message &other) const
{
    return !this->operator ==(other);
}

ComplexMessage::~ComplexMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 9> qt_protobuf_ComplexMessage_uint_data;
    const char qt_protobuf_ComplexMessage_char_data[72];
} qt_protobuf_ComplexMessage_metadata {
    // data
    {
        0, /* = version */
        2, /* = num fields */
        3, /* = field number offset */
        5, /* = property index offset */
        7, /* = field flags offset */
        40, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        41, /* = testFieldInt */
        54, /* = testComplexField */
        71, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testFieldInt */
        2, /* = testComplexField */
        // Property indices:
        0, /* = testFieldInt */
        1, /* = testComplexField */
        // Field flags:
        QtProtobufPrivate::NoFlags, /* = testFieldInt */
        QtProtobufPrivate::NoFlags, /* = testComplexField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.ComplexMessage\0" /* = full message name */
    /* field char_data: */
    "testFieldInt\0testComplexField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering ComplexMessage::propertyOrdering = {
    &qt_protobuf_ComplexMessage_metadata.data
};

void ComplexMessage::registerTypes()
{
    qRegisterMetaType<ComplexMessage>();
    qRegisterMetaType<ComplexMessageRepeated>();
}
ComplexMessage::ComplexMessage() : QProtobufMessage(&ComplexMessage::staticMetaObject),
    m_testFieldInt(0),
    m_testComplexField(nullptr)
{
}
ComplexMessage::ComplexMessage(const ComplexMessage &other) : QProtobufMessage(other),
    m_testFieldInt(other.m_testFieldInt),
    m_testComplexField(nullptr)
{
    if (m_testComplexField != other.m_testComplexField) {
        *m_testComplexField = *other.m_testComplexField;
    }
}
ComplexMessage &ComplexMessage::operator =(const ComplexMessage &other)
{
    QProtobufMessage::operator=(other);
    setTestFieldInt(other.m_testFieldInt);
    if (m_testComplexField != other.m_testComplexField)
        *m_testComplexField = *other.m_testComplexField;
    return *this;
}
ComplexMessage::ComplexMessage(ComplexMessage &&other) noexcept : QProtobufMessage(std::move(other)),
m_testComplexField(nullptr)
{
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    if (m_testComplexField != other.m_testComplexField) {
        *m_testComplexField = std::move(*other.m_testComplexField);
    }
}
ComplexMessage &ComplexMessage::operator =(ComplexMessage &&other) noexcept
{
    QProtobufMessage::operator=(std::move(other));
    setTestFieldInt(std::exchange(other.m_testFieldInt, 0));
    if (m_testComplexField != other.m_testComplexField)
        *m_testComplexField = std::move(*other.m_testComplexField);
    return *this;
}
bool ComplexMessage::operator ==(const ComplexMessage &other) const
{
    return QProtobufMessage::isEqual(*this, other)
        && m_testFieldInt == other.m_testFieldInt
        && (m_testComplexField == other.m_testComplexField
            || *m_testComplexField == *other.m_testComplexField)
;
}
bool ComplexMessage::operator !=(const ComplexMessage &other) const
{
    return !this->operator ==(other);
}

SimpleStringMessage *ComplexMessage::testComplexField_p() const
{
    return m_testComplexField ? m_testComplexField.get() : nullptr;
}

SimpleStringMessage &ComplexMessage::testComplexField() const
{
    return *m_testComplexField;
}

void ComplexMessage::setTestComplexField_p(SimpleStringMessage *testComplexField)
{
    if (m_testComplexField.get() != testComplexField)
        m_testComplexField.reset(testComplexField);
}

void ComplexMessage::setTestComplexField(const SimpleStringMessage &testComplexField)
{
    if (*m_testComplexField != testComplexField)
        *m_testComplexField = testComplexField;
}

} // namespace qtprotobufnamespace::tests

#include "moc_basicmessages.qpb.cpp"
