[cpp-qt-client] Fix warning (#16083)

* [cpp-qt-client] Fix warning * Handle warnings for MSVC * Add warning flags only for non-MSVC compilers * Fix warnings for MSVC compiler too
OpenAPITools · Jul 17, 2023 · 067b172 · 067b172
1 parent f8e19b4
commit 067b172
Show file tree

Hide file tree

Showing 21 changed files with 216 additions and 198 deletions.
diff --git a/modules/openapi-generator/src/main/resources/cpp-qt-client/helpers-body.mustache b/modules/openapi-generator/src/main/resources/cpp-qt-client/helpers-body.mustache
@@ -225,7 +225,7 @@ bool fromStringValue(const QString &inStr, QByteArray &value) {
     } else {
         value.clear();
         value.append(inStr.toUtf8());
-        return value.size() > 0;
+        return !value.isEmpty();
     }
 }
 

diff --git a/modules/openapi-generator/src/main/resources/cpp-qt-client/model-body.mustache b/modules/openapi-generator/src/main/resources/cpp-qt-client/model-body.mustache
@@ -46,9 +46,9 @@ void {{classname}}::fromJson(QString jsonString) {
 
 void {{classname}}::fromJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnum}}(QJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnum}} json) {
 {{^isEnum}}{{#vars}}{{^isContainer}}
-    m_{{name}}_isValid = ::{{cppNamespace}}::fromJsonValue({{name}}, json[QString("{{baseName}}")]);
+    m_{{name}}_isValid = ::{{cppNamespace}}::fromJsonValue(m_{{name}}, json[QString("{{baseName}}")]);
     m_{{name}}_isSet = !json[QString("{{baseName}}")].isNull() && m_{{name}}_isValid;{{/isContainer}}{{#isContainer}}{{^items.isContainer}}
-    m_{{name}}_isValid = ::{{cppNamespace}}::fromJsonValue({{name}}, json[QString("{{baseName}}")]);
+    m_{{name}}_isValid = ::{{cppNamespace}}::fromJsonValue(m_{{name}}, json[QString("{{baseName}}")]);
     m_{{name}}_isSet = !json[QString("{{baseName}}")].isNull() && m_{{name}}_isValid;{{/items.isContainer}}{{#items.isContainer}}{{#isArray}}
     if(json["{{baseName}}"].isArray()){
         auto arr = json["{{baseName}}"].toArray();
@@ -58,7 +58,7 @@ void {{classname}}::fromJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnu
                 {{^items.isContainer}}{{items.baseType}}{{/items.isContainer}}{{#items.isArray}}QList<{{items.items.baseType}}>{{/items.isArray}}{{#items.isMap}}QMap<QString, {{items.items.baseType}}>{{/items.isMap}} item;
                 m_{{name}}_isValid &= ::{{cppNamespace}}::fromJsonValue(item, jval);
                 m_{{name}}_isSet = !jval.isNull() && m_{{name}}_isValid;
-                {{name}}.push_back(item);
+                m_{{name}}.push_back(item);
             }
         }
     }{{/isArray}}{{#isMap}}
@@ -71,7 +71,7 @@ void {{classname}}::fromJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnu
                 auto jval = QJsonValue::fromVariant(varmap.value(val));
                 m_{{name}}_isValid &= ::{{cppNamespace}}::fromJsonValue(item, jval);
                 m_{{name}}_isSet &= !jval.isNull() && m_{{name}}_isValid;
-                {{name}}.insert({{name}}.end(), val, item);
+                m_{{name}}.insert(m_{{name}}.end(), val, item);
             }
         }
     }{{/isMap}}{{/items.isContainer}}{{/isContainer}}{{^-last}}
@@ -100,24 +100,24 @@ QString {{classname}}::asJson() const {
 
 QJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnum}} {{classname}}::asJson{{^isEnum}}Object{{/isEnum}}{{#isEnum}}Value{{/isEnum}}() const {
     {{^isEnum}}QJsonObject obj;{{#vars}}{{^isContainer}}{{#complexType}}
-    if ({{name}}.isSet()){{/complexType}}{{^complexType}}
+    if (m_{{name}}.isSet()){{/complexType}}{{^complexType}}
     if (m_{{name}}_isSet){{/complexType}} {
-        obj.insert(QString("{{baseName}}"), ::{{cppNamespace}}::toJsonValue({{name}}));
+        obj.insert(QString("{{baseName}}"), ::{{cppNamespace}}::toJsonValue(m_{{name}}));
     }{{/isContainer}}{{#isContainer}}
-    if ({{name}}.size() > 0) {
-        {{^items.isContainer}}obj.insert(QString("{{baseName}}"), ::{{cppNamespace}}::toJsonValue({{name}}));{{/items.isContainer}}{{#items.isContainer}}
-        obj.insert(QString("{{baseName}}"), toJsonValue({{name}}));{{/items.isContainer}}
+    if (m_{{name}}.size() > 0) {
+        {{^items.isContainer}}obj.insert(QString("{{baseName}}"), ::{{cppNamespace}}::toJsonValue(m_{{name}}));{{/items.isContainer}}{{#items.isContainer}}
+        obj.insert(QString("{{baseName}}"), toJsonValue(m_{{name}}));{{/items.isContainer}}
     }{{/isContainer}}{{/vars}}
     return obj;{{/isEnum}}{{#isEnum}}
     {{#allowableValues}}{{#enumVars}}{{#-first}}{{^isString}}return QJsonValue(static_cast<int>(m_value));{{/isString}}{{#isString}}return QJsonValue(asJson());{{/isString}}{{/-first}}{{/enumVars}}{{/allowableValues}}{{/isEnum}}
 }
 
 {{^isEnum}}{{#vars}}{{{dataType}}} {{classname}}::{{getter}}() const {
-    return {{name}};
+    return m_{{name}};
 }
 void {{classname}}::{{setter}}(const {{{dataType}}} &{{name}}) {
-    this->{{name}} = {{name}};
-    this->m_{{name}}_isSet = true;
+    m_{{name}} = {{name}};
+    m_{{name}}_isSet = true;
 }
 
 bool {{classname}}::is_{{name}}_Set() const{
@@ -141,7 +141,7 @@ void {{classname}}::setValue(const {{classname}}::e{{classname}}& value){
 bool {{classname}}::isSet() const {
     {{^isEnum}}bool isObjectUpdated = false;
     do {
-{{#vars}}        {{#isContainer}}if ({{name}}.size() > 0){{/isContainer}}{{^isContainer}}{{#complexType}}if ({{name}}.isSet()){{/complexType}}{{^complexType}}if (m_{{name}}_isSet){{/complexType}}{{/isContainer}} {
+{{#vars}}        {{#isContainer}}if (m_{{name}}.size() > 0){{/isContainer}}{{^isContainer}}{{#complexType}}if (m_{{name}}.isSet()){{/complexType}}{{^complexType}}if (m_{{name}}_isSet){{/complexType}}{{/isContainer}} {
             isObjectUpdated = true;
             break;
         }{{^-last}}

diff --git a/modules/openapi-generator/src/main/resources/cpp-qt-client/model-header.mustache b/modules/openapi-generator/src/main/resources/cpp-qt-client/model-header.mustache
@@ -60,7 +60,7 @@ public:
 private:
     void initializeModel();
 {{^isEnum}}{{#vars}}
-    {{{dataType}}} {{name}};
+    {{{dataType}}} m_{{name}};
     bool m_{{name}}_isSet;
     bool m_{{name}}_isValid;
 {{/vars}}{{/isEnum}}{{#isEnum}}

diff --git a/modules/openapi-generator/src/main/resources/cpp-qt-client/object.mustache b/modules/openapi-generator/src/main/resources/cpp-qt-client/object.mustache
@@ -54,7 +54,13 @@ inline bool operator==(const {{prefix}}Object& left, const {{prefix}}Object& rig
     return (left.asJsonObject() == right.asJsonObject());  
 }
 
-inline uint qHash(const {{prefix}}Object& obj, uint seed = 0) noexcept{
+inline
+#if QT_VERSION < 0x060000
+uint
+#else
+size_t
+#endif
+qHash(const {{prefix}}Object& obj, uint seed = 0) noexcept{
     return qHash(obj.asJsonObject(), seed);
 }
 

diff --git a/samples/client/petstore/cpp-qt/CMakeLists.txt b/samples/client/petstore/cpp-qt/CMakeLists.txt
@@ -7,6 +7,12 @@ set(CMAKE_AUTOMOC ON)
 
 find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core Network Gui Test)
 
+if(MSVC)
+  add_compile_options(/W4 /WX)
+else()
+  add_compile_options(-Wall -Wextra -Werror)
+endif()
+
 add_subdirectory(client)
 
 find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Test)

diff --git a/samples/client/petstore/cpp-qt/client/PFXApiResponse.cpp b/samples/client/petstore/cpp-qt/client/PFXApiResponse.cpp
@@ -52,13 +52,13 @@ void PFXApiResponse::fromJson(QString jsonString) {
 
 void PFXApiResponse::fromJsonObject(QJsonObject json) {
 
-    m_code_isValid = ::test_namespace::fromJsonValue(code, json[QString("code")]);
+    m_code_isValid = ::test_namespace::fromJsonValue(m_code, json[QString("code")]);
     m_code_isSet = !json[QString("code")].isNull() && m_code_isValid;
 
-    m_type_isValid = ::test_namespace::fromJsonValue(type, json[QString("type")]);
+    m_type_isValid = ::test_namespace::fromJsonValue(m_type, json[QString("type")]);
     m_type_isSet = !json[QString("type")].isNull() && m_type_isValid;
 
-    m_message_isValid = ::test_namespace::fromJsonValue(message, json[QString("message")]);
+    m_message_isValid = ::test_namespace::fromJsonValue(m_message, json[QString("message")]);
     m_message_isSet = !json[QString("message")].isNull() && m_message_isValid;
 }
 
@@ -72,23 +72,23 @@ QString PFXApiResponse::asJson() const {
 QJsonObject PFXApiResponse::asJsonObject() const {
     QJsonObject obj;
     if (m_code_isSet) {
-        obj.insert(QString("code"), ::test_namespace::toJsonValue(code));
+        obj.insert(QString("code"), ::test_namespace::toJsonValue(m_code));
     }
     if (m_type_isSet) {
-        obj.insert(QString("type"), ::test_namespace::toJsonValue(type));
+        obj.insert(QString("type"), ::test_namespace::toJsonValue(m_type));
     }
     if (m_message_isSet) {
-        obj.insert(QString("message"), ::test_namespace::toJsonValue(message));
+        obj.insert(QString("message"), ::test_namespace::toJsonValue(m_message));
     }
     return obj;
 }
 
 qint32 PFXApiResponse::getCode() const {
-    return code;
+    return m_code;
 }
 void PFXApiResponse::setCode(const qint32 &code) {
-    this->code = code;
-    this->m_code_isSet = true;
+    m_code = code;
+    m_code_isSet = true;
 }
 
 bool PFXApiResponse::is_code_Set() const{
@@ -100,11 +100,11 @@ bool PFXApiResponse::is_code_Valid() const{
 }
 
 QString PFXApiResponse::getType() const {
-    return type;
+    return m_type;
 }
 void PFXApiResponse::setType(const QString &type) {
-    this->type = type;
-    this->m_type_isSet = true;
+    m_type = type;
+    m_type_isSet = true;
 }
 
 bool PFXApiResponse::is_type_Set() const{
@@ -116,11 +116,11 @@ bool PFXApiResponse::is_type_Valid() const{
 }
 
 QString PFXApiResponse::getMessage() const {
-    return message;
+    return m_message;
 }
 void PFXApiResponse::setMessage(const QString &message) {
-    this->message = message;
-    this->m_message_isSet = true;
+    m_message = message;
+    m_message_isSet = true;
 }
 
 bool PFXApiResponse::is_message_Set() const{

diff --git a/samples/client/petstore/cpp-qt/client/PFXApiResponse.h b/samples/client/petstore/cpp-qt/client/PFXApiResponse.h
@@ -59,15 +59,15 @@ class PFXApiResponse : public PFXObject {
 private:
     void initializeModel();
 
-    qint32 code;
+    qint32 m_code;
     bool m_code_isSet;
     bool m_code_isValid;
 
-    QString type;
+    QString m_type;
     bool m_type_isSet;
     bool m_type_isValid;
 
-    QString message;
+    QString m_message;
     bool m_message_isSet;
     bool m_message_isValid;
 };

diff --git a/samples/client/petstore/cpp-qt/client/PFXCategory.cpp b/samples/client/petstore/cpp-qt/client/PFXCategory.cpp
@@ -49,10 +49,10 @@ void PFXCategory::fromJson(QString jsonString) {
 
 void PFXCategory::fromJsonObject(QJsonObject json) {
 
-    m_id_isValid = ::test_namespace::fromJsonValue(id, json[QString("id")]);
+    m_id_isValid = ::test_namespace::fromJsonValue(m_id, json[QString("id")]);
     m_id_isSet = !json[QString("id")].isNull() && m_id_isValid;
 
-    m_name_isValid = ::test_namespace::fromJsonValue(name, json[QString("name")]);
+    m_name_isValid = ::test_namespace::fromJsonValue(m_name, json[QString("name")]);
     m_name_isSet = !json[QString("name")].isNull() && m_name_isValid;
 }
 
@@ -66,20 +66,20 @@ QString PFXCategory::asJson() const {
 QJsonObject PFXCategory::asJsonObject() const {
     QJsonObject obj;
     if (m_id_isSet) {
-        obj.insert(QString("id"), ::test_namespace::toJsonValue(id));
+        obj.insert(QString("id"), ::test_namespace::toJsonValue(m_id));
     }
     if (m_name_isSet) {
-        obj.insert(QString("name"), ::test_namespace::toJsonValue(name));
+        obj.insert(QString("name"), ::test_namespace::toJsonValue(m_name));
     }
     return obj;
 }
 
 qint64 PFXCategory::getId() const {
-    return id;
+    return m_id;
 }
 void PFXCategory::setId(const qint64 &id) {
-    this->id = id;
-    this->m_id_isSet = true;
+    m_id = id;
+    m_id_isSet = true;
 }
 
 bool PFXCategory::is_id_Set() const{
@@ -91,11 +91,11 @@ bool PFXCategory::is_id_Valid() const{
 }
 
 QString PFXCategory::getName() const {
-    return name;
+    return m_name;
 }
 void PFXCategory::setName(const QString &name) {
-    this->name = name;
-    this->m_name_isSet = true;
+    m_name = name;
+    m_name_isSet = true;
 }
 
 bool PFXCategory::is_name_Set() const{

diff --git a/samples/client/petstore/cpp-qt/client/PFXCategory.h b/samples/client/petstore/cpp-qt/client/PFXCategory.h
@@ -54,11 +54,11 @@ class PFXCategory : public PFXObject {
 private:
     void initializeModel();
 
-    qint64 id;
+    qint64 m_id;
     bool m_id_isSet;
     bool m_id_isValid;
 
-    QString name;
+    QString m_name;
     bool m_name_isSet;
     bool m_name_isValid;
 };

diff --git a/samples/client/petstore/cpp-qt/client/PFXHelpers.cpp b/samples/client/petstore/cpp-qt/client/PFXHelpers.cpp
@@ -233,7 +233,7 @@ bool fromStringValue(const QString &inStr, QByteArray &value) {
     } else {
         value.clear();
         value.append(inStr.toUtf8());
-        return value.size() > 0;
+        return !value.isEmpty();
     }
 }
 

diff --git a/samples/client/petstore/cpp-qt/client/PFXObject.h b/samples/client/petstore/cpp-qt/client/PFXObject.h
@@ -62,7 +62,13 @@ inline bool operator==(const PFXObject& left, const PFXObject& right){
     return (left.asJsonObject() == right.asJsonObject());  
 }
 
-inline uint qHash(const PFXObject& obj, uint seed = 0) noexcept{
+inline
+#if QT_VERSION < 0x060000
+uint
+#else
+size_t
+#endif
+qHash(const PFXObject& obj, uint seed = 0) noexcept{
     return qHash(obj.asJsonObject(), seed);
 }