add cpprest generator

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -3706,7 +3706,7 @@ public class DefaultCodegen implements CodegenConfig {
         return mediaType.getSchema();
     }
 
-    private Schema getSchemaFromResponse(ApiResponse response) {
+    protected Schema getSchemaFromResponse(ApiResponse response) {
         if (response.getContent() == null || response.getContent().isEmpty()) {
             return null;
         }
@@ -4118,4 +4118,22 @@ public class DefaultCodegen implements CodegenConfig {
         return false;
     }
 
+    protected void addOption(String key, String description) {
+        addOption(key, description, null);
+    }
+
+    protected void addOption(String key, String description, String defaultValue) {
+        CliOption option = new CliOption(key, description);
+        if (defaultValue != null)
+            option.defaultValue(defaultValue);
+        cliOptions.add(option);
+    }
+
+    protected void addSwitch(String key, String description, Boolean defaultValue) {
+        CliOption option = CliOption.newBoolean(key, description);
+        if (defaultValue != null)
+            option.defaultValue(defaultValue.toString());
+        cliOptions.add(option);
+    }
+
 }

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractCppCodegen.java

@@ -0,0 +1,182 @@
+package org.openapitools.codegen.languages;
+
+import org.openapitools.codegen.CodegenConfig;
+import org.openapitools.codegen.CodegenProperty;
+import org.openapitools.codegen.DefaultCodegen;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.Operation;
+import io.swagger.v3.oas.models.media.*;
+
+import java.util.Arrays;
+
+abstract public class AbstractCppCodegen extends DefaultCodegen implements CodegenConfig {
+
+    public AbstractCppCodegen() {
+        super();
+
+        /*
+         * Reserved words.  Override this with reserved words specific to your language
+         */
+        setReservedWordsLowerCase(
+                Arrays.asList(
+                        "alignas",
+                        "alignof",
+                        "and",
+                        "and_eq",
+                        "asm",
+                        "auto",
+                        "bitand",
+                        "bitor",
+                        "bool",
+                        "break",
+                        "case",
+                        "catch",
+                        "char",
+                        "char16_t",
+                        "char32_t",
+                        "class",
+                        "compl",
+                        "concept",
+                        "const",
+                        "constexpr",
+                        "const_cast",
+                        "continue",
+                        "decltype",
+                        "default",
+                        "delete",
+                        "do",
+                        "double",
+                        "dynamic_cast",
+                        "else",
+                        "enum",
+                        "explicit",
+                        "export",
+                        "extern",
+                        "false",
+                        "float",
+                        "for",
+                        "friend",
+                        "goto",
+                        "if",
+                        "inline",
+                        "int",
+                        "linux",
+                        "long",
+                        "mutable",
+                        "namespace",
+                        "new",
+                        "noexcept",
+                        "not",
+                        "not_eq",
+                        "nullptr",
+                        "operator",
+                        "or",
+                        "or_eq",
+                        "private",
+                        "protected",
+                        "public",
+                        "register",
+                        "reinterpret_cast",
+                        "requires",
+                        "return",
+                        "short",
+                        "signed",
+                        "sizeof",
+                        "static",
+                        "static_assert",
+                        "static_cast",
+                        "struct",
+                        "switch",
+                        "template",
+                        "this",
+                        "thread_local",
+                        "throw",
+                        "true",
+                        "try",
+                        "typedef",
+                        "typeid",
+                        "typename",
+                        "union",
+                        "unsigned",
+                        "using",
+                        "virtual",
+                        "void",
+                        "volatile",
+                        "wchar_t",
+                        "while",
+                        "xor",
+                        "xor_eq")
+        );
+    }
+
+    @Override
+    public String toVarName(String name) {
+        if (typeMapping.keySet().contains(name) || typeMapping.values().contains(name)
+                || importMapping.values().contains(name) || defaultIncludes.contains(name)
+                || languageSpecificPrimitives.contains(name)) {
+            return sanitizeName(name);
+        }
+
+        if (isReservedWord(name)) {
+            return escapeReservedWord(name);
+        }
+
+        if (name.length() > 1) {
+            return sanitizeName(Character.toUpperCase(name.charAt(0)) + name.substring(1));
+        }
+
+        return sanitizeName(name);
+    }
+
+    /**
+     * Escapes a reserved word as defined in the `reservedWords` array. Handle
+     * escaping those terms here. This logic is only called if a variable
+     * matches the reserved words
+     *
+     * @return the escaped term
+     */
+    @Override
+    public String escapeReservedWord(String name) {
+        if (this.reservedWordsMappings().containsKey(name)) {
+            return this.reservedWordsMappings().get(name);
+        }
+        return sanitizeName("_" + name);
+    }
+
+    @Override
+    public String toOperationId(String operationId) {
+        if (isReservedWord(operationId)) {
+            LOGGER.warn(operationId + " (reserved word) cannot be used as method name. Renamed to " + escapeReservedWord(operationId));
+            return escapeReservedWord(operationId);
+        }
+        return sanitizeName(super.toOperationId(operationId));
+    }
+
+    @Override
+    public String toParamName(String name) {
+        return sanitizeName(super.toParamName(name));
+    }
+
+    @Override
+    public CodegenProperty fromProperty(String name, Schema p) {
+        CodegenProperty property = super.fromProperty(name, p);
+        String nameInCamelCase = property.nameInCamelCase;
+        if (nameInCamelCase.length() > 1) {
+            nameInCamelCase = sanitizeName(Character.toLowerCase(nameInCamelCase.charAt(0)) + nameInCamelCase.substring(1));
+        } else {
+            nameInCamelCase = sanitizeName(nameInCamelCase);
+        }
+        property.nameInCamelCase = nameInCamelCase;
+        return property;
+    }
+
+    /**
+     * Output the Getter name for boolean property, e.g. isActive
+     *
+     * @param name the name of the property
+     * @return getter name based on naming convention
+     */
+    public String toBooleanGetter(String name) {
+        return "is" + getterAndSetterCapitalize(name);
+    }
+}

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/CppRestClientCodegen.java

@@ -0,0 +1,429 @@
+package org.openapitools.codegen.languages;
+
+import static com.google.common.base.Strings.isNullOrEmpty;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+
+import org.apache.commons.lang3.StringUtils;
+import org.openapitools.codegen.CliOption;
+import org.openapitools.codegen.CodegenConstants;
+import org.openapitools.codegen.CodegenModel;
+import org.openapitools.codegen.CodegenOperation;
+import org.openapitools.codegen.CodegenParameter;
+import org.openapitools.codegen.CodegenProperty;
+import org.openapitools.codegen.CodegenType;
+import org.openapitools.codegen.SupportingFile;
+import org.openapitools.codegen.utils.ModelUtils;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.Operation;
+import io.swagger.v3.oas.models.media.*;
+import io.swagger.v3.oas.models.responses.ApiResponse;
+import io.swagger.v3.parser.util.SchemaTypeUtil;
+
+
+public class CppRestClientCodegen extends AbstractCppCodegen {
+
+    public static final String DECLSPEC = "declspec";
+    public static final String DEFAULT_INCLUDE = "defaultInclude";
+
+    protected String packageVersion = "1.0.0";
+    protected String declspec = "";
+    protected String defaultInclude = "";
+
+    private final Set<String> parentModels = new HashSet<>();
+    private final Multimap<String, CodegenModel> childrenByParent = ArrayListMultimap.create();
+
+    /**
+     * Configures the type of generator.
+     *
+     * @return the CodegenType for this generator
+     * @see org.openapitools.codegen.CodegenType
+     */
+    public CodegenType getTag() {
+        return CodegenType.CLIENT;
+    }
+
+    /**
+     * Configures a friendly name for the generator. This will be used by the
+     * generator to select the library with the -l flag.
+     *
+     * @return the friendly name for the generator
+     */
+    public String getName() {
+        return "cpprest";
+    }
+
+    /**
+     * Returns human-friendly help for the generator. Provide the consumer with
+     * help tips, parameters here
+     *
+     * @return A string value for the help message
+     */
+    public String getHelp() {
+        return "Generates a C++ API client with C++ REST SDK (https://github.com/Microsoft/cpprestsdk).";
+    }
+
+    public CppRestClientCodegen() {
+        super();
+
+        apiPackage = "io.swagger.client.api";
+        modelPackage = "io.swagger.client.model";
+
+        modelTemplateFiles.put("model-header.mustache", ".h");
+        modelTemplateFiles.put("model-source.mustache", ".cpp");
+
+        apiTemplateFiles.put("api-header.mustache", ".h");
+        apiTemplateFiles.put("api-source.mustache", ".cpp");
+
+        embeddedTemplateDir = templateDir = "cpprest";
+
+        cliOptions.clear();
+
+        // CLI options
+        addOption(CodegenConstants.MODEL_PACKAGE, "C++ namespace for models (convention: name.space.model).",
+                this.modelPackage);
+        addOption(CodegenConstants.API_PACKAGE, "C++ namespace for apis (convention: name.space.api).",
+                this.apiPackage);
+        addOption(CodegenConstants.PACKAGE_VERSION, "C++ package version.", this.packageVersion);
+        addOption(DECLSPEC, "C++ preprocessor to place before the class name for handling dllexport/dllimport.",
+                this.declspec);
+        addOption(DEFAULT_INCLUDE,
+                "The default include statement that should be placed in all headers for including things like the declspec (convention: #include \"Commons.h\" ",
+                this.defaultInclude);
+
+        supportingFiles.add(new SupportingFile("modelbase-header.mustache", "", "ModelBase.h"));
+        supportingFiles.add(new SupportingFile("modelbase-source.mustache", "", "ModelBase.cpp"));
+        supportingFiles.add(new SupportingFile("object-header.mustache", "", "Object.h"));
+        supportingFiles.add(new SupportingFile("object-source.mustache", "", "Object.cpp"));
+        supportingFiles.add(new SupportingFile("apiclient-header.mustache", "", "ApiClient.h"));
+        supportingFiles.add(new SupportingFile("apiclient-source.mustache", "", "ApiClient.cpp"));
+        supportingFiles.add(new SupportingFile("apiconfiguration-header.mustache", "", "ApiConfiguration.h"));
+        supportingFiles.add(new SupportingFile("apiconfiguration-source.mustache", "", "ApiConfiguration.cpp"));
+        supportingFiles.add(new SupportingFile("apiexception-header.mustache", "", "ApiException.h"));
+        supportingFiles.add(new SupportingFile("apiexception-source.mustache", "", "ApiException.cpp"));
+        supportingFiles.add(new SupportingFile("ihttpbody-header.mustache", "", "IHttpBody.h"));
+        supportingFiles.add(new SupportingFile("jsonbody-header.mustache", "", "JsonBody.h"));
+        supportingFiles.add(new SupportingFile("jsonbody-source.mustache", "", "JsonBody.cpp"));
+        supportingFiles.add(new SupportingFile("httpcontent-header.mustache", "", "HttpContent.h"));
+        supportingFiles.add(new SupportingFile("httpcontent-source.mustache", "", "HttpContent.cpp"));
+        supportingFiles.add(new SupportingFile("multipart-header.mustache", "", "MultipartFormData.h"));
+        supportingFiles.add(new SupportingFile("multipart-source.mustache", "", "MultipartFormData.cpp"));
+        supportingFiles.add(new SupportingFile("gitignore.mustache", "", ".gitignore"));
+        supportingFiles.add(new SupportingFile("git_push.sh.mustache", "", "git_push.sh"));
+        supportingFiles.add(new SupportingFile("cmake-lists.mustache", "", "CMakeLists.txt"));
+
+        languageSpecificPrimitives = new HashSet<String>(
+                Arrays.asList("int", "char", "bool", "long", "float", "double", "int32_t", "int64_t"));
+
+        typeMapping = new HashMap<String, String>();
+        typeMapping.put("date", "utility::datetime");
+        typeMapping.put("DateTime", "utility::datetime");
+        typeMapping.put("string", "utility::string_t");
+        typeMapping.put("integer", "int32_t");
+        typeMapping.put("long", "int64_t");
+        typeMapping.put("boolean", "bool");
+        typeMapping.put("array", "std::vector");
+        typeMapping.put("map", "std::map");
+        typeMapping.put("file", "HttpContent");
+        typeMapping.put("object", "Object");
+        typeMapping.put("binary", "std::string");
+        typeMapping.put("number", "double");
+        typeMapping.put("UUID", "utility::string_t");
+
+        super.importMapping = new HashMap<String, String>();
+        importMapping.put("std::vector", "#include <vector>");
+        importMapping.put("std::map", "#include <map>");
+        importMapping.put("std::string", "#include <string>");
+        importMapping.put("HttpContent", "#include \"HttpContent.h\"");
+        importMapping.put("Object", "#include \"Object.h\"");
+        importMapping.put("utility::string_t", "#include <cpprest/details/basic_types.h>");
+        importMapping.put("utility::datetime", "#include <cpprest/details/basic_types.h>");
+    }
+
+    @Override
+    public void processOpts() {
+        super.processOpts();
+
+        if (additionalProperties.containsKey(DECLSPEC)) {
+            declspec = additionalProperties.get(DECLSPEC).toString();
+        }
+
+        if (additionalProperties.containsKey(DEFAULT_INCLUDE)) {
+            defaultInclude = additionalProperties.get(DEFAULT_INCLUDE).toString();
+        }
+
+        additionalProperties.put("modelNamespaceDeclarations", modelPackage.split("\\."));
+        additionalProperties.put("modelNamespace", modelPackage.replaceAll("\\.", "::"));
+        additionalProperties.put("modelHeaderGuardPrefix", modelPackage.replaceAll("\\.", "_").toUpperCase());
+        additionalProperties.put("apiNamespaceDeclarations", apiPackage.split("\\."));
+        additionalProperties.put("apiNamespace", apiPackage.replaceAll("\\.", "::"));
+        additionalProperties.put("apiHeaderGuardPrefix", apiPackage.replaceAll("\\.", "_").toUpperCase());
+        additionalProperties.put("declspec", declspec);
+        additionalProperties.put("defaultInclude", defaultInclude);
+    }
+
+    /**
+     * Location to write model files. You can use the modelPackage() as defined
+     * when the class is instantiated
+     */
+    public String modelFileFolder() {
+        return outputFolder + "/model";
+    }
+
+    /**
+     * Location to write api files. You can use the apiPackage() as defined when
+     * the class is instantiated
+     */
+    @Override
+    public String apiFileFolder() {
+        return outputFolder + "/api";
+    }
+
+    @Override
+    public String toModelImport(String name) {
+        if (importMapping.containsKey(name)) {
+            return importMapping.get(name);
+        } else {
+            return "#include \"" + name + ".h\"";
+        }
+    }
+
+    @Override
+    public CodegenModel fromModel(String name, Schema model, Map<String, Schema> allDefinitions) {
+        CodegenModel codegenModel = super.fromModel(name, model, allDefinitions);
+
+        Set<String> oldImports = codegenModel.imports;
+        codegenModel.imports = new HashSet<String>();
+        for (String imp : oldImports) {
+            String newImp = toModelImport(imp);
+            if (!newImp.isEmpty()) {
+                codegenModel.imports.add(newImp);
+            }
+        }
+
+        return codegenModel;
+    }
+
+    @Override
+    public CodegenOperation fromOperation(String path, String httpMethod, Operation operation,
+                                          Map<String, Schema> schema, OpenAPI openAPI) {
+        CodegenOperation op = super.fromOperation(path, httpMethod, operation, schema, openAPI);
+
+        if (operation.getResponses() != null && !operation.getResponses().isEmpty()) {
+            ApiResponse methodResponse = findMethodResponse(operation.getResponses());
+
+            if (methodResponse != null) {
+                Schema response = getSchemaFromResponse(methodResponse);
+                if (response != null) {
+                    CodegenProperty cm = fromProperty("response", response);
+                    op.vendorExtensions.put("x-codegen-response", cm);
+                    if (cm.datatype == "HttpContent") {
+                        op.vendorExtensions.put("x-codegen-response-ishttpcontent", true);
+                    }
+                }
+            }
+        }
+
+        return op;
+    }
+
+    @Override
+    public void postProcessModelProperty(CodegenModel model, CodegenProperty property) {
+        if (isFileSchema(property)) {
+            property.vendorExtensions.put("x-codegen-file", true);
+        }
+
+        if (!isNullOrEmpty(model.parent)) {
+            parentModels.add(model.parent);
+            if (!childrenByParent.containsEntry(model.parent, model)) {
+                childrenByParent.put(model.parent, model);
+            }
+        }
+    }
+
+    protected boolean isFileSchema(CodegenProperty property) {
+        return property.baseType.equals("HttpContent");
+    }
+
+    @Override
+    public String toModelFilename(String name) {
+        return initialCaps(name);
+    }
+
+    @Override
+    public String toApiFilename(String name) {
+        return initialCaps(name) + "Api";
+    }
+
+    /**
+     * Optional - type declaration. This is a String which is used by the
+     * templates to instantiate your types. There is typically special handling
+     * for different property types
+     *
+     * @return a string value used as the `dataType` field for model templates,
+     * `returnType` for api templates
+     */
+    @Override
+    public String getTypeDeclaration(Schema p) {
+        String swaggerType = getSchemaType(p);
+
+        if (p instanceof ArraySchema) {
+            ArraySchema ap = (ArraySchema) p;
+            Schema inner = ap.getItems();
+            return getSchemaType(p) + "<" + getTypeDeclaration(inner) + ">";
+        }
+        if (p instanceof MapSchema) {
+            MapSchema mp = (MapSchema) p;
+            Schema inner = (Schema) mp.getAdditionalProperties();
+            return getSchemaType(p) + "<utility::string_t, " + getTypeDeclaration(inner) + ">";
+        }
+        if (p instanceof StringSchema || p instanceof DateSchema
+                || p instanceof DateTimeSchema || p instanceof FileSchema
+                || languageSpecificPrimitives.contains(swaggerType)) {
+            return toModelName(swaggerType);
+        }
+
+        return "std::shared_ptr<" + swaggerType + ">";
+    }
+
+    @Override
+    public String toDefaultValue(Schema p) {
+        if (p instanceof StringSchema) {
+            return "utility::conversions::to_string_t(\"\")";
+        } else if (p instanceof BooleanSchema) {
+            return "false";
+        } else if (p instanceof DateSchema) {
+            return "utility::datetime()";
+        } else if (p instanceof DateTimeSchema) {
+            return "utility::datetime()";
+        } else if (p instanceof NumberSchema) {
+            if(SchemaTypeUtil.FLOAT_FORMAT.equals(p.getFormat())) {
+                return "0.0f";
+            }
+            return "0.0";
+        } else if (p instanceof IntegerSchema) {
+            if(SchemaTypeUtil.INTEGER64_FORMAT.equals(p.getFormat())) {
+                return "0L";
+            }
+            return "0";
+        } else if (p instanceof MapSchema) {
+            MapSchema ap = (MapSchema) p;
+            String inner = getSchemaType((Schema) ap.getAdditionalProperties());
+            return "std::map<utility::string_t, " + inner + ">()";
+        } else if (p instanceof ArraySchema) {
+            ArraySchema ap = (ArraySchema) p;
+            String inner = getSchemaType(ap.getItems());
+            if (!languageSpecificPrimitives.contains(inner)) {
+                inner = "std::shared_ptr<" + inner + ">";
+            }
+            return "std::vector<" + inner + ">()";
+        } else if (!StringUtils.isEmpty(p.get$ref())) {
+            return "new " + toModelName(p.get$ref()) + "()";
+        }
+        return "nullptr";
+    }
+
+    @Override
+    public void postProcessParameter(CodegenParameter parameter) {
+        super.postProcessParameter(parameter);
+
+        boolean isPrimitiveType = parameter.isPrimitiveType == Boolean.TRUE;
+        boolean isListContainer = parameter.isListContainer == Boolean.TRUE;
+        boolean isString = parameter.isString == Boolean.TRUE;
+
+        if (!isPrimitiveType && !isListContainer && !isString && !parameter.dataType.startsWith("std::shared_ptr")) {
+            parameter.dataType = "std::shared_ptr<" + parameter.dataType + ">";
+        }
+    }
+
+    /**
+     * Optional - swagger type conversion. This is used to map swagger types in
+     * a `Schema` into either language specific types via `typeMapping` or
+     * into complex models if there is not a mapping.
+     *
+     * @return a string value of the type or complex model for this property
+     * @see io.swagger.models.properties.Schema
+     */
+    @Override
+    public String getSchemaType(Schema p) {
+        String swaggerType = super.getSchemaType(p);
+        String type = null;
+        if (typeMapping.containsKey(swaggerType)) {
+            type = typeMapping.get(swaggerType);
+            if (languageSpecificPrimitives.contains(type))
+                return toModelName(type);
+        } else
+            type = swaggerType;
+        return toModelName(type);
+    }
+
+    @Override
+    public String toModelName(String type) {
+        if (typeMapping.keySet().contains(type) || typeMapping.values().contains(type)
+                || importMapping.values().contains(type) || defaultIncludes.contains(type)
+                || languageSpecificPrimitives.contains(type)) {
+            return type;
+        } else {
+            return Character.toUpperCase(type.charAt(0)) + type.substring(1);
+        }
+    }
+
+    @Override
+    public String toApiName(String type) {
+        return Character.toUpperCase(type.charAt(0)) + type.substring(1) + "Api";
+    }
+
+    @Override
+    public String escapeQuotationMark(String input) {
+        // remove " to avoid code injection
+        return input.replace("\"", "");
+    }
+
+    @Override
+    public String escapeUnsafeCharacters(String input) {
+        return input.replace("*/", "*_/").replace("/*", "/_*");
+    }
+
+    @Override
+    public Map<String, Object> postProcessAllModels(final Map<String, Object> models) {
+
+        final Map<String, Object> processed = super.postProcessAllModels(models);
+        postProcessParentModels(models);
+        return processed;
+    }
+
+    private void postProcessParentModels(final Map<String, Object> models) {
+        for (final String parent : parentModels) {
+            final CodegenModel parentModel = ModelUtils.getModelByName(parent, models);
+            final Collection<CodegenModel> childrenModels = childrenByParent.get(parent);
+            for (final CodegenModel child : childrenModels) {
+                processParentPropertiesInChildModel(parentModel, child);
+            }
+        }
+    }
+
+    /**
+     * Sets the child property's isInherited flag to true if it is an inherited property
+     */
+    private void processParentPropertiesInChildModel(final CodegenModel parent, final CodegenModel child) {
+        final Map<String, CodegenProperty> childPropertiesByName = new HashMap<>(child.vars.size());
+        for (final CodegenProperty childSchema : child.vars) {
+            childPropertiesByName.put(childSchema.name, childSchema);
+        }
+        for (final CodegenProperty parentSchema : parent.vars) {
+            final CodegenProperty duplicatedByParent = childPropertiesByName.get(parentSchema.name);
+            if (duplicatedByParent != null) {
+                duplicatedByParent.isInherited = true;
+            }
+        }
+    }
+
+}

modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig

@@ -4,6 +4,7 @@ org.openapitools.codegen.languages.AkkaScalaClientCodegen
 org.openapitools.codegen.languages.BashClientCodegen
 org.openapitools.codegen.languages.ClojureClientCodegen
 org.openapitools.codegen.languages.ConfluenceWikiCodegen
+org.openapitools.codegen.languages.CppRestClientCodegen
 org.openapitools.codegen.languages.DartClientCodegen
 org.openapitools.codegen.languages.ElixirClientCodegen
 org.openapitools.codegen.languages.HaskellServantCodegen