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


#include "qtprotobufnamespace/tests/mapmessages.qpb.h"

#include <QtProtobuf/qprotobufregistration.h>

#include <cmath>

namespace qtprotobufnamespace::tests {

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

    SimpleSInt32StringMapMessage_QtProtobufData(const SimpleSInt32StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32StringMapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32StringMapMessage::~SimpleSInt32StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32StringMapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32StringMapMessage_char_data[65];
} qt_protobuf_SimpleSInt32StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32StringMapMessage_metadata.data
};

void SimpleSInt32StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32StringMapMessage>();
    qRegisterMetaType<SimpleSInt32StringMapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QString>();
}

SimpleSInt32StringMapMessage::SimpleSInt32StringMapMessage()
    : QProtobufMessage(&SimpleSInt32StringMapMessage::staticMetaObject, &SimpleSInt32StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32StringMapMessage_QtProtobufData)
{
}

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

const SimpleSInt32StringMapMessage::MapFieldEntry &SimpleSInt32StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32StringMapMessage::setMapField(const SimpleSInt32StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32StringMapMessage::setMapField(SimpleSInt32StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64StringMapMessage_QtProtobufData(const SimpleSInt64StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64StringMapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64StringMapMessage::~SimpleSInt64StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64StringMapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64StringMapMessage_char_data[65];
} qt_protobuf_SimpleSInt64StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64StringMapMessage_metadata.data
};

void SimpleSInt64StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64StringMapMessage>();
    qRegisterMetaType<SimpleSInt64StringMapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QString>();
}

SimpleSInt64StringMapMessage::SimpleSInt64StringMapMessage()
    : QProtobufMessage(&SimpleSInt64StringMapMessage::staticMetaObject, &SimpleSInt64StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64StringMapMessage_QtProtobufData)
{
}

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

const SimpleSInt64StringMapMessage::MapFieldEntry &SimpleSInt64StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64StringMapMessage::setMapField(const SimpleSInt64StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64StringMapMessage::setMapField(SimpleSInt64StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32StringMapMessage_QtProtobufData(const SimpleInt32StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32StringMapMessage::MapFieldEntry m_mapField;
};

SimpleInt32StringMapMessage::~SimpleInt32StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32StringMapMessage_uint_data;
    const char qt_protobuf_SimpleInt32StringMapMessage_char_data[64];
} qt_protobuf_SimpleInt32StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32StringMapMessage_metadata.data
};

void SimpleInt32StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32StringMapMessage>();
    qRegisterMetaType<SimpleInt32StringMapMessageRepeated>();
    qRegisterMetaType<SimpleInt32StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QString>();
}

SimpleInt32StringMapMessage::SimpleInt32StringMapMessage()
    : QProtobufMessage(&SimpleInt32StringMapMessage::staticMetaObject, &SimpleInt32StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32StringMapMessage_QtProtobufData)
{
}

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

const SimpleInt32StringMapMessage::MapFieldEntry &SimpleInt32StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32StringMapMessage::setMapField(const SimpleInt32StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32StringMapMessage::setMapField(SimpleInt32StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64StringMapMessage_QtProtobufData(const SimpleInt64StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64StringMapMessage::MapFieldEntry m_mapField;
};

SimpleInt64StringMapMessage::~SimpleInt64StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64StringMapMessage_uint_data;
    const char qt_protobuf_SimpleInt64StringMapMessage_char_data[64];
} qt_protobuf_SimpleInt64StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64StringMapMessage_metadata.data
};

void SimpleInt64StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64StringMapMessage>();
    qRegisterMetaType<SimpleInt64StringMapMessageRepeated>();
    qRegisterMetaType<SimpleInt64StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QString>();
}

SimpleInt64StringMapMessage::SimpleInt64StringMapMessage()
    : QProtobufMessage(&SimpleInt64StringMapMessage::staticMetaObject, &SimpleInt64StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64StringMapMessage_QtProtobufData)
{
}

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

const SimpleInt64StringMapMessage::MapFieldEntry &SimpleInt64StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64StringMapMessage::setMapField(const SimpleInt64StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64StringMapMessage::setMapField(SimpleInt64StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32StringMapMessage_QtProtobufData(const SimpleUInt32StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32StringMapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32StringMapMessage::~SimpleUInt32StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32StringMapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32StringMapMessage_char_data[65];
} qt_protobuf_SimpleUInt32StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32StringMapMessage_metadata.data
};

void SimpleUInt32StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32StringMapMessage>();
    qRegisterMetaType<SimpleUInt32StringMapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QString>();
}

SimpleUInt32StringMapMessage::SimpleUInt32StringMapMessage()
    : QProtobufMessage(&SimpleUInt32StringMapMessage::staticMetaObject, &SimpleUInt32StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32StringMapMessage_QtProtobufData)
{
}

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

const SimpleUInt32StringMapMessage::MapFieldEntry &SimpleUInt32StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32StringMapMessage::setMapField(const SimpleUInt32StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32StringMapMessage::setMapField(SimpleUInt32StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64StringMapMessage_QtProtobufData(const SimpleUInt64StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64StringMapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64StringMapMessage::~SimpleUInt64StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64StringMapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64StringMapMessage_char_data[65];
} qt_protobuf_SimpleUInt64StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64StringMapMessage_metadata.data
};

void SimpleUInt64StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64StringMapMessage>();
    qRegisterMetaType<SimpleUInt64StringMapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QString>();
}

SimpleUInt64StringMapMessage::SimpleUInt64StringMapMessage()
    : QProtobufMessage(&SimpleUInt64StringMapMessage::staticMetaObject, &SimpleUInt64StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64StringMapMessage_QtProtobufData)
{
}

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

const SimpleUInt64StringMapMessage::MapFieldEntry &SimpleUInt64StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64StringMapMessage::setMapField(const SimpleUInt64StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64StringMapMessage::setMapField(SimpleUInt64StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32StringMapMessage_QtProtobufData(const SimpleFixed32StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32StringMapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32StringMapMessage::~SimpleFixed32StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32StringMapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32StringMapMessage_char_data[66];
} qt_protobuf_SimpleFixed32StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32StringMapMessage_metadata.data
};

void SimpleFixed32StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32StringMapMessage>();
    qRegisterMetaType<SimpleFixed32StringMapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QString>();
}

SimpleFixed32StringMapMessage::SimpleFixed32StringMapMessage()
    : QProtobufMessage(&SimpleFixed32StringMapMessage::staticMetaObject, &SimpleFixed32StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32StringMapMessage_QtProtobufData)
{
}

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

const SimpleFixed32StringMapMessage::MapFieldEntry &SimpleFixed32StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32StringMapMessage::setMapField(const SimpleFixed32StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32StringMapMessage::setMapField(SimpleFixed32StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64StringMapMessage_QtProtobufData(const SimpleFixed64StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64StringMapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64StringMapMessage::~SimpleFixed64StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64StringMapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64StringMapMessage_char_data[66];
} qt_protobuf_SimpleFixed64StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64StringMapMessage_metadata.data
};

void SimpleFixed64StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64StringMapMessage>();
    qRegisterMetaType<SimpleFixed64StringMapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QString>();
}

SimpleFixed64StringMapMessage::SimpleFixed64StringMapMessage()
    : QProtobufMessage(&SimpleFixed64StringMapMessage::staticMetaObject, &SimpleFixed64StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64StringMapMessage_QtProtobufData)
{
}

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

const SimpleFixed64StringMapMessage::MapFieldEntry &SimpleFixed64StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64StringMapMessage::setMapField(const SimpleFixed64StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64StringMapMessage::setMapField(SimpleFixed64StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32StringMapMessage_QtProtobufData(const SimpleSFixed32StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32StringMapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32StringMapMessage::~SimpleSFixed32StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32StringMapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32StringMapMessage_char_data[67];
} qt_protobuf_SimpleSFixed32StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32StringMapMessage_metadata.data
};

void SimpleSFixed32StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32StringMapMessage>();
    qRegisterMetaType<SimpleSFixed32StringMapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QString>();
}

