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


#include "repeatedmessages.qpb.h"

#include <QtProtobuf/qprotobufregistration.h>

#include <cmath>

namespace qtprotobufnamespace::tests {

class RepeatedStringMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedStringMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedStringMessage_QtProtobufData(const RepeatedStringMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedString(other.m_testRepeatedString)
    {
    }

    QStringList m_testRepeatedString;
};

RepeatedStringMessage::~RepeatedStringMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedStringMessage_uint_data;
    const char qt_protobuf_RepeatedStringMessage_char_data[68];
} qt_protobuf_RepeatedStringMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        47, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        48, /* = testRepeatedString */
        67, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedString */
        // Property indices:
        0, /* = testRepeatedString */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedString */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedStringMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedString\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedStringMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedStringMessage_metadata.data
};

void RepeatedStringMessage::registerTypes()
{
    qRegisterMetaType<RepeatedStringMessage>();
    qRegisterMetaType<RepeatedStringMessageRepeated>();
}

RepeatedStringMessage::RepeatedStringMessage()
    : QProtobufMessage(&RepeatedStringMessage::staticMetaObject, &RepeatedStringMessage::staticPropertyOrdering),
      dptr(new RepeatedStringMessage_QtProtobufData)
{
}

RepeatedStringMessage::RepeatedStringMessage(const RepeatedStringMessage &other)
    = default;
RepeatedStringMessage &RepeatedStringMessage::operator =(const RepeatedStringMessage &other)
{
    RepeatedStringMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedStringMessage::RepeatedStringMessage(RepeatedStringMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedStringMessage &lhs, const RepeatedStringMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedString == rhs.dptr->m_testRepeatedString;
}

const QStringList &RepeatedStringMessage::testRepeatedString() const &
{
    return dptr->m_testRepeatedString;
}

void RepeatedStringMessage::setTestRepeatedString(const QStringList &testRepeatedString)
{
    if (dptr->m_testRepeatedString != testRepeatedString) {
        dptr.detach();
        dptr->m_testRepeatedString = testRepeatedString;
    }
}

void RepeatedStringMessage::setTestRepeatedString(QStringList &&testRepeatedString)
{
    if (dptr->m_testRepeatedString != testRepeatedString) {
        dptr.detach();
        dptr->m_testRepeatedString = std::move(testRepeatedString);
    }
}


class RepeatedDoubleMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedDoubleMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedDoubleMessage_QtProtobufData(const RepeatedDoubleMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedDouble(other.m_testRepeatedDouble)
    {
    }

    QtProtobuf::doubleList m_testRepeatedDouble;
};

RepeatedDoubleMessage::~RepeatedDoubleMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedDoubleMessage_uint_data;
    const char qt_protobuf_RepeatedDoubleMessage_char_data[68];
} qt_protobuf_RepeatedDoubleMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        47, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        48, /* = testRepeatedDouble */
        67, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedDouble */
        // Property indices:
        0, /* = testRepeatedDouble */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedDouble */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedDoubleMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedDouble\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedDoubleMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedDoubleMessage_metadata.data
};

void RepeatedDoubleMessage::registerTypes()
{
    qRegisterMetaType<RepeatedDoubleMessage>();
    qRegisterMetaType<RepeatedDoubleMessageRepeated>();
}

RepeatedDoubleMessage::RepeatedDoubleMessage()
    : QProtobufMessage(&RepeatedDoubleMessage::staticMetaObject, &RepeatedDoubleMessage::staticPropertyOrdering),
      dptr(new RepeatedDoubleMessage_QtProtobufData)
{
}

RepeatedDoubleMessage::RepeatedDoubleMessage(const RepeatedDoubleMessage &other)
    = default;
