CPPSDK: parameter and result handling changes

languages/cpp/templates/parameter-serialization/generic.cpp

@@ -0,0 +1,2 @@
+            WPEFramework::Core::JSON::Variant ${Property} = ${property};
+            jsonParameters.Set(_T("${property}"), ${Property});

languages/cpp/templates/types/anyOf.c

@@ -1 +1 @@
-/* AnyOf is not supported in CPP: ${title} */
+string

languages/cpp/templates/types/tuple.h

@@ -1,2 +1,2 @@
 /* ${title} */
-std::pair<${type},${type}> ${title};
+std::pair<${items}> ${title};

src/macrofier/engine.mjs

@@ -1245,6 +1245,7 @@ function insertMethodMacros(template, methodObj, json, templates, examples = {})
     .replace(/\$\{method\.params\.count}/g, methodObj.params ? methodObj.params.length : 0)
     .replace(/\$\{if\.params\}(.*?)\$\{end\.if\.params\}/gms, method.params.length ? '$1' : '')
     .replace(/\$\{if\.result\}(.*?)\$\{end\.if\.result\}/gms, resultType ? '$1' : '')
+    .replace(/\$\{if\.result.nonvoid\}(.*?)\$\{end\.if\.result.nonvoid\}/gms, resultType && resultType !== 'void' ? '$1' : '')
     .replace(/\$\{if\.result\.properties\}(.*?)\$\{end\.if\.result\.properties\}/gms, resultParams ? '$1' : '')
     .replace(/\$\{if\.params\.empty\}(.*?)\$\{end\.if\.params\.empty\}/gms, method.params.length === 0 ? '$1' : '')
     .replace(/\$\{if\.signature\.empty\}(.*?)\$\{end\.if\.signature\.empty\}/gms, (method.params.length === 0 && resultType === '') ? '$1' : '')
@@ -1253,6 +1254,7 @@ function insertMethodMacros(template, methodObj, json, templates, examples = {})
     .replace(/\$\{method\.params\.serialization\.with\.indent\}/g, indent(serializedParams, '    '))
     // Typed signature stuff
     .replace(/\$\{method\.signature\.params\}/g, types.getMethodSignatureParams(methodObj, json, { destination: state.destination, section: state.section }))
+    .replace(/\$\{method\.signature\.result\}/g, types.getMethodSignatureResult(methodObj, json, { destination: state.destination, section: state.section }))
     .replace(/\$\{method\.context\}/g, method.context.join(', '))
     .replace(/\$\{method\.context\.array\}/g, JSON.stringify(method.context))
     .replace(/\$\{method\.context\.count}/g, method.context ? method.context.length : 0)

src/macrofier/types.mjs

@@ -30,6 +30,8 @@ const primitives = {
   "string": "string"
 }
 
