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

#include "annotation.qpb.h"
#include <QProtobufSerializer>

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

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage1_uint_data;
    const char qt_protobuf_AnnotatedMessage1_char_data[11];
} qt_protobuf_AnnotatedMessage1_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage1::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage1_metadata.data
};

void AnnotatedMessage1::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage1>();
    qRegisterMetaType<AnnotatedMessage1Repeated>();
}
AnnotatedMessage1::AnnotatedMessage1(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage1::AnnotatedMessage1(const AnnotatedMessage1 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage1 &AnnotatedMessage1::operator =(const AnnotatedMessage1 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage1::AnnotatedMessage1(AnnotatedMessage1 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage1 &AnnotatedMessage1::operator =(AnnotatedMessage1 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage1::operator ==(const AnnotatedMessage1 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage1::operator !=(const AnnotatedMessage1 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage2::~AnnotatedMessage2() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage2_uint_data;
    const char qt_protobuf_AnnotatedMessage2_char_data[11];
} qt_protobuf_AnnotatedMessage2_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage2::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage2_metadata.data
};

void AnnotatedMessage2::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage2>();
    qRegisterMetaType<AnnotatedMessage2Repeated>();
}
AnnotatedMessage2::AnnotatedMessage2(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage2::AnnotatedMessage2(const AnnotatedMessage2 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage2 &AnnotatedMessage2::operator =(const AnnotatedMessage2 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage2::AnnotatedMessage2(AnnotatedMessage2 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage2 &AnnotatedMessage2::operator =(AnnotatedMessage2 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage2::operator ==(const AnnotatedMessage2 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage2::operator !=(const AnnotatedMessage2 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage3::~AnnotatedMessage3() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage3_uint_data;
    const char qt_protobuf_AnnotatedMessage3_char_data[11];
} qt_protobuf_AnnotatedMessage3_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage3::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage3_metadata.data
};

void AnnotatedMessage3::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage3>();
    qRegisterMetaType<AnnotatedMessage3Repeated>();
}
AnnotatedMessage3::AnnotatedMessage3(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage3::AnnotatedMessage3(const AnnotatedMessage3 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage3 &AnnotatedMessage3::operator =(const AnnotatedMessage3 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage3::AnnotatedMessage3(AnnotatedMessage3 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage3 &AnnotatedMessage3::operator =(AnnotatedMessage3 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage3::operator ==(const AnnotatedMessage3 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage3::operator !=(const AnnotatedMessage3 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage4::~AnnotatedMessage4() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage4_uint_data;
    const char qt_protobuf_AnnotatedMessage4_char_data[11];
} qt_protobuf_AnnotatedMessage4_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage4::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage4_metadata.data
};

void AnnotatedMessage4::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage4>();
    qRegisterMetaType<AnnotatedMessage4Repeated>();
}
AnnotatedMessage4::AnnotatedMessage4(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage4::AnnotatedMessage4(const AnnotatedMessage4 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage4 &AnnotatedMessage4::operator =(const AnnotatedMessage4 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage4::AnnotatedMessage4(AnnotatedMessage4 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage4 &AnnotatedMessage4::operator =(AnnotatedMessage4 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage4::operator ==(const AnnotatedMessage4 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage4::operator !=(const AnnotatedMessage4 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage5::~AnnotatedMessage5() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage5_uint_data;
    const char qt_protobuf_AnnotatedMessage5_char_data[11];
} qt_protobuf_AnnotatedMessage5_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage5::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage5_metadata.data
};

void AnnotatedMessage5::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage5>();
    qRegisterMetaType<AnnotatedMessage5Repeated>();
}
AnnotatedMessage5::AnnotatedMessage5(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage5::AnnotatedMessage5(const AnnotatedMessage5 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage5 &AnnotatedMessage5::operator =(const AnnotatedMessage5 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage5::AnnotatedMessage5(AnnotatedMessage5 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage5 &AnnotatedMessage5::operator =(AnnotatedMessage5 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage5::operator ==(const AnnotatedMessage5 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage5::operator !=(const AnnotatedMessage5 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage6::~AnnotatedMessage6() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage6_uint_data;
    const char qt_protobuf_AnnotatedMessage6_char_data[11];
} qt_protobuf_AnnotatedMessage6_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage6::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage6_metadata.data
};

void AnnotatedMessage6::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage6>();
    qRegisterMetaType<AnnotatedMessage6Repeated>();
}
AnnotatedMessage6::AnnotatedMessage6(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage6::AnnotatedMessage6(const AnnotatedMessage6 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage6 &AnnotatedMessage6::operator =(const AnnotatedMessage6 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage6::AnnotatedMessage6(AnnotatedMessage6 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage6 &AnnotatedMessage6::operator =(AnnotatedMessage6 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage6::operator ==(const AnnotatedMessage6 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage6::operator !=(const AnnotatedMessage6 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage7::~AnnotatedMessage7() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage7_uint_data;
    const char qt_protobuf_AnnotatedMessage7_char_data[11];
} qt_protobuf_AnnotatedMessage7_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage7::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage7_metadata.data
};

void AnnotatedMessage7::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage7>();
    qRegisterMetaType<AnnotatedMessage7Repeated>();
}
AnnotatedMessage7::AnnotatedMessage7(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage7::AnnotatedMessage7(const AnnotatedMessage7 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage7 &AnnotatedMessage7::operator =(const AnnotatedMessage7 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage7::AnnotatedMessage7(AnnotatedMessage7 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage7 &AnnotatedMessage7::operator =(AnnotatedMessage7 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage7::operator ==(const AnnotatedMessage7 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage7::operator !=(const AnnotatedMessage7 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage8::~AnnotatedMessage8() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage8_uint_data;
    const char qt_protobuf_AnnotatedMessage8_char_data[11];
} qt_protobuf_AnnotatedMessage8_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage8::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage8_metadata.data
};

void AnnotatedMessage8::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage8>();
    qRegisterMetaType<AnnotatedMessage8Repeated>();
}
AnnotatedMessage8::AnnotatedMessage8(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage8::AnnotatedMessage8(const AnnotatedMessage8 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage8 &AnnotatedMessage8::operator =(const AnnotatedMessage8 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage8::AnnotatedMessage8(AnnotatedMessage8 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage8 &AnnotatedMessage8::operator =(AnnotatedMessage8 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage8::operator ==(const AnnotatedMessage8 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage8::operator !=(const AnnotatedMessage8 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage9::~AnnotatedMessage9() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage9_uint_data;
    const char qt_protobuf_AnnotatedMessage9_char_data[11];
} qt_protobuf_AnnotatedMessage9_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage9::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage9_metadata.data
};

void AnnotatedMessage9::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage9>();
    qRegisterMetaType<AnnotatedMessage9Repeated>();
}
AnnotatedMessage9::AnnotatedMessage9(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage9::AnnotatedMessage9(const AnnotatedMessage9 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage9 &AnnotatedMessage9::operator =(const AnnotatedMessage9 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage9::AnnotatedMessage9(AnnotatedMessage9 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage9 &AnnotatedMessage9::operator =(AnnotatedMessage9 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage9::operator ==(const AnnotatedMessage9 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage9::operator !=(const AnnotatedMessage9 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage10::~AnnotatedMessage10() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage10_uint_data;
    const char qt_protobuf_AnnotatedMessage10_char_data[11];
} qt_protobuf_AnnotatedMessage10_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage10::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage10_metadata.data
};

void AnnotatedMessage10::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage10>();
    qRegisterMetaType<AnnotatedMessage10Repeated>();
}
AnnotatedMessage10::AnnotatedMessage10(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage10::AnnotatedMessage10(const AnnotatedMessage10 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage10 &AnnotatedMessage10::operator =(const AnnotatedMessage10 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage10::AnnotatedMessage10(AnnotatedMessage10 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage10 &AnnotatedMessage10::operator =(AnnotatedMessage10 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage10::operator ==(const AnnotatedMessage10 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage10::operator !=(const AnnotatedMessage10 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage11::~AnnotatedMessage11() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage11_uint_data;
    const char qt_protobuf_AnnotatedMessage11_char_data[11];
} qt_protobuf_AnnotatedMessage11_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage11::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage11_metadata.data
};

void AnnotatedMessage11::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage11>();
    qRegisterMetaType<AnnotatedMessage11Repeated>();
}
AnnotatedMessage11::AnnotatedMessage11(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage11::AnnotatedMessage11(const AnnotatedMessage11 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage11 &AnnotatedMessage11::operator =(const AnnotatedMessage11 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage11::AnnotatedMessage11(AnnotatedMessage11 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage11 &AnnotatedMessage11::operator =(AnnotatedMessage11 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage11::operator ==(const AnnotatedMessage11 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage11::operator !=(const AnnotatedMessage11 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage12::~AnnotatedMessage12() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage12_uint_data;
    const char qt_protobuf_AnnotatedMessage12_char_data[11];
} qt_protobuf_AnnotatedMessage12_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage12::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage12_metadata.data
};

void AnnotatedMessage12::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage12>();
    qRegisterMetaType<AnnotatedMessage12Repeated>();
}
AnnotatedMessage12::AnnotatedMessage12(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage12::AnnotatedMessage12(const AnnotatedMessage12 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage12 &AnnotatedMessage12::operator =(const AnnotatedMessage12 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage12::AnnotatedMessage12(AnnotatedMessage12 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage12 &AnnotatedMessage12::operator =(AnnotatedMessage12 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage12::operator ==(const AnnotatedMessage12 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage12::operator !=(const AnnotatedMessage12 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage13::~AnnotatedMessage13() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage13_uint_data;
    const char qt_protobuf_AnnotatedMessage13_char_data[11];
} qt_protobuf_AnnotatedMessage13_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage13::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage13_metadata.data
};

void AnnotatedMessage13::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage13>();
    qRegisterMetaType<AnnotatedMessage13Repeated>();
}
AnnotatedMessage13::AnnotatedMessage13(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage13::AnnotatedMessage13(const AnnotatedMessage13 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage13 &AnnotatedMessage13::operator =(const AnnotatedMessage13 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage13::AnnotatedMessage13(AnnotatedMessage13 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage13 &AnnotatedMessage13::operator =(AnnotatedMessage13 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage13::operator ==(const AnnotatedMessage13 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage13::operator !=(const AnnotatedMessage13 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage14::~AnnotatedMessage14() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage14_uint_data;
    const char qt_protobuf_AnnotatedMessage14_char_data[11];
} qt_protobuf_AnnotatedMessage14_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage14::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage14_metadata.data
};

void AnnotatedMessage14::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage14>();
    qRegisterMetaType<AnnotatedMessage14Repeated>();
}
AnnotatedMessage14::AnnotatedMessage14(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage14::AnnotatedMessage14(const AnnotatedMessage14 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage14 &AnnotatedMessage14::operator =(const AnnotatedMessage14 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage14::AnnotatedMessage14(AnnotatedMessage14 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage14 &AnnotatedMessage14::operator =(AnnotatedMessage14 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage14::operator ==(const AnnotatedMessage14 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage14::operator !=(const AnnotatedMessage14 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage15::~AnnotatedMessage15() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage15_uint_data;
    const char qt_protobuf_AnnotatedMessage15_char_data[11];
} qt_protobuf_AnnotatedMessage15_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage15::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage15_metadata.data
};

void AnnotatedMessage15::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage15>();
    qRegisterMetaType<AnnotatedMessage15Repeated>();
}
AnnotatedMessage15::AnnotatedMessage15(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage15::AnnotatedMessage15(const AnnotatedMessage15 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage15 &AnnotatedMessage15::operator =(const AnnotatedMessage15 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage15::AnnotatedMessage15(AnnotatedMessage15 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage15 &AnnotatedMessage15::operator =(AnnotatedMessage15 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage15::operator ==(const AnnotatedMessage15 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage15::operator !=(const AnnotatedMessage15 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage16::~AnnotatedMessage16() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage16_uint_data;
    const char qt_protobuf_AnnotatedMessage16_char_data[11];
} qt_protobuf_AnnotatedMessage16_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage16::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage16_metadata.data
};

void AnnotatedMessage16::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage16>();
    qRegisterMetaType<AnnotatedMessage16Repeated>();
}
AnnotatedMessage16::AnnotatedMessage16(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage16::AnnotatedMessage16(const AnnotatedMessage16 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage16 &AnnotatedMessage16::operator =(const AnnotatedMessage16 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage16::AnnotatedMessage16(AnnotatedMessage16 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage16 &AnnotatedMessage16::operator =(AnnotatedMessage16 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage16::operator ==(const AnnotatedMessage16 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage16::operator !=(const AnnotatedMessage16 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage17::~AnnotatedMessage17() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage17_uint_data;
    const char qt_protobuf_AnnotatedMessage17_char_data[11];
} qt_protobuf_AnnotatedMessage17_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage17::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage17_metadata.data
};

void AnnotatedMessage17::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage17>();
    qRegisterMetaType<AnnotatedMessage17Repeated>();
}
AnnotatedMessage17::AnnotatedMessage17(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage17::AnnotatedMessage17(const AnnotatedMessage17 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage17 &AnnotatedMessage17::operator =(const AnnotatedMessage17 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage17::AnnotatedMessage17(AnnotatedMessage17 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage17 &AnnotatedMessage17::operator =(AnnotatedMessage17 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage17::operator ==(const AnnotatedMessage17 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage17::operator !=(const AnnotatedMessage17 &other) const
{
    return !this->operator ==(other);
}

AnnotatedMessage18::~AnnotatedMessage18() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 4> qt_protobuf_AnnotatedMessage18_uint_data;
    const char qt_protobuf_AnnotatedMessage18_char_data[11];
} qt_protobuf_AnnotatedMessage18_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
    },
    // uint_data
    {
        // JSON name offsets:
        0, /* = testField */
        10, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testField */
        // Property indices:
        1, /* = testField */
    },
    // char_data
    "testField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering AnnotatedMessage18::propertyOrdering = {
    &qt_protobuf_AnnotatedMessage18_metadata.data
};

void AnnotatedMessage18::registerTypes()
{
    qRegisterMetaType<AnnotatedMessage18>();
    qRegisterMetaType<AnnotatedMessage18Repeated>();
}
AnnotatedMessage18::AnnotatedMessage18(QObject *parent) : QObject(parent),
    m_testField(0)
{
}
AnnotatedMessage18::AnnotatedMessage18(const AnnotatedMessage18 &other) : QObject()
{
    setTestField(other.m_testField);
}
AnnotatedMessage18 &AnnotatedMessage18::operator =(const AnnotatedMessage18 &other)
{
    setTestField(other.m_testField);
    return *this;
}
AnnotatedMessage18::AnnotatedMessage18(AnnotatedMessage18 &&other) noexcept : QObject()
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
}
AnnotatedMessage18 &AnnotatedMessage18::operator =(AnnotatedMessage18 &&other) noexcept
{
    setTestField(std::exchange(other.m_testField, 0));
    other.testFieldChanged();
    return *this;
}
bool AnnotatedMessage18::operator ==(const AnnotatedMessage18 &other) const
{
    return m_testField == other.m_testField;
}
bool AnnotatedMessage18::operator !=(const AnnotatedMessage18 &other) const
{
    return !this->operator ==(other);
}

} // namespace qtprotobufnamespace::tests

#include "moc_annotation.qpb.cpp"