SimpleSFixed32StringMapMessage::SimpleSFixed32StringMapMessage()
    : QProtobufMessage(&SimpleSFixed32StringMapMessage::staticMetaObject, &SimpleSFixed32StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32StringMapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32StringMapMessage::MapFieldEntry &SimpleSFixed32StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32StringMapMessage::setMapField(const SimpleSFixed32StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32StringMapMessage::setMapField(SimpleSFixed32StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64StringMapMessage_QtProtobufData(const SimpleSFixed64StringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64StringMapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64StringMapMessage::~SimpleSFixed64StringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64StringMapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64StringMapMessage_char_data[67];
} qt_protobuf_SimpleSFixed64StringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64StringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64StringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64StringMapMessage_metadata.data
};

void SimpleSFixed64StringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64StringMapMessage>();
    qRegisterMetaType<SimpleSFixed64StringMapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64StringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QString>();
}

SimpleSFixed64StringMapMessage::SimpleSFixed64StringMapMessage()
    : QProtobufMessage(&SimpleSFixed64StringMapMessage::staticMetaObject, &SimpleSFixed64StringMapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64StringMapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64StringMapMessage::MapFieldEntry &SimpleSFixed64StringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64StringMapMessage::setMapField(const SimpleSFixed64StringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64StringMapMessage::setMapField(SimpleSFixed64StringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringStringMapMessage_QtProtobufData(const SimpleStringStringMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringStringMapMessage::MapFieldEntry m_mapField;
};

SimpleStringStringMapMessage::~SimpleStringStringMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringStringMapMessage_uint_data;
    const char qt_protobuf_SimpleStringStringMapMessage_char_data[65];
} qt_protobuf_SimpleStringStringMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringStringMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringStringMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringStringMapMessage_metadata.data
};

void SimpleStringStringMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringStringMapMessage>();
    qRegisterMetaType<SimpleStringStringMapMessageRepeated>();
    qRegisterMetaType<SimpleStringStringMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QString>();
}

SimpleStringStringMapMessage::SimpleStringStringMapMessage()
    : QProtobufMessage(&SimpleStringStringMapMessage::staticMetaObject, &SimpleStringStringMapMessage::staticPropertyOrdering),
      dptr(new SimpleStringStringMapMessage_QtProtobufData)
{
}

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

const SimpleStringStringMapMessage::MapFieldEntry &SimpleStringStringMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringStringMapMessage::setMapField(const SimpleStringStringMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringStringMapMessage::setMapField(SimpleStringStringMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32SInt32MapMessage_QtProtobufData(const SimpleSInt32SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32SInt32MapMessage::~SimpleSInt32SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32SInt32MapMessage_char_data[65];
} qt_protobuf_SimpleSInt32SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32SInt32MapMessage_metadata.data
};

void SimpleSInt32SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32SInt32MapMessage>();
    qRegisterMetaType<SimpleSInt32SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::sint32>();
}

SimpleSInt32SInt32MapMessage::SimpleSInt32SInt32MapMessage()
    : QProtobufMessage(&SimpleSInt32SInt32MapMessage::staticMetaObject, &SimpleSInt32SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32SInt32MapMessage::MapFieldEntry &SimpleSInt32SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32SInt32MapMessage::setMapField(const SimpleSInt32SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32SInt32MapMessage::setMapField(SimpleSInt32SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64SInt32MapMessage_QtProtobufData(const SimpleSInt64SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64SInt32MapMessage::~SimpleSInt64SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64SInt32MapMessage_char_data[65];
} qt_protobuf_SimpleSInt64SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64SInt32MapMessage_metadata.data
};

void SimpleSInt64SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64SInt32MapMessage>();
    qRegisterMetaType<SimpleSInt64SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::sint32>();
}

SimpleSInt64SInt32MapMessage::SimpleSInt64SInt32MapMessage()
    : QProtobufMessage(&SimpleSInt64SInt32MapMessage::staticMetaObject, &SimpleSInt64SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64SInt32MapMessage::MapFieldEntry &SimpleSInt64SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64SInt32MapMessage::setMapField(const SimpleSInt64SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64SInt32MapMessage::setMapField(SimpleSInt64SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32SInt32MapMessage_QtProtobufData(const SimpleInt32SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32SInt32MapMessage::~SimpleInt32SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32SInt32MapMessage_char_data[64];
} qt_protobuf_SimpleInt32SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32SInt32MapMessage_metadata.data
};

void SimpleInt32SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32SInt32MapMessage>();
    qRegisterMetaType<SimpleInt32SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::sint32>();
}

SimpleInt32SInt32MapMessage::SimpleInt32SInt32MapMessage()
    : QProtobufMessage(&SimpleInt32SInt32MapMessage::staticMetaObject, &SimpleInt32SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleInt32SInt32MapMessage::MapFieldEntry &SimpleInt32SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32SInt32MapMessage::setMapField(const SimpleInt32SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32SInt32MapMessage::setMapField(SimpleInt32SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64SInt32MapMessage_QtProtobufData(const SimpleInt64SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64SInt32MapMessage::~SimpleInt64SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64SInt32MapMessage_char_data[64];
} qt_protobuf_SimpleInt64SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64SInt32MapMessage_metadata.data
};

void SimpleInt64SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64SInt32MapMessage>();
    qRegisterMetaType<SimpleInt64SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::sint32>();
}

SimpleInt64SInt32MapMessage::SimpleInt64SInt32MapMessage()
    : QProtobufMessage(&SimpleInt64SInt32MapMessage::staticMetaObject, &SimpleInt64SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleInt64SInt32MapMessage::MapFieldEntry &SimpleInt64SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64SInt32MapMessage::setMapField(const SimpleInt64SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64SInt32MapMessage::setMapField(SimpleInt64SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32SInt32MapMessage_QtProtobufData(const SimpleUInt32SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32SInt32MapMessage::~SimpleUInt32SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32SInt32MapMessage_char_data[65];
} qt_protobuf_SimpleUInt32SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32SInt32MapMessage_metadata.data
};

void SimpleUInt32SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32SInt32MapMessage>();
    qRegisterMetaType<SimpleUInt32SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::sint32>();
}

SimpleUInt32SInt32MapMessage::SimpleUInt32SInt32MapMessage()
    : QProtobufMessage(&SimpleUInt32SInt32MapMessage::staticMetaObject, &SimpleUInt32SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32SInt32MapMessage::MapFieldEntry &SimpleUInt32SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32SInt32MapMessage::setMapField(const SimpleUInt32SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32SInt32MapMessage::setMapField(SimpleUInt32SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64SInt32MapMessage_QtProtobufData(const SimpleUInt64SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64SInt32MapMessage::~SimpleUInt64SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64SInt32MapMessage_char_data[65];
} qt_protobuf_SimpleUInt64SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64SInt32MapMessage_metadata.data
};

void SimpleUInt64SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64SInt32MapMessage>();
    qRegisterMetaType<SimpleUInt64SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::sint32>();
}

SimpleUInt64SInt32MapMessage::SimpleUInt64SInt32MapMessage()
    : QProtobufMessage(&SimpleUInt64SInt32MapMessage::staticMetaObject, &SimpleUInt64SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64SInt32MapMessage::MapFieldEntry &SimpleUInt64SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64SInt32MapMessage::setMapField(const SimpleUInt64SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64SInt32MapMessage::setMapField(SimpleUInt64SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32SInt32MapMessage_QtProtobufData(const SimpleFixed32SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32SInt32MapMessage::~SimpleFixed32SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32SInt32MapMessage_char_data[66];
} qt_protobuf_SimpleFixed32SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32SInt32MapMessage_metadata.data
};

void SimpleFixed32SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32SInt32MapMessage>();
    qRegisterMetaType<SimpleFixed32SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::sint32>();
}

SimpleFixed32SInt32MapMessage::SimpleFixed32SInt32MapMessage()
    : QProtobufMessage(&SimpleFixed32SInt32MapMessage::staticMetaObject, &SimpleFixed32SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32SInt32MapMessage::MapFieldEntry &SimpleFixed32SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32SInt32MapMessage::setMapField(const SimpleFixed32SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32SInt32MapMessage::setMapField(SimpleFixed32SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64SInt32MapMessage_QtProtobufData(const SimpleFixed64SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64SInt32MapMessage::~SimpleFixed64SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64SInt32MapMessage_char_data[66];
} qt_protobuf_SimpleFixed64SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64SInt32MapMessage_metadata.data
};

void SimpleFixed64SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64SInt32MapMessage>();
    qRegisterMetaType<SimpleFixed64SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::sint32>();
}

SimpleFixed64SInt32MapMessage::SimpleFixed64SInt32MapMessage()
    : QProtobufMessage(&SimpleFixed64SInt32MapMessage::staticMetaObject, &SimpleFixed64SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64SInt32MapMessage::MapFieldEntry &SimpleFixed64SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64SInt32MapMessage::setMapField(const SimpleFixed64SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64SInt32MapMessage::setMapField(SimpleFixed64SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32SInt32MapMessage_QtProtobufData(const SimpleSFixed32SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32SInt32MapMessage::~SimpleSFixed32SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32SInt32MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed32SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32SInt32MapMessage_metadata.data
};

void SimpleSFixed32SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32SInt32MapMessage>();
    qRegisterMetaType<SimpleSFixed32SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::sint32>();
}

SimpleSFixed32SInt32MapMessage::SimpleSFixed32SInt32MapMessage()
    : QProtobufMessage(&SimpleSFixed32SInt32MapMessage::staticMetaObject, &SimpleSFixed32SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32SInt32MapMessage::MapFieldEntry &SimpleSFixed32SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32SInt32MapMessage::setMapField(const SimpleSFixed32SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32SInt32MapMessage::setMapField(SimpleSFixed32SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64SInt32MapMessage_QtProtobufData(const SimpleSFixed64SInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64SInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64SInt32MapMessage::~SimpleSFixed64SInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64SInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64SInt32MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed64SInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64SInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64SInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64SInt32MapMessage_metadata.data
};

void SimpleSFixed64SInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64SInt32MapMessage>();
    qRegisterMetaType<SimpleSFixed64SInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64SInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::sint32>();
}

SimpleSFixed64SInt32MapMessage::SimpleSFixed64SInt32MapMessage()
    : QProtobufMessage(&SimpleSFixed64SInt32MapMessage::staticMetaObject, &SimpleSFixed64SInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64SInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64SInt32MapMessage::MapFieldEntry &SimpleSFixed64SInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64SInt32MapMessage::setMapField(const SimpleSFixed64SInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64SInt32MapMessage::setMapField(SimpleSFixed64SInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringSInt32MapMessage_QtProtobufData(const SimpleStringSInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringSInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleStringSInt32MapMessage::~SimpleStringSInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringSInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleStringSInt32MapMessage_char_data[65];
} qt_protobuf_SimpleStringSInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringSInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringSInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringSInt32MapMessage_metadata.data
};

void SimpleStringSInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringSInt32MapMessage>();
    qRegisterMetaType<SimpleStringSInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleStringSInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::sint32>();
}

SimpleStringSInt32MapMessage::SimpleStringSInt32MapMessage()
    : QProtobufMessage(&SimpleStringSInt32MapMessage::staticMetaObject, &SimpleStringSInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringSInt32MapMessage_QtProtobufData)
{
}

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

const SimpleStringSInt32MapMessage::MapFieldEntry &SimpleStringSInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringSInt32MapMessage::setMapField(const SimpleStringSInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringSInt32MapMessage::setMapField(SimpleStringSInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32SInt64MapMessage_QtProtobufData(const SimpleSInt32SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32SInt64MapMessage::~SimpleSInt32SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32SInt64MapMessage_char_data[65];
} qt_protobuf_SimpleSInt32SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32SInt64MapMessage_metadata.data
};

void SimpleSInt32SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32SInt64MapMessage>();
    qRegisterMetaType<SimpleSInt32SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::sint64>();
}

SimpleSInt32SInt64MapMessage::SimpleSInt32SInt64MapMessage()
    : QProtobufMessage(&SimpleSInt32SInt64MapMessage::staticMetaObject, &SimpleSInt32SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32SInt64MapMessage::MapFieldEntry &SimpleSInt32SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32SInt64MapMessage::setMapField(const SimpleSInt32SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32SInt64MapMessage::setMapField(SimpleSInt32SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64SInt64MapMessage_QtProtobufData(const SimpleSInt64SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64SInt64MapMessage::~SimpleSInt64SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64SInt64MapMessage_char_data[65];
} qt_protobuf_SimpleSInt64SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64SInt64MapMessage_metadata.data
};

void SimpleSInt64SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64SInt64MapMessage>();
    qRegisterMetaType<SimpleSInt64SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::sint64>();
}

SimpleSInt64SInt64MapMessage::SimpleSInt64SInt64MapMessage()
    : QProtobufMessage(&SimpleSInt64SInt64MapMessage::staticMetaObject, &SimpleSInt64SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64SInt64MapMessage::MapFieldEntry &SimpleSInt64SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64SInt64MapMessage::setMapField(const SimpleSInt64SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64SInt64MapMessage::setMapField(SimpleSInt64SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32SInt64MapMessage_QtProtobufData(const SimpleInt32SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32SInt64MapMessage::~SimpleInt32SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32SInt64MapMessage_char_data[64];
} qt_protobuf_SimpleInt32SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32SInt64MapMessage_metadata.data
};

void SimpleInt32SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32SInt64MapMessage>();
    qRegisterMetaType<SimpleInt32SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::sint64>();
}

SimpleInt32SInt64MapMessage::SimpleInt32SInt64MapMessage()
    : QProtobufMessage(&SimpleInt32SInt64MapMessage::staticMetaObject, &SimpleInt32SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleInt32SInt64MapMessage::MapFieldEntry &SimpleInt32SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32SInt64MapMessage::setMapField(const SimpleInt32SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32SInt64MapMessage::setMapField(SimpleInt32SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64SInt64MapMessage_QtProtobufData(const SimpleInt64SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64SInt64MapMessage::~SimpleInt64SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64SInt64MapMessage_char_data[64];
} qt_protobuf_SimpleInt64SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64SInt64MapMessage_metadata.data
};

void SimpleInt64SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64SInt64MapMessage>();
    qRegisterMetaType<SimpleInt64SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::sint64>();
}

SimpleInt64SInt64MapMessage::SimpleInt64SInt64MapMessage()
    : QProtobufMessage(&SimpleInt64SInt64MapMessage::staticMetaObject, &SimpleInt64SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleInt64SInt64MapMessage::MapFieldEntry &SimpleInt64SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64SInt64MapMessage::setMapField(const SimpleInt64SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64SInt64MapMessage::setMapField(SimpleInt64SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32SInt64MapMessage_QtProtobufData(const SimpleUInt32SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32SInt64MapMessage::~SimpleUInt32SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32SInt64MapMessage_char_data[65];
} qt_protobuf_SimpleUInt32SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32SInt64MapMessage_metadata.data
};

void SimpleUInt32SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32SInt64MapMessage>();
    qRegisterMetaType<SimpleUInt32SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::sint64>();
}

SimpleUInt32SInt64MapMessage::SimpleUInt32SInt64MapMessage()
    : QProtobufMessage(&SimpleUInt32SInt64MapMessage::staticMetaObject, &SimpleUInt32SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32SInt64MapMessage::MapFieldEntry &SimpleUInt32SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32SInt64MapMessage::setMapField(const SimpleUInt32SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32SInt64MapMessage::setMapField(SimpleUInt32SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64SInt64MapMessage_QtProtobufData(const SimpleUInt64SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64SInt64MapMessage::~SimpleUInt64SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64SInt64MapMessage_char_data[65];
} qt_protobuf_SimpleUInt64SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64SInt64MapMessage_metadata.data
};

void SimpleUInt64SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64SInt64MapMessage>();
    qRegisterMetaType<SimpleUInt64SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::sint64>();
}

SimpleUInt64SInt64MapMessage::SimpleUInt64SInt64MapMessage()
    : QProtobufMessage(&SimpleUInt64SInt64MapMessage::staticMetaObject, &SimpleUInt64SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64SInt64MapMessage::MapFieldEntry &SimpleUInt64SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64SInt64MapMessage::setMapField(const SimpleUInt64SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64SInt64MapMessage::setMapField(SimpleUInt64SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32SInt64MapMessage_QtProtobufData(const SimpleFixed32SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32SInt64MapMessage::~SimpleFixed32SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32SInt64MapMessage_char_data[66];
} qt_protobuf_SimpleFixed32SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32SInt64MapMessage_metadata.data
};

void SimpleFixed32SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32SInt64MapMessage>();
    qRegisterMetaType<SimpleFixed32SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::sint64>();
}

SimpleFixed32SInt64MapMessage::SimpleFixed32SInt64MapMessage()
    : QProtobufMessage(&SimpleFixed32SInt64MapMessage::staticMetaObject, &SimpleFixed32SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32SInt64MapMessage::MapFieldEntry &SimpleFixed32SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32SInt64MapMessage::setMapField(const SimpleFixed32SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32SInt64MapMessage::setMapField(SimpleFixed32SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64SInt64MapMessage_QtProtobufData(const SimpleFixed64SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64SInt64MapMessage::~SimpleFixed64SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64SInt64MapMessage_char_data[66];
} qt_protobuf_SimpleFixed64SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64SInt64MapMessage_metadata.data
};

void SimpleFixed64SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64SInt64MapMessage>();
    qRegisterMetaType<SimpleFixed64SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::sint64>();
}

SimpleFixed64SInt64MapMessage::SimpleFixed64SInt64MapMessage()
    : QProtobufMessage(&SimpleFixed64SInt64MapMessage::staticMetaObject, &SimpleFixed64SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64SInt64MapMessage::MapFieldEntry &SimpleFixed64SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64SInt64MapMessage::setMapField(const SimpleFixed64SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64SInt64MapMessage::setMapField(SimpleFixed64SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32SInt64MapMessage_QtProtobufData(const SimpleSFixed32SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32SInt64MapMessage::~SimpleSFixed32SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32SInt64MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed32SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32SInt64MapMessage_metadata.data
};

void SimpleSFixed32SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32SInt64MapMessage>();
    qRegisterMetaType<SimpleSFixed32SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::sint64>();
}

SimpleSFixed32SInt64MapMessage::SimpleSFixed32SInt64MapMessage()
    : QProtobufMessage(&SimpleSFixed32SInt64MapMessage::staticMetaObject, &SimpleSFixed32SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32SInt64MapMessage::MapFieldEntry &SimpleSFixed32SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32SInt64MapMessage::setMapField(const SimpleSFixed32SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32SInt64MapMessage::setMapField(SimpleSFixed32SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64SInt64MapMessage_QtProtobufData(const SimpleSFixed64SInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64SInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64SInt64MapMessage::~SimpleSFixed64SInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64SInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64SInt64MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed64SInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64SInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64SInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64SInt64MapMessage_metadata.data
};

void SimpleSFixed64SInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64SInt64MapMessage>();
    qRegisterMetaType<SimpleSFixed64SInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64SInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::sint64>();
}

SimpleSFixed64SInt64MapMessage::SimpleSFixed64SInt64MapMessage()
    : QProtobufMessage(&SimpleSFixed64SInt64MapMessage::staticMetaObject, &SimpleSFixed64SInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64SInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64SInt64MapMessage::MapFieldEntry &SimpleSFixed64SInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64SInt64MapMessage::setMapField(const SimpleSFixed64SInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64SInt64MapMessage::setMapField(SimpleSFixed64SInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringSInt64MapMessage_QtProtobufData(const SimpleStringSInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringSInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleStringSInt64MapMessage::~SimpleStringSInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringSInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleStringSInt64MapMessage_char_data[65];
} qt_protobuf_SimpleStringSInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringSInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringSInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringSInt64MapMessage_metadata.data
};

void SimpleStringSInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringSInt64MapMessage>();
    qRegisterMetaType<SimpleStringSInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleStringSInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::sint64>();
}

SimpleStringSInt64MapMessage::SimpleStringSInt64MapMessage()
    : QProtobufMessage(&SimpleStringSInt64MapMessage::staticMetaObject, &SimpleStringSInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringSInt64MapMessage_QtProtobufData)
{
}

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

const SimpleStringSInt64MapMessage::MapFieldEntry &SimpleStringSInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringSInt64MapMessage::setMapField(const SimpleStringSInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringSInt64MapMessage::setMapField(SimpleStringSInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32UInt32MapMessage_QtProtobufData(const SimpleSInt32UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32UInt32MapMessage::~SimpleSInt32UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32UInt32MapMessage_char_data[65];
} qt_protobuf_SimpleSInt32UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32UInt32MapMessage_metadata.data
};

void SimpleSInt32UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32UInt32MapMessage>();
    qRegisterMetaType<SimpleSInt32UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::uint32>();
}

SimpleSInt32UInt32MapMessage::SimpleSInt32UInt32MapMessage()
    : QProtobufMessage(&SimpleSInt32UInt32MapMessage::staticMetaObject, &SimpleSInt32UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32UInt32MapMessage::MapFieldEntry &SimpleSInt32UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32UInt32MapMessage::setMapField(const SimpleSInt32UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32UInt32MapMessage::setMapField(SimpleSInt32UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64UInt32MapMessage_QtProtobufData(const SimpleSInt64UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64UInt32MapMessage::~SimpleSInt64UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64UInt32MapMessage_char_data[65];
} qt_protobuf_SimpleSInt64UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64UInt32MapMessage_metadata.data
};

void SimpleSInt64UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64UInt32MapMessage>();
    qRegisterMetaType<SimpleSInt64UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::uint32>();
}

SimpleSInt64UInt32MapMessage::SimpleSInt64UInt32MapMessage()
    : QProtobufMessage(&SimpleSInt64UInt32MapMessage::staticMetaObject, &SimpleSInt64UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64UInt32MapMessage::MapFieldEntry &SimpleSInt64UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64UInt32MapMessage::setMapField(const SimpleSInt64UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64UInt32MapMessage::setMapField(SimpleSInt64UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32UInt32MapMessage_QtProtobufData(const SimpleInt32UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32UInt32MapMessage::~SimpleInt32UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32UInt32MapMessage_char_data[64];
} qt_protobuf_SimpleInt32UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32UInt32MapMessage_metadata.data
};

void SimpleInt32UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32UInt32MapMessage>();
    qRegisterMetaType<SimpleInt32UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::uint32>();
}

SimpleInt32UInt32MapMessage::SimpleInt32UInt32MapMessage()
    : QProtobufMessage(&SimpleInt32UInt32MapMessage::staticMetaObject, &SimpleInt32UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleInt32UInt32MapMessage::MapFieldEntry &SimpleInt32UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32UInt32MapMessage::setMapField(const SimpleInt32UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32UInt32MapMessage::setMapField(SimpleInt32UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64UInt32MapMessage_QtProtobufData(const SimpleInt64UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64UInt32MapMessage::~SimpleInt64UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64UInt32MapMessage_char_data[64];
} qt_protobuf_SimpleInt64UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64UInt32MapMessage_metadata.data
};

void SimpleInt64UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64UInt32MapMessage>();
    qRegisterMetaType<SimpleInt64UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::uint32>();
}

SimpleInt64UInt32MapMessage::SimpleInt64UInt32MapMessage()
    : QProtobufMessage(&SimpleInt64UInt32MapMessage::staticMetaObject, &SimpleInt64UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleInt64UInt32MapMessage::MapFieldEntry &SimpleInt64UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64UInt32MapMessage::setMapField(const SimpleInt64UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64UInt32MapMessage::setMapField(SimpleInt64UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32UInt32MapMessage_QtProtobufData(const SimpleUInt32UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32UInt32MapMessage::~SimpleUInt32UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32UInt32MapMessage_char_data[65];
} qt_protobuf_SimpleUInt32UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32UInt32MapMessage_metadata.data
};

void SimpleUInt32UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32UInt32MapMessage>();
    qRegisterMetaType<SimpleUInt32UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::uint32>();
}

SimpleUInt32UInt32MapMessage::SimpleUInt32UInt32MapMessage()
    : QProtobufMessage(&SimpleUInt32UInt32MapMessage::staticMetaObject, &SimpleUInt32UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32UInt32MapMessage::MapFieldEntry &SimpleUInt32UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32UInt32MapMessage::setMapField(const SimpleUInt32UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32UInt32MapMessage::setMapField(SimpleUInt32UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64UInt32MapMessage_QtProtobufData(const SimpleUInt64UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64UInt32MapMessage::~SimpleUInt64UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64UInt32MapMessage_char_data[65];
} qt_protobuf_SimpleUInt64UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64UInt32MapMessage_metadata.data
};

void SimpleUInt64UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64UInt32MapMessage>();
    qRegisterMetaType<SimpleUInt64UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::uint32>();
}

SimpleUInt64UInt32MapMessage::SimpleUInt64UInt32MapMessage()
    : QProtobufMessage(&SimpleUInt64UInt32MapMessage::staticMetaObject, &SimpleUInt64UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64UInt32MapMessage::MapFieldEntry &SimpleUInt64UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64UInt32MapMessage::setMapField(const SimpleUInt64UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64UInt32MapMessage::setMapField(SimpleUInt64UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32UInt32MapMessage_QtProtobufData(const SimpleFixed32UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32UInt32MapMessage::~SimpleFixed32UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32UInt32MapMessage_char_data[66];
} qt_protobuf_SimpleFixed32UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32UInt32MapMessage_metadata.data
};

void SimpleFixed32UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32UInt32MapMessage>();
    qRegisterMetaType<SimpleFixed32UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::uint32>();
}

SimpleFixed32UInt32MapMessage::SimpleFixed32UInt32MapMessage()
    : QProtobufMessage(&SimpleFixed32UInt32MapMessage::staticMetaObject, &SimpleFixed32UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32UInt32MapMessage::MapFieldEntry &SimpleFixed32UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32UInt32MapMessage::setMapField(const SimpleFixed32UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32UInt32MapMessage::setMapField(SimpleFixed32UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64UInt32MapMessage_QtProtobufData(const SimpleFixed64UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64UInt32MapMessage::~SimpleFixed64UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64UInt32MapMessage_char_data[66];
} qt_protobuf_SimpleFixed64UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64UInt32MapMessage_metadata.data
};

void SimpleFixed64UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64UInt32MapMessage>();
    qRegisterMetaType<SimpleFixed64UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::uint32>();
}

SimpleFixed64UInt32MapMessage::SimpleFixed64UInt32MapMessage()
    : QProtobufMessage(&SimpleFixed64UInt32MapMessage::staticMetaObject, &SimpleFixed64UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64UInt32MapMessage::MapFieldEntry &SimpleFixed64UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64UInt32MapMessage::setMapField(const SimpleFixed64UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64UInt32MapMessage::setMapField(SimpleFixed64UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32UInt32MapMessage_QtProtobufData(const SimpleSFixed32UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32UInt32MapMessage::~SimpleSFixed32UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32UInt32MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed32UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32UInt32MapMessage_metadata.data
};

void SimpleSFixed32UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32UInt32MapMessage>();
    qRegisterMetaType<SimpleSFixed32UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::uint32>();
}

SimpleSFixed32UInt32MapMessage::SimpleSFixed32UInt32MapMessage()
    : QProtobufMessage(&SimpleSFixed32UInt32MapMessage::staticMetaObject, &SimpleSFixed32UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32UInt32MapMessage::MapFieldEntry &SimpleSFixed32UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32UInt32MapMessage::setMapField(const SimpleSFixed32UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32UInt32MapMessage::setMapField(SimpleSFixed32UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64UInt32MapMessage_QtProtobufData(const SimpleSFixed64UInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64UInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64UInt32MapMessage::~SimpleSFixed64UInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64UInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64UInt32MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed64UInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64UInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64UInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64UInt32MapMessage_metadata.data
};

void SimpleSFixed64UInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64UInt32MapMessage>();
    qRegisterMetaType<SimpleSFixed64UInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64UInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::uint32>();
}

SimpleSFixed64UInt32MapMessage::SimpleSFixed64UInt32MapMessage()
    : QProtobufMessage(&SimpleSFixed64UInt32MapMessage::staticMetaObject, &SimpleSFixed64UInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64UInt32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64UInt32MapMessage::MapFieldEntry &SimpleSFixed64UInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64UInt32MapMessage::setMapField(const SimpleSFixed64UInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64UInt32MapMessage::setMapField(SimpleSFixed64UInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringUInt32MapMessage_QtProtobufData(const SimpleStringUInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringUInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleStringUInt32MapMessage::~SimpleStringUInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringUInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleStringUInt32MapMessage_char_data[65];
} qt_protobuf_SimpleStringUInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringUInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringUInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringUInt32MapMessage_metadata.data
};

void SimpleStringUInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringUInt32MapMessage>();
    qRegisterMetaType<SimpleStringUInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleStringUInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::uint32>();
}

SimpleStringUInt32MapMessage::SimpleStringUInt32MapMessage()
    : QProtobufMessage(&SimpleStringUInt32MapMessage::staticMetaObject, &SimpleStringUInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringUInt32MapMessage_QtProtobufData)
{
}

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

const SimpleStringUInt32MapMessage::MapFieldEntry &SimpleStringUInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringUInt32MapMessage::setMapField(const SimpleStringUInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringUInt32MapMessage::setMapField(SimpleStringUInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32UInt64MapMessage_QtProtobufData(const SimpleSInt32UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32UInt64MapMessage::~SimpleSInt32UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32UInt64MapMessage_char_data[65];
} qt_protobuf_SimpleSInt32UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32UInt64MapMessage_metadata.data
};

void SimpleSInt32UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32UInt64MapMessage>();
    qRegisterMetaType<SimpleSInt32UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::uint64>();
}

SimpleSInt32UInt64MapMessage::SimpleSInt32UInt64MapMessage()
    : QProtobufMessage(&SimpleSInt32UInt64MapMessage::staticMetaObject, &SimpleSInt32UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32UInt64MapMessage::MapFieldEntry &SimpleSInt32UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32UInt64MapMessage::setMapField(const SimpleSInt32UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32UInt64MapMessage::setMapField(SimpleSInt32UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64UInt64MapMessage_QtProtobufData(const SimpleSInt64UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64UInt64MapMessage::~SimpleSInt64UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64UInt64MapMessage_char_data[65];
} qt_protobuf_SimpleSInt64UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64UInt64MapMessage_metadata.data
};

void SimpleSInt64UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64UInt64MapMessage>();
    qRegisterMetaType<SimpleSInt64UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::uint64>();
}

SimpleSInt64UInt64MapMessage::SimpleSInt64UInt64MapMessage()
    : QProtobufMessage(&SimpleSInt64UInt64MapMessage::staticMetaObject, &SimpleSInt64UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64UInt64MapMessage::MapFieldEntry &SimpleSInt64UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64UInt64MapMessage::setMapField(const SimpleSInt64UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64UInt64MapMessage::setMapField(SimpleSInt64UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32UInt64MapMessage_QtProtobufData(const SimpleInt32UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32UInt64MapMessage::~SimpleInt32UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32UInt64MapMessage_char_data[64];
} qt_protobuf_SimpleInt32UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32UInt64MapMessage_metadata.data
};

void SimpleInt32UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32UInt64MapMessage>();
    qRegisterMetaType<SimpleInt32UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::uint64>();
}

SimpleInt32UInt64MapMessage::SimpleInt32UInt64MapMessage()
    : QProtobufMessage(&SimpleInt32UInt64MapMessage::staticMetaObject, &SimpleInt32UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleInt32UInt64MapMessage::MapFieldEntry &SimpleInt32UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32UInt64MapMessage::setMapField(const SimpleInt32UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32UInt64MapMessage::setMapField(SimpleInt32UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64UInt64MapMessage_QtProtobufData(const SimpleInt64UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64UInt64MapMessage::~SimpleInt64UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64UInt64MapMessage_char_data[64];
} qt_protobuf_SimpleInt64UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64UInt64MapMessage_metadata.data
};

void SimpleInt64UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64UInt64MapMessage>();
    qRegisterMetaType<SimpleInt64UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::uint64>();
}

SimpleInt64UInt64MapMessage::SimpleInt64UInt64MapMessage()
    : QProtobufMessage(&SimpleInt64UInt64MapMessage::staticMetaObject, &SimpleInt64UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleInt64UInt64MapMessage::MapFieldEntry &SimpleInt64UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64UInt64MapMessage::setMapField(const SimpleInt64UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64UInt64MapMessage::setMapField(SimpleInt64UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32UInt64MapMessage_QtProtobufData(const SimpleUInt32UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32UInt64MapMessage::~SimpleUInt32UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32UInt64MapMessage_char_data[65];
} qt_protobuf_SimpleUInt32UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32UInt64MapMessage_metadata.data
};

void SimpleUInt32UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32UInt64MapMessage>();
    qRegisterMetaType<SimpleUInt32UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::uint64>();
}

SimpleUInt32UInt64MapMessage::SimpleUInt32UInt64MapMessage()
    : QProtobufMessage(&SimpleUInt32UInt64MapMessage::staticMetaObject, &SimpleUInt32UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32UInt64MapMessage::MapFieldEntry &SimpleUInt32UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32UInt64MapMessage::setMapField(const SimpleUInt32UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32UInt64MapMessage::setMapField(SimpleUInt32UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64UInt64MapMessage_QtProtobufData(const SimpleUInt64UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64UInt64MapMessage::~SimpleUInt64UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64UInt64MapMessage_char_data[65];
} qt_protobuf_SimpleUInt64UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64UInt64MapMessage_metadata.data
};

void SimpleUInt64UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64UInt64MapMessage>();
    qRegisterMetaType<SimpleUInt64UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::uint64>();
}

SimpleUInt64UInt64MapMessage::SimpleUInt64UInt64MapMessage()
    : QProtobufMessage(&SimpleUInt64UInt64MapMessage::staticMetaObject, &SimpleUInt64UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64UInt64MapMessage::MapFieldEntry &SimpleUInt64UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64UInt64MapMessage::setMapField(const SimpleUInt64UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64UInt64MapMessage::setMapField(SimpleUInt64UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32UInt64MapMessage_QtProtobufData(const SimpleFixed32UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32UInt64MapMessage::~SimpleFixed32UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32UInt64MapMessage_char_data[66];
} qt_protobuf_SimpleFixed32UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32UInt64MapMessage_metadata.data
};

void SimpleFixed32UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32UInt64MapMessage>();
    qRegisterMetaType<SimpleFixed32UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::uint64>();
}

SimpleFixed32UInt64MapMessage::SimpleFixed32UInt64MapMessage()
    : QProtobufMessage(&SimpleFixed32UInt64MapMessage::staticMetaObject, &SimpleFixed32UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32UInt64MapMessage::MapFieldEntry &SimpleFixed32UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32UInt64MapMessage::setMapField(const SimpleFixed32UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32UInt64MapMessage::setMapField(SimpleFixed32UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64UInt64MapMessage_QtProtobufData(const SimpleFixed64UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64UInt64MapMessage::~SimpleFixed64UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64UInt64MapMessage_char_data[66];
} qt_protobuf_SimpleFixed64UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64UInt64MapMessage_metadata.data
};

void SimpleFixed64UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64UInt64MapMessage>();
    qRegisterMetaType<SimpleFixed64UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::uint64>();
}

SimpleFixed64UInt64MapMessage::SimpleFixed64UInt64MapMessage()
    : QProtobufMessage(&SimpleFixed64UInt64MapMessage::staticMetaObject, &SimpleFixed64UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64UInt64MapMessage::MapFieldEntry &SimpleFixed64UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64UInt64MapMessage::setMapField(const SimpleFixed64UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64UInt64MapMessage::setMapField(SimpleFixed64UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32UInt64MapMessage_QtProtobufData(const SimpleSFixed32UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32UInt64MapMessage::~SimpleSFixed32UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32UInt64MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed32UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32UInt64MapMessage_metadata.data
};

void SimpleSFixed32UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32UInt64MapMessage>();
    qRegisterMetaType<SimpleSFixed32UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::uint64>();
}

SimpleSFixed32UInt64MapMessage::SimpleSFixed32UInt64MapMessage()
    : QProtobufMessage(&SimpleSFixed32UInt64MapMessage::staticMetaObject, &SimpleSFixed32UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32UInt64MapMessage::MapFieldEntry &SimpleSFixed32UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32UInt64MapMessage::setMapField(const SimpleSFixed32UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32UInt64MapMessage::setMapField(SimpleSFixed32UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64UInt64MapMessage_QtProtobufData(const SimpleSFixed64UInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64UInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64UInt64MapMessage::~SimpleSFixed64UInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64UInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64UInt64MapMessage_char_data[67];
} qt_protobuf_SimpleSFixed64UInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        56, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        57, /* = mapField */
        66, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64UInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64UInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64UInt64MapMessage_metadata.data
};

void SimpleSFixed64UInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64UInt64MapMessage>();
    qRegisterMetaType<SimpleSFixed64UInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64UInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::uint64>();
}

SimpleSFixed64UInt64MapMessage::SimpleSFixed64UInt64MapMessage()
    : QProtobufMessage(&SimpleSFixed64UInt64MapMessage::staticMetaObject, &SimpleSFixed64UInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64UInt64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64UInt64MapMessage::MapFieldEntry &SimpleSFixed64UInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64UInt64MapMessage::setMapField(const SimpleSFixed64UInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64UInt64MapMessage::setMapField(SimpleSFixed64UInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringUInt64MapMessage_QtProtobufData(const SimpleStringUInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringUInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleStringUInt64MapMessage::~SimpleStringUInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringUInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleStringUInt64MapMessage_char_data[65];
} qt_protobuf_SimpleStringUInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringUInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringUInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringUInt64MapMessage_metadata.data
};

void SimpleStringUInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringUInt64MapMessage>();
    qRegisterMetaType<SimpleStringUInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleStringUInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::uint64>();
}

SimpleStringUInt64MapMessage::SimpleStringUInt64MapMessage()
    : QProtobufMessage(&SimpleStringUInt64MapMessage::staticMetaObject, &SimpleStringUInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringUInt64MapMessage_QtProtobufData)
{
}

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

const SimpleStringUInt64MapMessage::MapFieldEntry &SimpleStringUInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringUInt64MapMessage::setMapField(const SimpleStringUInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringUInt64MapMessage::setMapField(SimpleStringUInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32Int32MapMessage_QtProtobufData(const SimpleSInt32Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32Int32MapMessage::~SimpleSInt32Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32Int32MapMessage_char_data[64];
} qt_protobuf_SimpleSInt32Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32Int32MapMessage_metadata.data
};

void SimpleSInt32Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32Int32MapMessage>();
    qRegisterMetaType<SimpleSInt32Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::int32>();
}

SimpleSInt32Int32MapMessage::SimpleSInt32Int32MapMessage()
    : QProtobufMessage(&SimpleSInt32Int32MapMessage::staticMetaObject, &SimpleSInt32Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32Int32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32Int32MapMessage::MapFieldEntry &SimpleSInt32Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32Int32MapMessage::setMapField(const SimpleSInt32Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32Int32MapMessage::setMapField(SimpleSInt32Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64Int32MapMessage_QtProtobufData(const SimpleSInt64Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64Int32MapMessage::~SimpleSInt64Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64Int32MapMessage_char_data[64];
} qt_protobuf_SimpleSInt64Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64Int32MapMessage_metadata.data
};

void SimpleSInt64Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64Int32MapMessage>();
    qRegisterMetaType<SimpleSInt64Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::int32>();
}

SimpleSInt64Int32MapMessage::SimpleSInt64Int32MapMessage()
    : QProtobufMessage(&SimpleSInt64Int32MapMessage::staticMetaObject, &SimpleSInt64Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64Int32MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64Int32MapMessage::MapFieldEntry &SimpleSInt64Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64Int32MapMessage::setMapField(const SimpleSInt64Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64Int32MapMessage::setMapField(SimpleSInt64Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32Int32MapMessage_QtProtobufData(const SimpleInt32Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32Int32MapMessage::~SimpleInt32Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32Int32MapMessage_char_data[63];
} qt_protobuf_SimpleInt32Int32MapMessage_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, /* = mapField */
        62, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32Int32MapMessage_metadata.data
};

void SimpleInt32Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32Int32MapMessage>();
    qRegisterMetaType<SimpleInt32Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::int32>();
}

SimpleInt32Int32MapMessage::SimpleInt32Int32MapMessage()
    : QProtobufMessage(&SimpleInt32Int32MapMessage::staticMetaObject, &SimpleInt32Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32Int32MapMessage_QtProtobufData)
{
}

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

const SimpleInt32Int32MapMessage::MapFieldEntry &SimpleInt32Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32Int32MapMessage::setMapField(const SimpleInt32Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32Int32MapMessage::setMapField(SimpleInt32Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64Int32MapMessage_QtProtobufData(const SimpleInt64Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64Int32MapMessage::~SimpleInt64Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64Int32MapMessage_char_data[63];
} qt_protobuf_SimpleInt64Int32MapMessage_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, /* = mapField */
        62, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64Int32MapMessage_metadata.data
};

void SimpleInt64Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64Int32MapMessage>();
    qRegisterMetaType<SimpleInt64Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::int32>();
}

SimpleInt64Int32MapMessage::SimpleInt64Int32MapMessage()
    : QProtobufMessage(&SimpleInt64Int32MapMessage::staticMetaObject, &SimpleInt64Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64Int32MapMessage_QtProtobufData)
{
}

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

const SimpleInt64Int32MapMessage::MapFieldEntry &SimpleInt64Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64Int32MapMessage::setMapField(const SimpleInt64Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64Int32MapMessage::setMapField(SimpleInt64Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32Int32MapMessage_QtProtobufData(const SimpleUInt32Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32Int32MapMessage::~SimpleUInt32Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32Int32MapMessage_char_data[64];
} qt_protobuf_SimpleUInt32Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32Int32MapMessage_metadata.data
};

void SimpleUInt32Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32Int32MapMessage>();
    qRegisterMetaType<SimpleUInt32Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::int32>();
}

SimpleUInt32Int32MapMessage::SimpleUInt32Int32MapMessage()
    : QProtobufMessage(&SimpleUInt32Int32MapMessage::staticMetaObject, &SimpleUInt32Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32Int32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32Int32MapMessage::MapFieldEntry &SimpleUInt32Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32Int32MapMessage::setMapField(const SimpleUInt32Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32Int32MapMessage::setMapField(SimpleUInt32Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64Int32MapMessage_QtProtobufData(const SimpleUInt64Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64Int32MapMessage::~SimpleUInt64Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64Int32MapMessage_char_data[64];
} qt_protobuf_SimpleUInt64Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64Int32MapMessage_metadata.data
};

void SimpleUInt64Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64Int32MapMessage>();
    qRegisterMetaType<SimpleUInt64Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::int32>();
}

SimpleUInt64Int32MapMessage::SimpleUInt64Int32MapMessage()
    : QProtobufMessage(&SimpleUInt64Int32MapMessage::staticMetaObject, &SimpleUInt64Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64Int32MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64Int32MapMessage::MapFieldEntry &SimpleUInt64Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64Int32MapMessage::setMapField(const SimpleUInt64Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64Int32MapMessage::setMapField(SimpleUInt64Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32Int32MapMessage_QtProtobufData(const SimpleFixed32Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32Int32MapMessage::~SimpleFixed32Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32Int32MapMessage_char_data[65];
} qt_protobuf_SimpleFixed32Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32Int32MapMessage_metadata.data
};

void SimpleFixed32Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32Int32MapMessage>();
    qRegisterMetaType<SimpleFixed32Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::int32>();
}

SimpleFixed32Int32MapMessage::SimpleFixed32Int32MapMessage()
    : QProtobufMessage(&SimpleFixed32Int32MapMessage::staticMetaObject, &SimpleFixed32Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32Int32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32Int32MapMessage::MapFieldEntry &SimpleFixed32Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32Int32MapMessage::setMapField(const SimpleFixed32Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32Int32MapMessage::setMapField(SimpleFixed32Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64Int32MapMessage_QtProtobufData(const SimpleFixed64Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64Int32MapMessage::~SimpleFixed64Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64Int32MapMessage_char_data[65];
} qt_protobuf_SimpleFixed64Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64Int32MapMessage_metadata.data
};

void SimpleFixed64Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64Int32MapMessage>();
    qRegisterMetaType<SimpleFixed64Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::int32>();
}

SimpleFixed64Int32MapMessage::SimpleFixed64Int32MapMessage()
    : QProtobufMessage(&SimpleFixed64Int32MapMessage::staticMetaObject, &SimpleFixed64Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64Int32MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64Int32MapMessage::MapFieldEntry &SimpleFixed64Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64Int32MapMessage::setMapField(const SimpleFixed64Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64Int32MapMessage::setMapField(SimpleFixed64Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32Int32MapMessage_QtProtobufData(const SimpleSFixed32Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32Int32MapMessage::~SimpleSFixed32Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32Int32MapMessage_char_data[66];
} qt_protobuf_SimpleSFixed32Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32Int32MapMessage_metadata.data
};

void SimpleSFixed32Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32Int32MapMessage>();
    qRegisterMetaType<SimpleSFixed32Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::int32>();
}

SimpleSFixed32Int32MapMessage::SimpleSFixed32Int32MapMessage()
    : QProtobufMessage(&SimpleSFixed32Int32MapMessage::staticMetaObject, &SimpleSFixed32Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32Int32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32Int32MapMessage::MapFieldEntry &SimpleSFixed32Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32Int32MapMessage::setMapField(const SimpleSFixed32Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32Int32MapMessage::setMapField(SimpleSFixed32Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64Int32MapMessage_QtProtobufData(const SimpleSFixed64Int32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64Int32MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64Int32MapMessage::~SimpleSFixed64Int32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64Int32MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64Int32MapMessage_char_data[66];
} qt_protobuf_SimpleSFixed64Int32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64Int32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64Int32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64Int32MapMessage_metadata.data
};

void SimpleSFixed64Int32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64Int32MapMessage>();
    qRegisterMetaType<SimpleSFixed64Int32MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64Int32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::int32>();
}

SimpleSFixed64Int32MapMessage::SimpleSFixed64Int32MapMessage()
    : QProtobufMessage(&SimpleSFixed64Int32MapMessage::staticMetaObject, &SimpleSFixed64Int32MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64Int32MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64Int32MapMessage::MapFieldEntry &SimpleSFixed64Int32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64Int32MapMessage::setMapField(const SimpleSFixed64Int32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64Int32MapMessage::setMapField(SimpleSFixed64Int32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringInt32MapMessage_QtProtobufData(const SimpleStringInt32MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringInt32MapMessage::MapFieldEntry m_mapField;
};

SimpleStringInt32MapMessage::~SimpleStringInt32MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringInt32MapMessage_uint_data;
    const char qt_protobuf_SimpleStringInt32MapMessage_char_data[64];
} qt_protobuf_SimpleStringInt32MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringInt32MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringInt32MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringInt32MapMessage_metadata.data
};

void SimpleStringInt32MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringInt32MapMessage>();
    qRegisterMetaType<SimpleStringInt32MapMessageRepeated>();
    qRegisterMetaType<SimpleStringInt32MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::int32>();
}

SimpleStringInt32MapMessage::SimpleStringInt32MapMessage()
    : QProtobufMessage(&SimpleStringInt32MapMessage::staticMetaObject, &SimpleStringInt32MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringInt32MapMessage_QtProtobufData)
{
}

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

const SimpleStringInt32MapMessage::MapFieldEntry &SimpleStringInt32MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringInt32MapMessage::setMapField(const SimpleStringInt32MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringInt32MapMessage::setMapField(SimpleStringInt32MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32Int64MapMessage_QtProtobufData(const SimpleSInt32Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32Int64MapMessage::~SimpleSInt32Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32Int64MapMessage_char_data[64];
} qt_protobuf_SimpleSInt32Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32Int64MapMessage_metadata.data
};

void SimpleSInt32Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32Int64MapMessage>();
    qRegisterMetaType<SimpleSInt32Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, QtProtobuf::int64>();
}

SimpleSInt32Int64MapMessage::SimpleSInt32Int64MapMessage()
    : QProtobufMessage(&SimpleSInt32Int64MapMessage::staticMetaObject, &SimpleSInt32Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32Int64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt32Int64MapMessage::MapFieldEntry &SimpleSInt32Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32Int64MapMessage::setMapField(const SimpleSInt32Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32Int64MapMessage::setMapField(SimpleSInt32Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64Int64MapMessage_QtProtobufData(const SimpleSInt64Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64Int64MapMessage::~SimpleSInt64Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64Int64MapMessage_char_data[64];
} qt_protobuf_SimpleSInt64Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64Int64MapMessage_metadata.data
};

void SimpleSInt64Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64Int64MapMessage>();
    qRegisterMetaType<SimpleSInt64Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, QtProtobuf::int64>();
}

SimpleSInt64Int64MapMessage::SimpleSInt64Int64MapMessage()
    : QProtobufMessage(&SimpleSInt64Int64MapMessage::staticMetaObject, &SimpleSInt64Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64Int64MapMessage_QtProtobufData)
{
}

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

const SimpleSInt64Int64MapMessage::MapFieldEntry &SimpleSInt64Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64Int64MapMessage::setMapField(const SimpleSInt64Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64Int64MapMessage::setMapField(SimpleSInt64Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32Int64MapMessage_QtProtobufData(const SimpleInt32Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt32Int64MapMessage::~SimpleInt32Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt32Int64MapMessage_char_data[63];
} qt_protobuf_SimpleInt32Int64MapMessage_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, /* = mapField */
        62, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32Int64MapMessage_metadata.data
};

void SimpleInt32Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32Int64MapMessage>();
    qRegisterMetaType<SimpleInt32Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt32Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, QtProtobuf::int64>();
}

SimpleInt32Int64MapMessage::SimpleInt32Int64MapMessage()
    : QProtobufMessage(&SimpleInt32Int64MapMessage::staticMetaObject, &SimpleInt32Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32Int64MapMessage_QtProtobufData)
{
}

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

const SimpleInt32Int64MapMessage::MapFieldEntry &SimpleInt32Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32Int64MapMessage::setMapField(const SimpleInt32Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32Int64MapMessage::setMapField(SimpleInt32Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64Int64MapMessage_QtProtobufData(const SimpleInt64Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleInt64Int64MapMessage::~SimpleInt64Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleInt64Int64MapMessage_char_data[63];
} qt_protobuf_SimpleInt64Int64MapMessage_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, /* = mapField */
        62, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64Int64MapMessage_metadata.data
};

void SimpleInt64Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64Int64MapMessage>();
    qRegisterMetaType<SimpleInt64Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleInt64Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, QtProtobuf::int64>();
}

SimpleInt64Int64MapMessage::SimpleInt64Int64MapMessage()
    : QProtobufMessage(&SimpleInt64Int64MapMessage::staticMetaObject, &SimpleInt64Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64Int64MapMessage_QtProtobufData)
{
}

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

const SimpleInt64Int64MapMessage::MapFieldEntry &SimpleInt64Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64Int64MapMessage::setMapField(const SimpleInt64Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64Int64MapMessage::setMapField(SimpleInt64Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32Int64MapMessage_QtProtobufData(const SimpleUInt32Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32Int64MapMessage::~SimpleUInt32Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32Int64MapMessage_char_data[64];
} qt_protobuf_SimpleUInt32Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32Int64MapMessage_metadata.data
};

void SimpleUInt32Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32Int64MapMessage>();
    qRegisterMetaType<SimpleUInt32Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, QtProtobuf::int64>();
}

SimpleUInt32Int64MapMessage::SimpleUInt32Int64MapMessage()
    : QProtobufMessage(&SimpleUInt32Int64MapMessage::staticMetaObject, &SimpleUInt32Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32Int64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt32Int64MapMessage::MapFieldEntry &SimpleUInt32Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32Int64MapMessage::setMapField(const SimpleUInt32Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32Int64MapMessage::setMapField(SimpleUInt32Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64Int64MapMessage_QtProtobufData(const SimpleUInt64Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64Int64MapMessage::~SimpleUInt64Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64Int64MapMessage_char_data[64];
} qt_protobuf_SimpleUInt64Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64Int64MapMessage_metadata.data
};

void SimpleUInt64Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64Int64MapMessage>();
    qRegisterMetaType<SimpleUInt64Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, QtProtobuf::int64>();
}

SimpleUInt64Int64MapMessage::SimpleUInt64Int64MapMessage()
    : QProtobufMessage(&SimpleUInt64Int64MapMessage::staticMetaObject, &SimpleUInt64Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64Int64MapMessage_QtProtobufData)
{
}

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

const SimpleUInt64Int64MapMessage::MapFieldEntry &SimpleUInt64Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64Int64MapMessage::setMapField(const SimpleUInt64Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64Int64MapMessage::setMapField(SimpleUInt64Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32Int64MapMessage_QtProtobufData(const SimpleFixed32Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32Int64MapMessage::~SimpleFixed32Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32Int64MapMessage_char_data[65];
} qt_protobuf_SimpleFixed32Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32Int64MapMessage_metadata.data
};

void SimpleFixed32Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32Int64MapMessage>();
    qRegisterMetaType<SimpleFixed32Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, QtProtobuf::int64>();
}

SimpleFixed32Int64MapMessage::SimpleFixed32Int64MapMessage()
    : QProtobufMessage(&SimpleFixed32Int64MapMessage::staticMetaObject, &SimpleFixed32Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32Int64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed32Int64MapMessage::MapFieldEntry &SimpleFixed32Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32Int64MapMessage::setMapField(const SimpleFixed32Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32Int64MapMessage::setMapField(SimpleFixed32Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64Int64MapMessage_QtProtobufData(const SimpleFixed64Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64Int64MapMessage::~SimpleFixed64Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64Int64MapMessage_char_data[65];
} qt_protobuf_SimpleFixed64Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        54, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        55, /* = mapField */
        64, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64Int64MapMessage_metadata.data
};

void SimpleFixed64Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64Int64MapMessage>();
    qRegisterMetaType<SimpleFixed64Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, QtProtobuf::int64>();
}

SimpleFixed64Int64MapMessage::SimpleFixed64Int64MapMessage()
    : QProtobufMessage(&SimpleFixed64Int64MapMessage::staticMetaObject, &SimpleFixed64Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64Int64MapMessage_QtProtobufData)
{
}

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

const SimpleFixed64Int64MapMessage::MapFieldEntry &SimpleFixed64Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64Int64MapMessage::setMapField(const SimpleFixed64Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64Int64MapMessage::setMapField(SimpleFixed64Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32Int64MapMessage_QtProtobufData(const SimpleSFixed32Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32Int64MapMessage::~SimpleSFixed32Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32Int64MapMessage_char_data[66];
} qt_protobuf_SimpleSFixed32Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32Int64MapMessage_metadata.data
};

void SimpleSFixed32Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32Int64MapMessage>();
    qRegisterMetaType<SimpleSFixed32Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, QtProtobuf::int64>();
}

SimpleSFixed32Int64MapMessage::SimpleSFixed32Int64MapMessage()
    : QProtobufMessage(&SimpleSFixed32Int64MapMessage::staticMetaObject, &SimpleSFixed32Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32Int64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32Int64MapMessage::MapFieldEntry &SimpleSFixed32Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32Int64MapMessage::setMapField(const SimpleSFixed32Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32Int64MapMessage::setMapField(SimpleSFixed32Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64Int64MapMessage_QtProtobufData(const SimpleSFixed64Int64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64Int64MapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64Int64MapMessage::~SimpleSFixed64Int64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64Int64MapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64Int64MapMessage_char_data[66];
} qt_protobuf_SimpleSFixed64Int64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        55, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        56, /* = mapField */
        65, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64Int64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64Int64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64Int64MapMessage_metadata.data
};

void SimpleSFixed64Int64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64Int64MapMessage>();
    qRegisterMetaType<SimpleSFixed64Int64MapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64Int64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, QtProtobuf::int64>();
}

SimpleSFixed64Int64MapMessage::SimpleSFixed64Int64MapMessage()
    : QProtobufMessage(&SimpleSFixed64Int64MapMessage::staticMetaObject, &SimpleSFixed64Int64MapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64Int64MapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64Int64MapMessage::MapFieldEntry &SimpleSFixed64Int64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64Int64MapMessage::setMapField(const SimpleSFixed64Int64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64Int64MapMessage::setMapField(SimpleSFixed64Int64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringInt64MapMessage_QtProtobufData(const SimpleStringInt64MapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringInt64MapMessage::MapFieldEntry m_mapField;
};

SimpleStringInt64MapMessage::~SimpleStringInt64MapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringInt64MapMessage_uint_data;
    const char qt_protobuf_SimpleStringInt64MapMessage_char_data[64];
} qt_protobuf_SimpleStringInt64MapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        53, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        54, /* = mapField */
        63, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringInt64MapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringInt64MapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringInt64MapMessage_metadata.data
};

void SimpleStringInt64MapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringInt64MapMessage>();
    qRegisterMetaType<SimpleStringInt64MapMessageRepeated>();
    qRegisterMetaType<SimpleStringInt64MapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, QtProtobuf::int64>();
}

SimpleStringInt64MapMessage::SimpleStringInt64MapMessage()
    : QProtobufMessage(&SimpleStringInt64MapMessage::staticMetaObject, &SimpleStringInt64MapMessage::staticPropertyOrdering),
      dptr(new SimpleStringInt64MapMessage_QtProtobufData)
{
}

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

const SimpleStringInt64MapMessage::MapFieldEntry &SimpleStringInt64MapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringInt64MapMessage::setMapField(const SimpleStringInt64MapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringInt64MapMessage::setMapField(SimpleStringInt64MapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt32ComplexMessageMapMessage_QtProtobufData(const SimpleSInt32ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleSInt32ComplexMessageMapMessage::~SimpleSInt32ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt32ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleSInt32ComplexMessageMapMessage_char_data[73];
} qt_protobuf_SimpleSInt32ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        62, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        63, /* = mapField */
        72, /* = end-of-string-marker */
        // Field numbers:
        1, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt32ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt32ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt32ComplexMessageMapMessage_metadata.data
};

void SimpleSInt32ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt32ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleSInt32ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleSInt32ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint32, ComplexMessage>();
}

SimpleSInt32ComplexMessageMapMessage::SimpleSInt32ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleSInt32ComplexMessageMapMessage::staticMetaObject, &SimpleSInt32ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt32ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleSInt32ComplexMessageMapMessage::MapFieldEntry &SimpleSInt32ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt32ComplexMessageMapMessage::setMapField(const SimpleSInt32ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt32ComplexMessageMapMessage::setMapField(SimpleSInt32ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSInt64ComplexMessageMapMessage_QtProtobufData(const SimpleSInt64ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleSInt64ComplexMessageMapMessage::~SimpleSInt64ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSInt64ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleSInt64ComplexMessageMapMessage_char_data[73];
} qt_protobuf_SimpleSInt64ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        62, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        63, /* = mapField */
        72, /* = end-of-string-marker */
        // Field numbers:
        2, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSInt64ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSInt64ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSInt64ComplexMessageMapMessage_metadata.data
};

void SimpleSInt64ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSInt64ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleSInt64ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleSInt64ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sint64, ComplexMessage>();
}

SimpleSInt64ComplexMessageMapMessage::SimpleSInt64ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleSInt64ComplexMessageMapMessage::staticMetaObject, &SimpleSInt64ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleSInt64ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleSInt64ComplexMessageMapMessage::MapFieldEntry &SimpleSInt64ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSInt64ComplexMessageMapMessage::setMapField(const SimpleSInt64ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSInt64ComplexMessageMapMessage::setMapField(SimpleSInt64ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt32ComplexMessageMapMessage_QtProtobufData(const SimpleInt32ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleInt32ComplexMessageMapMessage::~SimpleInt32ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt32ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleInt32ComplexMessageMapMessage_char_data[72];
} qt_protobuf_SimpleInt32ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        61, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        62, /* = mapField */
        71, /* = end-of-string-marker */
        // Field numbers:
        3, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt32ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt32ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt32ComplexMessageMapMessage_metadata.data
};

void SimpleInt32ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt32ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleInt32ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleInt32ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int32, ComplexMessage>();
}

SimpleInt32ComplexMessageMapMessage::SimpleInt32ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleInt32ComplexMessageMapMessage::staticMetaObject, &SimpleInt32ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleInt32ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleInt32ComplexMessageMapMessage::MapFieldEntry &SimpleInt32ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt32ComplexMessageMapMessage::setMapField(const SimpleInt32ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt32ComplexMessageMapMessage::setMapField(SimpleInt32ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleInt64ComplexMessageMapMessage_QtProtobufData(const SimpleInt64ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleInt64ComplexMessageMapMessage::~SimpleInt64ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleInt64ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleInt64ComplexMessageMapMessage_char_data[72];
} qt_protobuf_SimpleInt64ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        61, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        62, /* = mapField */
        71, /* = end-of-string-marker */
        // Field numbers:
        4, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleInt64ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleInt64ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleInt64ComplexMessageMapMessage_metadata.data
};

void SimpleInt64ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleInt64ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleInt64ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleInt64ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::int64, ComplexMessage>();
}

SimpleInt64ComplexMessageMapMessage::SimpleInt64ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleInt64ComplexMessageMapMessage::staticMetaObject, &SimpleInt64ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleInt64ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleInt64ComplexMessageMapMessage::MapFieldEntry &SimpleInt64ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleInt64ComplexMessageMapMessage::setMapField(const SimpleInt64ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleInt64ComplexMessageMapMessage::setMapField(SimpleInt64ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt32ComplexMessageMapMessage_QtProtobufData(const SimpleUInt32ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleUInt32ComplexMessageMapMessage::~SimpleUInt32ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt32ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleUInt32ComplexMessageMapMessage_char_data[73];
} qt_protobuf_SimpleUInt32ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        62, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        63, /* = mapField */
        72, /* = end-of-string-marker */
        // Field numbers:
        5, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt32ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt32ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt32ComplexMessageMapMessage_metadata.data
};

void SimpleUInt32ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt32ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleUInt32ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleUInt32ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint32, ComplexMessage>();
}

SimpleUInt32ComplexMessageMapMessage::SimpleUInt32ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleUInt32ComplexMessageMapMessage::staticMetaObject, &SimpleUInt32ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt32ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleUInt32ComplexMessageMapMessage::MapFieldEntry &SimpleUInt32ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt32ComplexMessageMapMessage::setMapField(const SimpleUInt32ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt32ComplexMessageMapMessage::setMapField(SimpleUInt32ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleUInt64ComplexMessageMapMessage_QtProtobufData(const SimpleUInt64ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleUInt64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleUInt64ComplexMessageMapMessage::~SimpleUInt64ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleUInt64ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleUInt64ComplexMessageMapMessage_char_data[73];
} qt_protobuf_SimpleUInt64ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        62, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        63, /* = mapField */
        72, /* = end-of-string-marker */
        // Field numbers:
        6, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleUInt64ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleUInt64ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleUInt64ComplexMessageMapMessage_metadata.data
};

void SimpleUInt64ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleUInt64ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleUInt64ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleUInt64ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::uint64, ComplexMessage>();
}

SimpleUInt64ComplexMessageMapMessage::SimpleUInt64ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleUInt64ComplexMessageMapMessage::staticMetaObject, &SimpleUInt64ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleUInt64ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleUInt64ComplexMessageMapMessage::MapFieldEntry &SimpleUInt64ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleUInt64ComplexMessageMapMessage::setMapField(const SimpleUInt64ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleUInt64ComplexMessageMapMessage::setMapField(SimpleUInt64ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed32ComplexMessageMapMessage_QtProtobufData(const SimpleFixed32ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleFixed32ComplexMessageMapMessage::~SimpleFixed32ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed32ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleFixed32ComplexMessageMapMessage_char_data[74];
} qt_protobuf_SimpleFixed32ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        63, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        64, /* = mapField */
        73, /* = end-of-string-marker */
        // Field numbers:
        7, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed32ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed32ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed32ComplexMessageMapMessage_metadata.data
};

void SimpleFixed32ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed32ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleFixed32ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleFixed32ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed32, ComplexMessage>();
}

SimpleFixed32ComplexMessageMapMessage::SimpleFixed32ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleFixed32ComplexMessageMapMessage::staticMetaObject, &SimpleFixed32ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed32ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleFixed32ComplexMessageMapMessage::MapFieldEntry &SimpleFixed32ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed32ComplexMessageMapMessage::setMapField(const SimpleFixed32ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed32ComplexMessageMapMessage::setMapField(SimpleFixed32ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleFixed64ComplexMessageMapMessage_QtProtobufData(const SimpleFixed64ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleFixed64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleFixed64ComplexMessageMapMessage::~SimpleFixed64ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleFixed64ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleFixed64ComplexMessageMapMessage_char_data[74];
} qt_protobuf_SimpleFixed64ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        63, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        64, /* = mapField */
        73, /* = end-of-string-marker */
        // Field numbers:
        8, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleFixed64ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleFixed64ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleFixed64ComplexMessageMapMessage_metadata.data
};

void SimpleFixed64ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleFixed64ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleFixed64ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleFixed64ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::fixed64, ComplexMessage>();
}

SimpleFixed64ComplexMessageMapMessage::SimpleFixed64ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleFixed64ComplexMessageMapMessage::staticMetaObject, &SimpleFixed64ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleFixed64ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleFixed64ComplexMessageMapMessage::MapFieldEntry &SimpleFixed64ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleFixed64ComplexMessageMapMessage::setMapField(const SimpleFixed64ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleFixed64ComplexMessageMapMessage::setMapField(SimpleFixed64ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed32ComplexMessageMapMessage_QtProtobufData(const SimpleSFixed32ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed32ComplexMessageMapMessage::~SimpleSFixed32ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed32ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed32ComplexMessageMapMessage_char_data[75];
} qt_protobuf_SimpleSFixed32ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        64, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        65, /* = mapField */
        74, /* = end-of-string-marker */
        // Field numbers:
        9, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed32ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed32ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed32ComplexMessageMapMessage_metadata.data
};

void SimpleSFixed32ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed32ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleSFixed32ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed32, ComplexMessage>();
}

SimpleSFixed32ComplexMessageMapMessage::SimpleSFixed32ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleSFixed32ComplexMessageMapMessage::staticMetaObject, &SimpleSFixed32ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed32ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry &SimpleSFixed32ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed32ComplexMessageMapMessage::setMapField(const SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed32ComplexMessageMapMessage::setMapField(SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleSFixed64ComplexMessageMapMessage_QtProtobufData(const SimpleSFixed64ComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleSFixed64ComplexMessageMapMessage::~SimpleSFixed64ComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleSFixed64ComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleSFixed64ComplexMessageMapMessage_char_data[75];
} qt_protobuf_SimpleSFixed64ComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        64, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        65, /* = mapField */
        74, /* = end-of-string-marker */
        // Field numbers:
        10, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleSFixed64ComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleSFixed64ComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleSFixed64ComplexMessageMapMessage_metadata.data
};

void SimpleSFixed64ComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleSFixed64ComplexMessageMapMessage>();
    qRegisterMetaType<SimpleSFixed64ComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QtProtobuf::sfixed64, ComplexMessage>();
}

SimpleSFixed64ComplexMessageMapMessage::SimpleSFixed64ComplexMessageMapMessage()
    : QProtobufMessage(&SimpleSFixed64ComplexMessageMapMessage::staticMetaObject, &SimpleSFixed64ComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleSFixed64ComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry &SimpleSFixed64ComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleSFixed64ComplexMessageMapMessage::setMapField(const SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleSFixed64ComplexMessageMapMessage::setMapField(SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}


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

    SimpleStringComplexMessageMapMessage_QtProtobufData(const SimpleStringComplexMessageMapMessage_QtProtobufData &other)
        : QSharedData(other),
          m_mapField(other.m_mapField)
    {
    }

    SimpleStringComplexMessageMapMessage::MapFieldEntry m_mapField;
};

SimpleStringComplexMessageMapMessage::~SimpleStringComplexMessageMapMessage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_SimpleStringComplexMessageMapMessage_uint_data;
    const char qt_protobuf_SimpleStringComplexMessageMapMessage_char_data[73];
} qt_protobuf_SimpleStringComplexMessageMapMessage_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        62, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        63, /* = mapField */
        72, /* = end-of-string-marker */
        // Field numbers:
        13, /* = mapField */
        // Property indices:
        0, /* = mapField */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Map | QtProtobufPrivate::FieldFlag::Message), /* = mapField */
    },
    // char_data
    /* metadata char_data: */
    "qtprotobufnamespace.tests.SimpleStringComplexMessageMapMessage\0" /* = full message name */
    /* field char_data: */
    "mapField\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering SimpleStringComplexMessageMapMessage::staticPropertyOrdering = {
    &qt_protobuf_SimpleStringComplexMessageMapMessage_metadata.data
};

void SimpleStringComplexMessageMapMessage::registerTypes()
{
    qRegisterMetaType<SimpleStringComplexMessageMapMessage>();
    qRegisterMetaType<SimpleStringComplexMessageMapMessageRepeated>();
    qRegisterMetaType<SimpleStringComplexMessageMapMessage::MapFieldEntry>();
    qRegisterProtobufMapType<QString, ComplexMessage>();
}

SimpleStringComplexMessageMapMessage::SimpleStringComplexMessageMapMessage()
    : QProtobufMessage(&SimpleStringComplexMessageMapMessage::staticMetaObject, &SimpleStringComplexMessageMapMessage::staticPropertyOrdering),
      dptr(new SimpleStringComplexMessageMapMessage_QtProtobufData)
{
}

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

const SimpleStringComplexMessageMapMessage::MapFieldEntry &SimpleStringComplexMessageMapMessage::mapField() const &
{
    return dptr->m_mapField;
}

void SimpleStringComplexMessageMapMessage::setMapField(const SimpleStringComplexMessageMapMessage::MapFieldEntry &mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = mapField;
    }
}

void SimpleStringComplexMessageMapMessage::setMapField(SimpleStringComplexMessageMapMessage::MapFieldEntry &&mapField)
{
    if (dptr->m_mapField != mapField) {
        dptr.detach();
        dptr->m_mapField = std::move(mapField);
    }
}

} // namespace qtprotobufnamespace::tests

#include "moc_mapmessages.qpb.cpp"