+const isVoid = type => (type === 'void') ? true : false
+const isPrimitiveType = type => primitives[type] ? true : false
 const allocatedPrimitiveProxies = {}
 
 function setTemplates(t) {
@@ -53,17 +55,48 @@ const safeName = value => value.split(':').pop().replace(/[\.\-]/g, '_').replace
 
 // TODO: This is what's left of getMethodSignatureParams. We need to figure out / handle C's `FireboltTypes_StringHandle`
 function getMethodSignatureParams(method, module, { destination, callback }) {
-  const paramRequired = getTemplate('/parameters/default')
   const paramOptional = getTemplate('/parameters/optional')
   return method.params.map(param => {
-    let type = getSchemaType(param.schema, module, { destination })
+    let type = getSchemaType(param.schema, module, { destination, namespace : true })
     if (callback && allocatedPrimitiveProxies[type]) {
       type = allocatedPrimitiveProxies[type]
     }
+
+    let paramRequired = ''
+    let jsonType = getJsonType(param.schema, module, { destination })
+    if (!isPrimitiveType(jsonType) && getTemplate('/parameters/nonprimitive')) {
+      paramRequired = getTemplate('/parameters/nonprimitive')
+    }
+    else if ((jsonType === 'string') && getTemplate('/parameters/string')) {
+      paramRequired = getTemplate('/parameters/string')
+    }
+    else {
+      paramRequired = getTemplate('/parameters/default')
+    }
+
     return (param.required ? paramRequired : paramOptional).replace(/\$\{method\.param\.name\}/g, param.name).replace(/\$\{method\.param\.type\}/g, type)
   }).join(', ')
 }
 
+function getMethodSignatureResult(method, module, { destination, callback }) {
+    let type = getSchemaType(method.result.schema, module, { destination, namespace : true })
+
+    let result = ''
+    let jsonType = getJsonType(method.result.schema, module, { destination })
+
+    if (!isVoid(type) && !isPrimitiveType(jsonType) && getTemplate('/result/nonprimitive')) {
+      result = getTemplate('/result/nonprimitive')
+    }
+    else if ((jsonType === 'string') && getTemplate('/result/string')) {
+      result = getTemplate('/result/string')
+    }
+    else {
+      result = getTemplate('/result/default')
+    }
+
+    return result.replace(/\$\{method\.result\.type\}/g, type)
+}
+
 const getTemplate = (name) => {
   if (name[0] !== '/') {
     name = '/' + name
@@ -120,8 +153,6 @@ const insertConstMacros = (content, schema, module, name) => {
   return content
 }
 
-
-
 const insertEnumMacros = (content, schema, module, name) => {
   const template = content.split('\n')
 
@@ -251,6 +282,7 @@ const insertTupleMacros = (content, schema, module, title, options) => {
   const itemsTemplate = getTemplate(path.join(options.templateDir, 'items'))
   const propIndent = (content.split('\n').find(line => line.includes("${properties}")) || '').match(/^\s+/) || [''][0]
   const itemsIndent = (content.split('\n').find(line => line.includes("${items}")) || '').match(/^\s+/) || [''][0]
+  const delimiter = getTemplate(path.join(options.templateDir, 'delimiter'))
 
   const doMacroWork = (str, prop, i, indent) => {
     const schemaShape = getSchemaShape(prop, module, options)
@@ -267,8 +299,8 @@ const insertTupleMacros = (content, schema, module, title, options) => {
       .replace(/\$\{if\.optional\}(.*?)\$\{end\.if\.optional\}/gms, '')
   }
 
-  content = content.replace(/\$\{properties\}/g, schema.items.map((prop, i) => doMacroWork(propTemplate, prop, i, propIndent)).join('\n'))
-  content = content.replace(/\$\{items\}/g, schema.items.map((prop, i) => doMacroWork(itemsTemplate, prop, i, itemsIndent)).join('\n'))  
+  content = content.replace(/\$\{properties\}/g, schema.items.map((prop, i) => doMacroWork(propTemplate, prop, i, propIndent)).join(delimiter))
+  content = content.replace(/\$\{items\}/g, schema.items.map((prop, i) => doMacroWork(itemsTemplate, prop, i, itemsIndent)).join(delimiter))
 
   return content
 }
@@ -287,10 +319,13 @@ const insertPrimitiveMacros = (content, schema, module, name, templateDir) => {
 
 const insertAnyOfMacros = (content, schema, module, name) => {
   const itemTemplate = content
-  content = schema.anyOf.map((item, i) => itemTemplate
-    .replace(/\$\{type\}/g, getSchemaType(item, module))
-    .replace(/\$\{delimiter\}(.*?)\$\{end.delimiter\}/g, i === schema.anyOf.length - 1 ? '' : '$1')
-  ).join('')
+  if (content.split('\n').find(line => line.includes("${type}"))) {
+    content = schema.anyOf.map((item, i) => itemTemplate
+      .replace(/\$\{type\}/g, getSchemaType(item, module))
+      .replace(/\$\{delimiter\}(.*?)\$\{end.delimiter\}/g, i === schema.anyOf.length - 1 ? '' : '$1')
+    ).join('')
+  }
+
   return content
 }
 
@@ -464,7 +499,7 @@ const isSupportedTuple = schema => {
   }
 }
 
-function getSchemaType(schema, module, { destination, templateDir = 'types', link = false, code = false, asPath = false, event = false, result = false, expandEnums = true, baseUrl = '', namespace = false } = {}) {
+function getSchemaType(schema, module, { destination, templateDir = 'types', link = false, code = false, asPath = false, event = false, result = false, expandEnums = true, baseUrl = '', namespace = false, name = '' } = {}) {
   const wrap = (str, wrapper) => wrapper + str + wrapper
 
   schema = sanitize(schema)
@@ -479,8 +514,9 @@ function getSchemaType(schema, module, { destination, templateDir = 'types', lin
   if (schema['$ref']) {
     if (schema['$ref'][0] === '#') {
       const refSchema = getPath(schema['$ref'], module)
+      const refName = refSchema.title || schema['$ref'].split('/').pop()
       const includeNamespace = (module.info.title !== getXSchemaGroup(refSchema, module))
-      return getSchemaType(refSchema, module, {destination, templateDir, link, title, code, asPath, event, result, expandEnums, baseUrl, namespace:includeNamespace })// { link: link, code: code, destination })
+      return getSchemaType(refSchema, module, {destination, templateDir, link, title, code, asPath, event, result, expandEnums, baseUrl, namespace:includeNamespace, name:refName })// { link: link, code: code, destination })
     }
     else {
       // TODO: This never happens... but might be worth keeping in case we link to an opaque external schema at some point?
@@ -640,6 +676,7 @@ export default {
   setConvertTuples,
   setAllocatedPrimitiveProxies,
   getMethodSignatureParams,
+  getMethodSignatureResult,
   getSchemaShape,
   getSchemaType,
   getJsonType,