RepeatedDoubleMessage &RepeatedDoubleMessage::operator =(const RepeatedDoubleMessage &other)
{
    RepeatedDoubleMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedDoubleMessage::RepeatedDoubleMessage(RepeatedDoubleMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedDoubleMessage &lhs, const RepeatedDoubleMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedDouble == rhs.dptr->m_testRepeatedDouble;
}

const QtProtobuf::doubleList &RepeatedDoubleMessage::testRepeatedDouble() const &
{
    return dptr->m_testRepeatedDouble;
}

void RepeatedDoubleMessage::setTestRepeatedDouble(const QtProtobuf::doubleList &testRepeatedDouble)
{
    if (dptr->m_testRepeatedDouble != testRepeatedDouble) {
        dptr.detach();
        dptr->m_testRepeatedDouble = testRepeatedDouble;
    }
}

void RepeatedDoubleMessage::setTestRepeatedDouble(QtProtobuf::doubleList &&testRepeatedDouble)
{
    if (dptr->m_testRepeatedDouble != testRepeatedDouble) {
        dptr.detach();
        dptr->m_testRepeatedDouble = std::move(testRepeatedDouble);
    }
}


class RepeatedBytesMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedBytesMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedBytesMessage_QtProtobufData(const RepeatedBytesMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedBytes(other.m_testRepeatedBytes)
    {
    }

    QByteArrayList m_testRepeatedBytes;
};

RepeatedBytesMessage::~RepeatedBytesMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedBytesMessage_uint_data;
    const char qt_protobuf_RepeatedBytesMessage_char_data[66];
} qt_protobuf_RepeatedBytesMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        46, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        47, /* = testRepeatedBytes */
        65, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedBytes */
        // Property indices:
        0, /* = testRepeatedBytes */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedBytes */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedBytesMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedBytes\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedBytesMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedBytesMessage_metadata.data
};

void RepeatedBytesMessage::registerTypes()
{
    qRegisterMetaType<RepeatedBytesMessage>();
    qRegisterMetaType<RepeatedBytesMessageRepeated>();
}

RepeatedBytesMessage::RepeatedBytesMessage()
    : QProtobufMessage(&RepeatedBytesMessage::staticMetaObject, &RepeatedBytesMessage::staticPropertyOrdering),
      dptr(new RepeatedBytesMessage_QtProtobufData)
{
}

RepeatedBytesMessage::RepeatedBytesMessage(const RepeatedBytesMessage &other)
    = default;
RepeatedBytesMessage &RepeatedBytesMessage::operator =(const RepeatedBytesMessage &other)
{
    RepeatedBytesMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedBytesMessage::RepeatedBytesMessage(RepeatedBytesMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedBytesMessage &lhs, const RepeatedBytesMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedBytes == rhs.dptr->m_testRepeatedBytes;
}

const QByteArrayList &RepeatedBytesMessage::testRepeatedBytes() const &
{
    return dptr->m_testRepeatedBytes;
}

void RepeatedBytesMessage::setTestRepeatedBytes(const QByteArrayList &testRepeatedBytes)
{
    if (dptr->m_testRepeatedBytes != testRepeatedBytes) {
        dptr.detach();
        dptr->m_testRepeatedBytes = testRepeatedBytes;
    }
}

void RepeatedBytesMessage::setTestRepeatedBytes(QByteArrayList &&testRepeatedBytes)
{
    if (dptr->m_testRepeatedBytes != testRepeatedBytes) {
        dptr.detach();
        dptr->m_testRepeatedBytes = std::move(testRepeatedBytes);
    }
}


class RepeatedFloatMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedFloatMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedFloatMessage_QtProtobufData(const RepeatedFloatMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedFloat(other.m_testRepeatedFloat)
    {
    }

    QtProtobuf::floatList m_testRepeatedFloat;
};

RepeatedFloatMessage::~RepeatedFloatMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedFloatMessage_uint_data;
    const char qt_protobuf_RepeatedFloatMessage_char_data[66];
} qt_protobuf_RepeatedFloatMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        46, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        47, /* = testRepeatedFloat */
        65, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedFloat */
        // Property indices:
        0, /* = testRepeatedFloat */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedFloat */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedFloatMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedFloat\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedFloatMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedFloatMessage_metadata.data
};

void RepeatedFloatMessage::registerTypes()
{
    qRegisterMetaType<RepeatedFloatMessage>();
    qRegisterMetaType<RepeatedFloatMessageRepeated>();
}

RepeatedFloatMessage::RepeatedFloatMessage()
    : QProtobufMessage(&RepeatedFloatMessage::staticMetaObject, &RepeatedFloatMessage::staticPropertyOrdering),
      dptr(new RepeatedFloatMessage_QtProtobufData)
{
}

RepeatedFloatMessage::RepeatedFloatMessage(const RepeatedFloatMessage &other)
    = default;
RepeatedFloatMessage &RepeatedFloatMessage::operator =(const RepeatedFloatMessage &other)
{
    RepeatedFloatMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedFloatMessage::RepeatedFloatMessage(RepeatedFloatMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedFloatMessage &lhs, const RepeatedFloatMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedFloat == rhs.dptr->m_testRepeatedFloat;
}

const QtProtobuf::floatList &RepeatedFloatMessage::testRepeatedFloat() const &
{
    return dptr->m_testRepeatedFloat;
}

void RepeatedFloatMessage::setTestRepeatedFloat(const QtProtobuf::floatList &testRepeatedFloat)
{
    if (dptr->m_testRepeatedFloat != testRepeatedFloat) {
        dptr.detach();
        dptr->m_testRepeatedFloat = testRepeatedFloat;
    }
}

void RepeatedFloatMessage::setTestRepeatedFloat(QtProtobuf::floatList &&testRepeatedFloat)
{
    if (dptr->m_testRepeatedFloat != testRepeatedFloat) {
        dptr.detach();
        dptr->m_testRepeatedFloat = std::move(testRepeatedFloat);
    }
}


class RepeatedComplexMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedComplexMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedComplexMessage_QtProtobufData(const RepeatedComplexMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedComplex(other.m_testRepeatedComplex)
    {
    }

    ComplexMessageRepeated m_testRepeatedComplex;
};

RepeatedComplexMessage::~RepeatedComplexMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedComplexMessage_uint_data;
    const char qt_protobuf_RepeatedComplexMessage_char_data[70];
} qt_protobuf_RepeatedComplexMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        48, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        49, /* = testRepeatedComplex */
        69, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedComplex */
        // Property indices:
        0, /* = testRepeatedComplex */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated | QtProtobufPrivate::FieldFlag::Message), /* = testRepeatedComplex */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedComplexMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedComplex\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedComplexMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedComplexMessage_metadata.data
};

void RepeatedComplexMessage::registerTypes()
{
    qRegisterMetaType<RepeatedComplexMessage>();
    qRegisterMetaType<RepeatedComplexMessageRepeated>();
}

RepeatedComplexMessage::RepeatedComplexMessage()
    : QProtobufMessage(&RepeatedComplexMessage::staticMetaObject, &RepeatedComplexMessage::staticPropertyOrdering),
      dptr(new RepeatedComplexMessage_QtProtobufData)
{
}

RepeatedComplexMessage::RepeatedComplexMessage(const RepeatedComplexMessage &other)
    = default;
RepeatedComplexMessage &RepeatedComplexMessage::operator =(const RepeatedComplexMessage &other)
{
    RepeatedComplexMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedComplexMessage::RepeatedComplexMessage(RepeatedComplexMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedComplexMessage &lhs, const RepeatedComplexMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedComplex == rhs.dptr->m_testRepeatedComplex;
}

const ComplexMessageRepeated &RepeatedComplexMessage::testRepeatedComplex() const &
{
    return dptr->m_testRepeatedComplex;
}

void RepeatedComplexMessage::setTestRepeatedComplex(const ComplexMessageRepeated &testRepeatedComplex)
{
    if (dptr->m_testRepeatedComplex != testRepeatedComplex) {
        dptr.detach();
        dptr->m_testRepeatedComplex = testRepeatedComplex;
    }
}

void RepeatedComplexMessage::setTestRepeatedComplex(ComplexMessageRepeated &&testRepeatedComplex)
{
    if (dptr->m_testRepeatedComplex != testRepeatedComplex) {
        dptr.detach();
        dptr->m_testRepeatedComplex = std::move(testRepeatedComplex);
    }
}


class RepeatedSIntMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedSIntMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedSIntMessage_QtProtobufData(const RepeatedSIntMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::sint32List m_testRepeatedInt;
};

RepeatedSIntMessage::~RepeatedSIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedSIntMessage_uint_data;
    const char qt_protobuf_RepeatedSIntMessage_char_data[63];
} qt_protobuf_RepeatedSIntMessage_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, /* = testRepeatedInt */
        62, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedSIntMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedSIntMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedSIntMessage_metadata.data
};

void RepeatedSIntMessage::registerTypes()
{
    qRegisterMetaType<RepeatedSIntMessage>();
    qRegisterMetaType<RepeatedSIntMessageRepeated>();
}

RepeatedSIntMessage::RepeatedSIntMessage()
    : QProtobufMessage(&RepeatedSIntMessage::staticMetaObject, &RepeatedSIntMessage::staticPropertyOrdering),
      dptr(new RepeatedSIntMessage_QtProtobufData)
{
}

RepeatedSIntMessage::RepeatedSIntMessage(const RepeatedSIntMessage &other)
    = default;
RepeatedSIntMessage &RepeatedSIntMessage::operator =(const RepeatedSIntMessage &other)
{
    RepeatedSIntMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedSIntMessage::RepeatedSIntMessage(RepeatedSIntMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedSIntMessage &lhs, const RepeatedSIntMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::sint32List &RepeatedSIntMessage::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedSIntMessage::setTestRepeatedInt(const QtProtobuf::sint32List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedSIntMessage::setTestRepeatedInt(QtProtobuf::sint32List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedIntMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedIntMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedIntMessage_QtProtobufData(const RepeatedIntMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::int32List m_testRepeatedInt;
};

RepeatedIntMessage::~RepeatedIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedIntMessage_uint_data;
    const char qt_protobuf_RepeatedIntMessage_char_data[62];
} qt_protobuf_RepeatedIntMessage_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, /* = testRepeatedInt */
        61, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedIntMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedIntMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedIntMessage_metadata.data
};

void RepeatedIntMessage::registerTypes()
{
    qRegisterMetaType<RepeatedIntMessage>();
    qRegisterMetaType<RepeatedIntMessageRepeated>();
}

RepeatedIntMessage::RepeatedIntMessage()
    : QProtobufMessage(&RepeatedIntMessage::staticMetaObject, &RepeatedIntMessage::staticPropertyOrdering),
      dptr(new RepeatedIntMessage_QtProtobufData)
{
}

RepeatedIntMessage::RepeatedIntMessage(const RepeatedIntMessage &other)
    = default;
RepeatedIntMessage &RepeatedIntMessage::operator =(const RepeatedIntMessage &other)
{
    RepeatedIntMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedIntMessage::RepeatedIntMessage(RepeatedIntMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedIntMessage &lhs, const RepeatedIntMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::int32List &RepeatedIntMessage::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedIntMessage::setTestRepeatedInt(const QtProtobuf::int32List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedIntMessage::setTestRepeatedInt(QtProtobuf::int32List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedUIntMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedUIntMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedUIntMessage_QtProtobufData(const RepeatedUIntMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::uint32List m_testRepeatedInt;
};

RepeatedUIntMessage::~RepeatedUIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedUIntMessage_uint_data;
    const char qt_protobuf_RepeatedUIntMessage_char_data[63];
} qt_protobuf_RepeatedUIntMessage_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, /* = testRepeatedInt */
        62, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedUIntMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedUIntMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedUIntMessage_metadata.data
};

void RepeatedUIntMessage::registerTypes()
{
    qRegisterMetaType<RepeatedUIntMessage>();
    qRegisterMetaType<RepeatedUIntMessageRepeated>();
}

RepeatedUIntMessage::RepeatedUIntMessage()
    : QProtobufMessage(&RepeatedUIntMessage::staticMetaObject, &RepeatedUIntMessage::staticPropertyOrdering),
      dptr(new RepeatedUIntMessage_QtProtobufData)
{
}

RepeatedUIntMessage::RepeatedUIntMessage(const RepeatedUIntMessage &other)
    = default;
RepeatedUIntMessage &RepeatedUIntMessage::operator =(const RepeatedUIntMessage &other)
{
    RepeatedUIntMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedUIntMessage::RepeatedUIntMessage(RepeatedUIntMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedUIntMessage &lhs, const RepeatedUIntMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::uint32List &RepeatedUIntMessage::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedUIntMessage::setTestRepeatedInt(const QtProtobuf::uint32List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedUIntMessage::setTestRepeatedInt(QtProtobuf::uint32List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedSInt64Message_QtProtobufData : public QSharedData
{
public:
    RepeatedSInt64Message_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedSInt64Message_QtProtobufData(const RepeatedSInt64Message_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::sint64List m_testRepeatedInt;
};

RepeatedSInt64Message::~RepeatedSInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedSInt64Message_uint_data;
    const char qt_protobuf_RepeatedSInt64Message_char_data[65];
} qt_protobuf_RepeatedSInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        47, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        48, /* = testRepeatedInt */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedSInt64Message\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedSInt64Message::staticPropertyOrdering = {
    &qt_protobuf_RepeatedSInt64Message_metadata.data
};

void RepeatedSInt64Message::registerTypes()
{
    qRegisterMetaType<RepeatedSInt64Message>();
    qRegisterMetaType<RepeatedSInt64MessageRepeated>();
}

RepeatedSInt64Message::RepeatedSInt64Message()
    : QProtobufMessage(&RepeatedSInt64Message::staticMetaObject, &RepeatedSInt64Message::staticPropertyOrdering),
      dptr(new RepeatedSInt64Message_QtProtobufData)
{
}

RepeatedSInt64Message::RepeatedSInt64Message(const RepeatedSInt64Message &other)
    = default;
RepeatedSInt64Message &RepeatedSInt64Message::operator =(const RepeatedSInt64Message &other)
{
    RepeatedSInt64Message temp(other);
    swap(temp);
    return *this;
}
RepeatedSInt64Message::RepeatedSInt64Message(RepeatedSInt64Message &&other) noexcept
    = default;
bool comparesEqual(const RepeatedSInt64Message &lhs, const RepeatedSInt64Message &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::sint64List &RepeatedSInt64Message::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedSInt64Message::setTestRepeatedInt(const QtProtobuf::sint64List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedSInt64Message::setTestRepeatedInt(QtProtobuf::sint64List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedInt64Message_QtProtobufData : public QSharedData
{
public:
    RepeatedInt64Message_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedInt64Message_QtProtobufData(const RepeatedInt64Message_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::int64List m_testRepeatedInt;
};

RepeatedInt64Message::~RepeatedInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedInt64Message_uint_data;
    const char qt_protobuf_RepeatedInt64Message_char_data[64];
} qt_protobuf_RepeatedInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        46, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        47, /* = testRepeatedInt */
        63, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedInt64Message\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedInt64Message::staticPropertyOrdering = {
    &qt_protobuf_RepeatedInt64Message_metadata.data
};

void RepeatedInt64Message::registerTypes()
{
    qRegisterMetaType<RepeatedInt64Message>();
    qRegisterMetaType<RepeatedInt64MessageRepeated>();
}

RepeatedInt64Message::RepeatedInt64Message()
    : QProtobufMessage(&RepeatedInt64Message::staticMetaObject, &RepeatedInt64Message::staticPropertyOrdering),
      dptr(new RepeatedInt64Message_QtProtobufData)
{
}

RepeatedInt64Message::RepeatedInt64Message(const RepeatedInt64Message &other)
    = default;
RepeatedInt64Message &RepeatedInt64Message::operator =(const RepeatedInt64Message &other)
{
    RepeatedInt64Message temp(other);
    swap(temp);
    return *this;
}
RepeatedInt64Message::RepeatedInt64Message(RepeatedInt64Message &&other) noexcept
    = default;
bool comparesEqual(const RepeatedInt64Message &lhs, const RepeatedInt64Message &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::int64List &RepeatedInt64Message::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedInt64Message::setTestRepeatedInt(const QtProtobuf::int64List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedInt64Message::setTestRepeatedInt(QtProtobuf::int64List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedUInt64Message_QtProtobufData : public QSharedData
{
public:
    RepeatedUInt64Message_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedUInt64Message_QtProtobufData(const RepeatedUInt64Message_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::uint64List m_testRepeatedInt;
};

RepeatedUInt64Message::~RepeatedUInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedUInt64Message_uint_data;
    const char qt_protobuf_RepeatedUInt64Message_char_data[65];
} qt_protobuf_RepeatedUInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        47, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        48, /* = testRepeatedInt */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedUInt64Message\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedUInt64Message::staticPropertyOrdering = {
    &qt_protobuf_RepeatedUInt64Message_metadata.data
};

void RepeatedUInt64Message::registerTypes()
{
    qRegisterMetaType<RepeatedUInt64Message>();
    qRegisterMetaType<RepeatedUInt64MessageRepeated>();
}

RepeatedUInt64Message::RepeatedUInt64Message()
    : QProtobufMessage(&RepeatedUInt64Message::staticMetaObject, &RepeatedUInt64Message::staticPropertyOrdering),
      dptr(new RepeatedUInt64Message_QtProtobufData)
{
}

RepeatedUInt64Message::RepeatedUInt64Message(const RepeatedUInt64Message &other)
    = default;
RepeatedUInt64Message &RepeatedUInt64Message::operator =(const RepeatedUInt64Message &other)
{
    RepeatedUInt64Message temp(other);
    swap(temp);
    return *this;
}
RepeatedUInt64Message::RepeatedUInt64Message(RepeatedUInt64Message &&other) noexcept
    = default;
bool comparesEqual(const RepeatedUInt64Message &lhs, const RepeatedUInt64Message &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::uint64List &RepeatedUInt64Message::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedUInt64Message::setTestRepeatedInt(const QtProtobuf::uint64List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedUInt64Message::setTestRepeatedInt(QtProtobuf::uint64List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedFixedIntMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedFixedIntMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedFixedIntMessage_QtProtobufData(const RepeatedFixedIntMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::fixed32List m_testRepeatedInt;
};

RepeatedFixedIntMessage::~RepeatedFixedIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedFixedIntMessage_uint_data;
    const char qt_protobuf_RepeatedFixedIntMessage_char_data[67];
} qt_protobuf_RepeatedFixedIntMessage_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, /* = testRepeatedInt */
        66, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedFixedIntMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedFixedIntMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedFixedIntMessage_metadata.data
};

void RepeatedFixedIntMessage::registerTypes()
{
    qRegisterMetaType<RepeatedFixedIntMessage>();
    qRegisterMetaType<RepeatedFixedIntMessageRepeated>();
}

RepeatedFixedIntMessage::RepeatedFixedIntMessage()
    : QProtobufMessage(&RepeatedFixedIntMessage::staticMetaObject, &RepeatedFixedIntMessage::staticPropertyOrdering),
      dptr(new RepeatedFixedIntMessage_QtProtobufData)
{
}

RepeatedFixedIntMessage::RepeatedFixedIntMessage(const RepeatedFixedIntMessage &other)
    = default;
RepeatedFixedIntMessage &RepeatedFixedIntMessage::operator =(const RepeatedFixedIntMessage &other)
{
    RepeatedFixedIntMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedFixedIntMessage::RepeatedFixedIntMessage(RepeatedFixedIntMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedFixedIntMessage &lhs, const RepeatedFixedIntMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::fixed32List &RepeatedFixedIntMessage::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedFixedIntMessage::setTestRepeatedInt(const QtProtobuf::fixed32List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedFixedIntMessage::setTestRepeatedInt(QtProtobuf::fixed32List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedSFixedIntMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedSFixedIntMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedSFixedIntMessage_QtProtobufData(const RepeatedSFixedIntMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::sfixed32List m_testRepeatedInt;
};

RepeatedSFixedIntMessage::~RepeatedSFixedIntMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedSFixedIntMessage_uint_data;
    const char qt_protobuf_RepeatedSFixedIntMessage_char_data[68];
} qt_protobuf_RepeatedSFixedIntMessage_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, /* = testRepeatedInt */
        67, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedSFixedIntMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedSFixedIntMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedSFixedIntMessage_metadata.data
};

void RepeatedSFixedIntMessage::registerTypes()
{
    qRegisterMetaType<RepeatedSFixedIntMessage>();
    qRegisterMetaType<RepeatedSFixedIntMessageRepeated>();
}

RepeatedSFixedIntMessage::RepeatedSFixedIntMessage()
    : QProtobufMessage(&RepeatedSFixedIntMessage::staticMetaObject, &RepeatedSFixedIntMessage::staticPropertyOrdering),
      dptr(new RepeatedSFixedIntMessage_QtProtobufData)
{
}

RepeatedSFixedIntMessage::RepeatedSFixedIntMessage(const RepeatedSFixedIntMessage &other)
    = default;
RepeatedSFixedIntMessage &RepeatedSFixedIntMessage::operator =(const RepeatedSFixedIntMessage &other)
{
    RepeatedSFixedIntMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedSFixedIntMessage::RepeatedSFixedIntMessage(RepeatedSFixedIntMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedSFixedIntMessage &lhs, const RepeatedSFixedIntMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::sfixed32List &RepeatedSFixedIntMessage::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedSFixedIntMessage::setTestRepeatedInt(const QtProtobuf::sfixed32List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedSFixedIntMessage::setTestRepeatedInt(QtProtobuf::sfixed32List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedFixedInt64Message_QtProtobufData : public QSharedData
{
public:
    RepeatedFixedInt64Message_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedFixedInt64Message_QtProtobufData(const RepeatedFixedInt64Message_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::fixed64List m_testRepeatedInt;
};

RepeatedFixedInt64Message::~RepeatedFixedInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedFixedInt64Message_uint_data;
    const char qt_protobuf_RepeatedFixedInt64Message_char_data[69];
} qt_protobuf_RepeatedFixedInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        51, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        52, /* = testRepeatedInt */
        68, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedFixedInt64Message\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedFixedInt64Message::staticPropertyOrdering = {
    &qt_protobuf_RepeatedFixedInt64Message_metadata.data
};

void RepeatedFixedInt64Message::registerTypes()
{
    qRegisterMetaType<RepeatedFixedInt64Message>();
    qRegisterMetaType<RepeatedFixedInt64MessageRepeated>();
}

RepeatedFixedInt64Message::RepeatedFixedInt64Message()
    : QProtobufMessage(&RepeatedFixedInt64Message::staticMetaObject, &RepeatedFixedInt64Message::staticPropertyOrdering),
      dptr(new RepeatedFixedInt64Message_QtProtobufData)
{
}

RepeatedFixedInt64Message::RepeatedFixedInt64Message(const RepeatedFixedInt64Message &other)
    = default;
RepeatedFixedInt64Message &RepeatedFixedInt64Message::operator =(const RepeatedFixedInt64Message &other)
{
    RepeatedFixedInt64Message temp(other);
    swap(temp);
    return *this;
}
RepeatedFixedInt64Message::RepeatedFixedInt64Message(RepeatedFixedInt64Message &&other) noexcept
    = default;
bool comparesEqual(const RepeatedFixedInt64Message &lhs, const RepeatedFixedInt64Message &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::fixed64List &RepeatedFixedInt64Message::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedFixedInt64Message::setTestRepeatedInt(const QtProtobuf::fixed64List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedFixedInt64Message::setTestRepeatedInt(QtProtobuf::fixed64List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedSFixedInt64Message_QtProtobufData : public QSharedData
{
public:
    RepeatedSFixedInt64Message_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedSFixedInt64Message_QtProtobufData(const RepeatedSFixedInt64Message_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedInt(other.m_testRepeatedInt)
    {
    }

    QtProtobuf::sfixed64List m_testRepeatedInt;
};

RepeatedSFixedInt64Message::~RepeatedSFixedInt64Message() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedSFixedInt64Message_uint_data;
    const char qt_protobuf_RepeatedSFixedInt64Message_char_data[70];
} qt_protobuf_RepeatedSFixedInt64Message_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        52, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        53, /* = testRepeatedInt */
        69, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedInt */
        // Property indices:
        0, /* = testRepeatedInt */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedInt */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedSFixedInt64Message\0" /* = full message name */
    /* field char_data: */
    "testRepeatedInt\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedSFixedInt64Message::staticPropertyOrdering = {
    &qt_protobuf_RepeatedSFixedInt64Message_metadata.data
};

void RepeatedSFixedInt64Message::registerTypes()
{
    qRegisterMetaType<RepeatedSFixedInt64Message>();
    qRegisterMetaType<RepeatedSFixedInt64MessageRepeated>();
}

RepeatedSFixedInt64Message::RepeatedSFixedInt64Message()
    : QProtobufMessage(&RepeatedSFixedInt64Message::staticMetaObject, &RepeatedSFixedInt64Message::staticPropertyOrdering),
      dptr(new RepeatedSFixedInt64Message_QtProtobufData)
{
}

RepeatedSFixedInt64Message::RepeatedSFixedInt64Message(const RepeatedSFixedInt64Message &other)
    = default;
RepeatedSFixedInt64Message &RepeatedSFixedInt64Message::operator =(const RepeatedSFixedInt64Message &other)
{
    RepeatedSFixedInt64Message temp(other);
    swap(temp);
    return *this;
}
RepeatedSFixedInt64Message::RepeatedSFixedInt64Message(RepeatedSFixedInt64Message &&other) noexcept
    = default;
bool comparesEqual(const RepeatedSFixedInt64Message &lhs, const RepeatedSFixedInt64Message &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedInt == rhs.dptr->m_testRepeatedInt;
}

const QtProtobuf::sfixed64List &RepeatedSFixedInt64Message::testRepeatedInt() const &
{
    return dptr->m_testRepeatedInt;
}

void RepeatedSFixedInt64Message::setTestRepeatedInt(const QtProtobuf::sfixed64List &testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = testRepeatedInt;
    }
}

void RepeatedSFixedInt64Message::setTestRepeatedInt(QtProtobuf::sfixed64List &&testRepeatedInt)
{
    if (dptr->m_testRepeatedInt != testRepeatedInt) {
        dptr.detach();
        dptr->m_testRepeatedInt = std::move(testRepeatedInt);
    }
}


class RepeatedBoolMessage_QtProtobufData : public QSharedData
{
public:
    RepeatedBoolMessage_QtProtobufData()
        : QSharedData()
    {
    }

    RepeatedBoolMessage_QtProtobufData(const RepeatedBoolMessage_QtProtobufData &other)
        : QSharedData(other),
          m_testRepeatedBool(other.m_testRepeatedBool)
    {
    }

    QtProtobuf::boolList m_testRepeatedBool;
};

RepeatedBoolMessage::~RepeatedBoolMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_RepeatedBoolMessage_uint_data;
    const char qt_protobuf_RepeatedBoolMessage_char_data[64];
} qt_protobuf_RepeatedBoolMessage_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, /* = testRepeatedBool */
        63, /* = end-of-string-marker */
        // Field numbers:
        1, /* = testRepeatedBool */
        // Property indices:
        0, /* = testRepeatedBool */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = testRepeatedBool */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.RepeatedBoolMessage\0" /* = full message name */
    /* field char_data: */
    "testRepeatedBool\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering RepeatedBoolMessage::staticPropertyOrdering = {
    &qt_protobuf_RepeatedBoolMessage_metadata.data
};

void RepeatedBoolMessage::registerTypes()
{
    qRegisterMetaType<RepeatedBoolMessage>();
    qRegisterMetaType<RepeatedBoolMessageRepeated>();
}

RepeatedBoolMessage::RepeatedBoolMessage()
    : QProtobufMessage(&RepeatedBoolMessage::staticMetaObject, &RepeatedBoolMessage::staticPropertyOrdering),
      dptr(new RepeatedBoolMessage_QtProtobufData)
{
}

RepeatedBoolMessage::RepeatedBoolMessage(const RepeatedBoolMessage &other)
    = default;
RepeatedBoolMessage &RepeatedBoolMessage::operator =(const RepeatedBoolMessage &other)
{
    RepeatedBoolMessage temp(other);
    swap(temp);
    return *this;
}
RepeatedBoolMessage::RepeatedBoolMessage(RepeatedBoolMessage &&other) noexcept
    = default;
bool comparesEqual(const RepeatedBoolMessage &lhs, const RepeatedBoolMessage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_testRepeatedBool == rhs.dptr->m_testRepeatedBool;
}

const QtProtobuf::boolList &RepeatedBoolMessage::testRepeatedBool() const &
{
    return dptr->m_testRepeatedBool;
}

void RepeatedBoolMessage::setTestRepeatedBool(const QtProtobuf::boolList &testRepeatedBool)
{
    if (dptr->m_testRepeatedBool != testRepeatedBool) {
        dptr.detach();
        dptr->m_testRepeatedBool = testRepeatedBool;
    }
}

void RepeatedBoolMessage::setTestRepeatedBool(QtProtobuf::boolList &&testRepeatedBool)
{
    if (dptr->m_testRepeatedBool != testRepeatedBool) {
        dptr.detach();
        dptr->m_testRepeatedBool = std::move(testRepeatedBool);
    }
}

} // namespace qtprotobufnamespace::tests

#include "moc_repeatedmessages.qpb.cpp"
