rclnodejs 1.5.1 → 1.6.0

package/rosidl_gen/templates/message-template.js

@@ -0,0 +1,1113 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+/**
+ * Generate JavaScript message class code using native template literals
+ * This replaces the doT template engine with pure JavaScript
+ */
+
+// Helper functions (same as in message.dot template)
+function getPrimitiveNameByType(type) {
+  if (type.type === 'bool') {
+    return 'Bool';
+  } else if (type.type === 'int8') {
+    return 'Int8';
+  } else if (type.type === 'uint8') {
+    return 'UInt8';
+  } else if (type.type === 'int16') {
+    return 'Int16';
+  } else if (type.type === 'uint16') {
+    return 'UInt16';
+  } else if (type.type === 'int32') {
+    return 'Int32';
+  } else if (type.type === 'uint32') {
+    return 'UInt32';
+  } else if (type.type === 'int64') {
+    return 'Int64';
+  } else if (type.type === 'uint64') {
+    return 'UInt64';
+  } else if (type.type === 'float64') {
+    return 'Float64';
+  } else if (type.type === 'float32') {
+    return 'Float32';
+  } else if (type.type === 'char') {
+    return 'Char';
+  } else if (type.type === 'byte') {
+    return 'Byte';
+  } else if (type.type === 'string' || type.type === 'wstring') {
+    return 'String';
+  } else {
+    return '';
+  }
+}
+
+function getTypedArrayName(type) {
+  const t = type.type.toLowerCase();
+  let typedArrayName = null;
+
+  switch (t) {
+    case 'byte':
+    case 'octet':
+    case 'uint8':
+      typedArrayName = 'Uint8Array';
+      break;
+    case 'char':
+    case 'int8':
+      typedArrayName = 'Int8Array';
+      break;
+    case 'int16':
+    case 'short':
+      typedArrayName = 'Int16Array';
+      break;
+    case 'uint16':
+    case 'unsigned short':
+      typedArrayName = 'Uint16Array';
+      break;
+    case 'int32':
+    case 'long':
+      typedArrayName = 'Int32Array';
+      break;
+    case 'uint32':
+    case 'unsigned long':
+      typedArrayName = 'Uint32Array';
+      break;
+    case 'float':
+    case 'float32':
+      typedArrayName = 'Float32Array';
+      break;
+    case 'double':
+    case 'float64':
+      typedArrayName = 'Float64Array';
+      break;
+    default:
+      typedArrayName = '';
+  }
+  return typedArrayName;
+}
+
+function getTypedArrayElementName(type) {
+  const t = type.type.toLowerCase();
+  if (t === 'int8') {
+    return 'int8';
+  } else if (t === 'uint8') {
+    return 'uint8';
+  } else if (t === 'int16') {
+    return 'int16';
+  } else if (t === 'uint16') {
+    return 'uint16';
+  } else if (t === 'int32') {
+    return 'int32';
+  } else if (t === 'uint32') {
+    return 'uint32';
+  } else if (t === 'float64') {
+    return 'double';
+  } else if (t === 'float32') {
+    return 'float';
+  } else if (t === 'char') {
+    return 'int8';
+  } else if (t === 'byte') {
+    return 'uint8';
+  } else {
+    return '';
+  }
+}
+
+const primitiveBaseType = [
+  'Bool',
+  'Int8',
+  'UInt8',
+  'Int16',
+  'UInt16',
+  'Int32',
+  'UInt32',
+  'Int64',
+  'UInt64',
+  'Float64',
+  'Float32',
+  'Char',
+  'Byte',
+  'String',
+];
+
+const typedArrayType = [
+  'int8',
+  'uint8',
+  'int16',
+  'uint16',
+  'int32',
+  'uint32',
+  'float64',
+  'float32',
+  'char',
+  'byte',
+];
+
+function isPrimitivePackage(baseType) {
+  return primitiveBaseType.indexOf(baseType.type) !== -1;
+}
+
+function isTypedArrayType(type) {
+  return typedArrayType.indexOf(type.type.toLowerCase()) !== -1;
+}
+
+function isBigInt(type) {
+  return ['int64', 'uint64'].indexOf(type.type.toLowerCase()) !== -1;
+}
+
+function getWrapperNameByType(type) {
+  if (type.isPrimitiveType) {
+    return getPrimitiveNameByType(type) + 'Wrapper';
+  } else {
+    return type.type + 'Wrapper';
+  }
+}
+
+function getModulePathByType(type, messageInfo) {
+  if (type.isPrimitiveType) {
+    return 'std_msgs__msg__' + getPrimitiveNameByType(type) + '.js';
+  }
+
+  if (
+    messageInfo &&
+    messageInfo.subFolder === 'action' &&
+    messageInfo.pkgName === type.pkgName &&
+    (type.type.endsWith('_Goal') ||
+      type.type.endsWith('_Result') ||
+      type.type.endsWith('_Feedback'))
+  ) {
+    return type.pkgName + '__action__' + type.type + '.js';
+  }
+
+  /* We should use '__msg__' to require "service_msgs/msg/ServiceEventInfo.msg" for service event message. */
+  if (
+    messageInfo &&
+    messageInfo.isServiceEvent &&
+    type.type !== 'ServiceEventInfo'
+  ) {
+    return type.pkgName + `__${messageInfo.subFolder}__` + type.type + '.js';
+  }
+  return type.pkgName + '__msg__' + type.type + '.js';
+}
+
+function getPackageNameByType(type) {
+  if (type.isPrimitiveType) {
+    return 'std_msgs';
+  } else {
+    return type.pkgName;
+  }
+}
+
+function extractMemberNames(fields) {
+  let memberNames = [];
+  fields.forEach((field) => {
+    memberNames.push(field.name);
+  });
+  return JSON.stringify(memberNames);
+}
+
+/**
+ * Main template generation function
+ * @param {Object} data - Template data
+ * @param {Object} data.spec - Message specification
+ * @param {Object} data.messageInfo - Message information (pkgName, subFolder, interfaceName, isServiceEvent)
+ * @param {string} data.json - JSON string of spec
+ * @param {boolean} data.isDebug - Debug flag
+ * @returns {string} Generated JavaScript code
+ */
+function generateMessage(data) {
+  const spec = data.spec;
+  const messageInfo = data.messageInfo;
+  const json = data.json;
+  const isDebug = data.isDebug;
+
+  // Initialize variables
+  const objectWrapper = spec.msgName + 'Wrapper';
+  const arrayWrapper = spec.msgName + 'ArrayWrapper';
+  const refObjectType = spec.msgName + 'RefStruct';
+  const refObjectArrayType = spec.msgName + 'RefStructArray';
+  const refArrayType = spec.msgName + 'RefArray';
+  const compactMsgDefJSON = JSON.stringify(JSON.parse(json));
+
+  // Add dummy field if empty (following rosidl_generator_c style)
+  if (spec.fields.length === 0) {
+    spec.isEmpty = true;
+    spec.fields.push({
+      type: {
+        isArray: false,
+        pkgName: null,
+        type: 'bool',
+        isDynamicArray: false,
+        stringUpperBound: null,
+        isUpperBound: false,
+        isPrimitiveType: true,
+        isFixedSizeArray: false,
+        arraySize: null,
+      },
+      name: '_dummy',
+    });
+  }
+
+  // Check if will use TypedArray
+  const willUseTypedArray = isTypedArrayType(spec.baseType);
+  const currentTypedArray = getTypedArrayName(spec.baseType);
+  const currentTypedArrayElementType = getTypedArrayElementName(spec.baseType);
+
+  // Track required modules
+  let existedModules = [];
+  function shouldRequire(baseType, fieldType) {
+    let requiredModule = `${getPackageNameByType(fieldType)}/${getModulePathByType(fieldType, messageInfo)}`;
+    let shouldReq =
+      !isPrimitivePackage(baseType) &&
+      (fieldType.isArray ||
+        !fieldType.isPrimitiveType ||
+        fieldType.type === 'string');
+
+    if (shouldReq && existedModules.indexOf(requiredModule) === -1) {
+      existedModules.push(requiredModule);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // Start generating the code
+  return `// This file is automatically generated by rclnodejs
+//
+// *** DO NOT EDIT directly
+//
+
+'use strict';
+
+${willUseTypedArray ? "const rclnodejs = require('../../lib/native_loader.js');" : ''}
+const ref = require('../../third_party/ref-napi');
+const StructType = require('@rclnodejs/ref-struct-di')(ref);
+const ArrayType = require('@rclnodejs/ref-array-di')(ref);
+const primitiveTypes = require('../../rosidl_gen/primitive_types.js');
+const deallocator = require('../../rosidl_gen/deallocator.js');
+const translator = require('../../rosidl_gen/message_translator.js');
+
+${spec.fields
+  .map((field) => {
+    if (shouldRequire(spec.baseType, field.type)) {
+      return `const ${getWrapperNameByType(field.type)} = require('../../generated/${getPackageNameByType(field.type)}/${getModulePathByType(field.type, messageInfo)}');`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+
+${
+  spec.msgName === 'String'
+    ? `const ${refObjectType} = primitiveTypes.string;`
+    : `const ${refObjectType} = StructType({
+${spec.fields
+  .map((field) => {
+    if (field.type.isPrimitiveType && !field.type.isArray) {
+      return `  ${field.name}: primitiveTypes.${field.type.type},`;
+    } else if (
+      field.type.isPrimitiveType &&
+      field.type.isArray &&
+      field.type.isFixedSizeArray
+    ) {
+      return `  ${field.name}: ArrayType(primitiveTypes.${field.type.type}, ${field.type.arraySize}),`;
+    } else if (
+      !field.type.isPrimitiveType &&
+      field.type.isArray &&
+      field.type.isFixedSizeArray
+    ) {
+      return `  ${field.name}: ArrayType(${getWrapperNameByType(field.type)}.refObjectType, ${field.type.arraySize}),`;
+    } else if (field.type.isArray) {
+      return `  ${field.name}: ${getWrapperNameByType(field.type)}.refObjectArrayType,`;
+    } else {
+      return `  ${field.name}: ${getWrapperNameByType(field.type)}.refObjectType,`;
+    }
+  })
+  .join('\n')}
+});`
+}
+
+const ${refArrayType} = ArrayType(${refObjectType});
+const ${refObjectArrayType} = StructType({
+${
+  willUseTypedArray
+    ? `  data: ref.refType(ref.types.${currentTypedArrayElementType}),`
+    : `  data: ${refArrayType},`
+}
+  size: ref.types.size_t,
+  capacity: ref.types.size_t
+});
+
+${generateWrapperClass()}
+
+${generateArrayWrapperClass()}
+
+${generateConstants()}
+
+module.exports = ${objectWrapper};
+
+${isDebug ? `/*\n * The following is the original spec object coming from parser:\n${json}\n*/` : ''}
+`;
+
+  // Helper function to generate the wrapper class
+  function generateWrapperClass() {
+    return `class ${objectWrapper} {
+  constructor(other) {
+    this._initialize();
+    this._setDefaults();
+
+${
+  spec.fields
+    .map(
+      (field) => `    if (typeof other === 'object' && other._refObject) {
+      this._refObject = new ${refObjectType}(other._refObject.toObject());
+${
+  field.type.isArray
+    ? `      this._wrapperFields.${field.name} = ${getWrapperNameByType(field.type)}.createArray();
+      this._wrapperFields.${field.name}.copy(other._wrapperFields.${field.name});
+${field.type.isPrimitiveType && !isTypedArrayType(field.type) ? `      this.${field.name} = other.${field.name};` : ''}`
+    : !field.type.isPrimitiveType ||
+        (field.type.type === 'string' && spec.msgName !== 'String')
+      ? `      this._wrapperFields.${field.name} =  new ${getWrapperNameByType(field.type)}(other._wrapperFields.${field.name});`
+      : ''
+}`
+    )
+    .filter((line) => line.trim())
+    .join('\n')[0] || ''
+}    if (typeof other === 'object' && other._refObject) {
+      this._refObject = new ${refObjectType}(other._refObject.toObject());
+${spec.fields
+  .map((field) => {
+    if (field.type.isArray) {
+      return `      this._wrapperFields.${field.name} = ${getWrapperNameByType(field.type)}.createArray();
+      this._wrapperFields.${field.name}.copy(other._wrapperFields.${field.name});
+${field.type.isPrimitiveType && !isTypedArrayType(field.type) ? `      this.${field.name} = other.${field.name};` : ''}`;
+    } else if (
+      !field.type.isPrimitiveType ||
+      (field.type.type === 'string' && spec.msgName !== 'String')
+    ) {
+      return `      this._wrapperFields.${field.name} =  new ${getWrapperNameByType(field.type)}(other._wrapperFields.${field.name});`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+    } else if (typeof other !== 'undefined') {
+      translator.constructFromPlanObject(this, other);
+    }
+    this.freeze(/*own=*/false);
+  }
+
+  _setDefaults() {
+${spec.fields
+  .map((field) => {
+    if (
+      field.type.isPrimitiveType &&
+      !field.type.isArray &&
+      field.default_value
+    ) {
+      if (field.type.type === 'string' || field.type.type === 'wstring') {
+        return `    this._refObject.${field.name} = "${field.default_value.replace(/"/g, '\\"')}";`;
+      } else {
+        return `    this._refObject.${field.name} = ${field.default_value};`;
+      }
+    } else if (
+      field.type.isPrimitiveType &&
+      !isTypedArrayType(field.type) &&
+      field.default_value
+    ) {
+      if (isBigInt(field.type)) {
+        return `    this._${field.name}Array = ${JSON.stringify(field.default_value)}.map(num => BigInt(num));`;
+      } else {
+        return `    this._${field.name}Array = ${JSON.stringify(field.default_value)};`;
+      }
+    } else if (
+      field.type.isPrimitiveType &&
+      isTypedArrayType(field.type) &&
+      field.default_value
+    ) {
+      return `    this._wrapperFields.${field.name}.fill(${getTypedArrayName(field.type)}.from(${JSON.stringify(field.default_value)}));`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+  }
+
+  _initialize() {
+    this._wrapperFields = {};
+    this._refObject = new ${refObjectType}();
+${spec.fields
+  .map((field) => {
+    if (field.type.isArray) {
+      let result = `    this._wrapperFields.${field.name} = ${getWrapperNameByType(field.type)}.createArray();`;
+      if (field.type.type === 'string' && field.type.isFixedSizeArray) {
+        result += `\n    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      primitiveTypes.initString(this._refObject.${field.name}[i]);
+    }`;
+      }
+      if (
+        field.type.isArray &&
+        field.type.isPrimitiveType &&
+        !isTypedArrayType(field.type)
+      ) {
+        result += `\n    this._${field.name}Array = [];`;
+      }
+      return result;
+    } else if (
+      !field.type.isPrimitiveType ||
+      (field.type.type === 'string' && spec.msgName !== 'String')
+    ) {
+      return `    this._wrapperFields.${field.name} = new ${getWrapperNameByType(field.type)}();`;
+    } else if (spec.msgName === 'String') {
+      return `    primitiveTypes.initString(this._refObject);`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+  }
+
+  static createFromRefObject(refObject) {
+    let self = new ${objectWrapper}();
+    self.copyRefObject(refObject);
+    return self;
+  }
+
+  static createArray() {
+    return new ${arrayWrapper}();
+  }
+
+  static get ArrayType() {
+    return ${arrayWrapper};
+  }
+
+  static get refObjectArrayType() {
+    return ${refObjectArrayType};
+  }
+
+  static get refObjectType() {
+    return ${refObjectType};
+  }
+
+  toRawROS() {
+    this.freeze(/*own=*/true);
+    return this._refObject.ref();
+  }
+
+  freeze(own) {
+${generateFreezeMethod()}
+  }
+
+  serialize() {
+    this.freeze(/*own=*/false);
+    return this._refObject.ref();
+  }
+
+  deserialize(refObject) {
+${spec.fields
+  .map((field) => {
+    if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      field.type.isFixedSizeArray &&
+      isTypedArrayType(field.type)
+    ) {
+      return `    this._wrapperFields.${field.name}.fill(refObject.${field.name}.toArray());`;
+    } else if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      field.type.isFixedSizeArray &&
+      !isTypedArrayType(field.type)
+    ) {
+      if (field.type.type === 'string') {
+        return `    for (let index = 0; index < ${field.type.arraySize}; index++) {
+      this._${field.name}Array[index] = refObject.${field.name}[index].data;
+    }`;
+      } else {
+        return `    this._${field.name}Array = refObject.${field.name}.toArray();`;
+      }
+    } else if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      !isTypedArrayType(field.type)
+    ) {
+      return `    refObject.${field.name}.data.length = refObject.${field.name}.size;
+    for (let index = 0; index < refObject.${field.name}.size; index++) {
+      this._${field.name}Array[index] = refObject.${field.name}.data[index].data;
+    }`;
+    } else if (
+      field.type.isArray &&
+      !field.type.isPrimitiveType &&
+      field.type.isFixedSizeArray
+    ) {
+      return `    this._refObject.${field.name} = refObject.${field.name};
+    this._wrapperFields.${field.name}.size = ${field.type.arraySize}
+    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      this._wrapperFields.${field.name}.data[i].copyRefObject(refObject.${field.name}[i]);
+    }`;
+    } else if (field.type.isArray || !field.type.isPrimitiveType) {
+      return `    this._wrapperFields.${field.name}.copyRefObject(refObject.${field.name});`;
+    } else if (field.type.type === 'string' && spec.msgName !== 'String') {
+      return `    this._wrapperFields.${field.name}.data = refObject.${field.name}.data;`;
+    } else if (field.type.isPrimitiveType) {
+      return `    this._refObject.${field.name} = refObject.${field.name};`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+  }
+
+  toPlainObject(enableTypedArray) {
+    return translator.toPlainObject(this, enableTypedArray);
+  }
+
+  static freeStruct(refObject) {
+${generateFreeStructMethod()}
+  }
+
+  static destroyRawROS(msg) {
+    ${objectWrapper}.freeStruct(msg.refObject);
+  }
+
+  static type() {
+    return {pkgName: '${messageInfo.pkgName}', subFolder: '${messageInfo.subFolder}', interfaceName: '${messageInfo.interfaceName}'};
+  }
+
+  static isPrimitive() {
+    return ${isPrimitivePackage(spec.baseType)};
+  }
+
+  static get isROSArray() {
+    return false;
+  }
+
+  get refObject() {
+    return this._refObject;
+  }
+
+${generateGettersSetters()}
+
+  copyRefObject(refObject) {
+    this._refObject = new ${refObjectType}(refObject.toObject());
+
+${spec.fields
+  .map((field) => {
+    if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      !isTypedArrayType(field.type)
+    ) {
+      return `    refObject.${field.name}.data.length = refObject.${field.name}.size;
+    for (let index = 0; index < refObject.${field.name}.size; index++) {
+      this._${field.name}Array[index] = refObject.${field.name}.data[index].data;
+    }`;
+    } else if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      field.type.isFixedSizeArray
+    ) {
+      return `    this._wrapperFields.${field.name}.fill(refObject.${field.name}.toArray());`;
+    } else if (
+      field.type.isArray &&
+      !field.type.isPrimitiveType &&
+      field.type.isFixedSizeArray
+    ) {
+      return `    this._refObject.${field.name} = refObject.${field.name};
+    this._wrapperFields.${field.name}.size = ${field.type.arraySize}
+    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      this._wrapperFields.${field.name}.data[i].copyRefObject(refObject.${field.name}[i]);
+    }`;
+    } else if (
+      !field.type.isPrimitiveType ||
+      field.type.isArray ||
+      (field.type.type === 'string' && spec.msgName !== 'String')
+    ) {
+      return `    this._wrapperFields.${field.name}.copyRefObject(this._refObject.${field.name});`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+  }
+
+  copy(other) {
+    this._refObject = new ${refObjectType}(other._refObject.toObject());
+
+${spec.fields
+  .map((field) => {
+    if (
+      field.type.isArray &&
+      field.type.isPrimitiveType &&
+      !isTypedArrayType(field.type)
+    ) {
+      return `    this._${field.name}Array = other._${field.name}Array.slice();`;
+    } else if (
+      !field.type.isPrimitiveType ||
+      field.type.isArray ||
+      (field.type.type === 'string' && spec.msgName !== 'String')
+    ) {
+      return `    this._wrapperFields.${field.name}.copy(other._wrapperFields.${field.name});`;
+    }
+    return '';
+  })
+  .filter((line) => line)
+  .join('\n')}
+  }
+
+  static get classType() {
+    return ${objectWrapper};
+  }
+
+  static get ROSMessageDef() {
+    return ${compactMsgDefJSON};
+  }
+
+  hasMember(name) {
+    let memberNames = ${extractMemberNames(spec.fields)};
+    return memberNames.indexOf(name) !== -1;
+  }
+}`;
+  }
+
+  // Helper function to generate freeze method
+  function generateFreezeMethod() {
+    return spec.fields
+      .map((field) => {
+        if (
+          field.type.isArray &&
+          field.type.isPrimitiveType &&
+          !isTypedArrayType(field.type) &&
+          field.type.isFixedSizeArray
+        ) {
+          if (field.type.type === 'string') {
+            return `    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      if (own) {
+        primitiveTypes.initString(this._refObject.${field.name}[i].ref(), own);
+      } else {
+        if (this._${field.name}Array.length === ${field.type.arraySize}) {
+          const value = this._${field.name}Array[i];
+          this._refObject.${field.name}[i].data = value;
+          this._refObject.${field.name}[i].size = Buffer.byteLength(value);
+          this._refObject.${field.name}[i].capacity = Buffer.byteLength(value) + 1;
+        }
+      }
+    }`;
+          } else if (isBigInt(field.type)) {
+            return `    this._refObject.${field.name} = this._${field.name}Array.map(num => num.toString());`;
+          } else {
+            return `    this._refObject.${field.name} = this._${field.name}Array;`;
+          }
+        } else if (
+          field.type.isArray &&
+          field.type.isPrimitiveType &&
+          isTypedArrayType(field.type) &&
+          field.type.isFixedSizeArray
+        ) {
+          return `    this._refObject.${field.name} = Array.from(this._wrapperFields.${field.name}.data);`;
+        } else if (
+          field.type.isArray &&
+          field.type.isPrimitiveType &&
+          !isTypedArrayType(field.type)
+        ) {
+          return `    if (own) {
+      this._wrapperFields.${field.name}.fill([]);
+    } else {
+      this._wrapperFields.${field.name}.fill(this._${field.name}Array);
+    }
+    this._wrapperFields.${field.name}.freeze(own);
+    this._refObject.${field.name} = this._wrapperFields.${field.name}.refObject;`;
+        } else if (
+          field.type.isArray &&
+          field.type.isPrimitiveType &&
+          isTypedArrayType(field.type)
+        ) {
+          return `    if (own) {
+      this._wrapperFields.${field.name}.fill(${getTypedArrayName(field.type)}.from([]));
+    }
+    this._wrapperFields.${field.name}.freeze(own);
+    this._refObject.${field.name} = this._wrapperFields.${field.name}.refObject;`;
+        } else if (
+          field.type.isArray &&
+          !field.type.isPrimitiveType &&
+          field.type.isFixedSizeArray
+        ) {
+          return `    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      if (this._wrapperFields.${field.name}.data[i]) {
+        this._wrapperFields.${field.name}.data[i].freeze(own);
+        this._refObject.${field.name}[i] = this._wrapperFields.${field.name}.data[i].refObject;
+      }
+    }`;
+        } else if (field.type.isArray || !field.type.isPrimitiveType) {
+          let result = '';
+          if (field.type.isArray) {
+            result += `    if (own) {
+      this._wrapperFields.${field.name}.fill([]);
+    }
+`;
+          }
+          result += `    this._wrapperFields.${field.name}.freeze(own);
+    this._refObject.${field.name} = this._wrapperFields.${field.name}.refObject;`;
+          return result;
+        } else if (field.type.type === 'string' && spec.msgName !== 'String') {
+          return `    if (own) {
+      this._wrapperFields.${field.name}.freeze(own);
+    }
+    this._refObject.${field.name} = this._wrapperFields.${field.name}.refObject;`;
+        } else if (spec.msgName === 'String') {
+          return `    if (own) {
+      primitiveTypes.initString(this._refObject.ref(), own);
+    }`;
+        }
+        return '';
+      })
+      .filter((line) => line)
+      .join('\n');
+  }
+
+  // Helper function to generate freeStruct method
+  function generateFreeStructMethod() {
+    return spec.fields
+      .map((field) => {
+        if (field.type.isArray && !field.type.isFixedSizeArray) {
+          return `    if (refObject.${field.name}.size != 0) {
+      ${getWrapperNameByType(field.type)}.ArrayType.freeArray(refObject.${field.name});
+      if (!${getWrapperNameByType(field.type)}.ArrayType.useTypedArray) {
+        deallocator.freeStructMember(refObject.${field.name}, ${getWrapperNameByType(field.type)}.refObjectArrayType, 'data');
+      }
+    }`;
+        } else if (
+          field.type.isArray &&
+          !field.type.isPrimitiveType &&
+          field.type.isFixedSizeArray
+        ) {
+          return `    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      ${getWrapperNameByType(field.type)}.freeStruct(refObject.${field.name}[i]);
+    }`;
+        } else if (
+          field.type.isArray &&
+          field.type.type === 'string' &&
+          field.type.isFixedSizeArray
+        ) {
+          return `    for (let i = 0; i < ${field.type.arraySize}; i++) {
+      ${getWrapperNameByType(field.type)}.freeStruct(refObject.${field.name}[i]);
+    }`;
+        } else if (
+          !field.type.isPrimitiveType ||
+          (field.type.type === 'string' && spec.msgName !== 'String')
+        ) {
+          return `    ${getWrapperNameByType(field.type)}.freeStruct(refObject.${field.name});`;
+        } else if (spec.msgName === 'String') {
+          return `    deallocator.freeStructMember(refObject, ${getWrapperNameByType(field.type)}.refObjectType, '${field.name}');`;
+        }
+        return '';
+      })
+      .filter((line) => line)
+      .join('\n');
+  }
+
+  // Helper function to generate getters and setters
+  function generateGettersSetters() {
+    return spec.fields
+      .map(
+        (field) => `  get ${field.name}() {
+${generateGetter(field)}
+  }
+
+  set ${field.name}(value) {
+${generateSetter(field)}
+  }`
+      )
+      .join('\n\n');
+  }
+
+  function generateGetter(field) {
+    if (field.type.isArray && field.type.type === 'Constants') {
+      return `    return [];`;
+    } else if (field.type.isArray && isTypedArrayType(field.type)) {
+      return `    return this._wrapperFields['${field.name}'].data;`;
+    } else if (field.type.isArray && field.type.isPrimitiveType) {
+      return `    return this._${field.name}Array;`;
+    } else if (field.type.isArray && !field.type.isPrimitiveType) {
+      return `    return this._wrapperFields.${field.name};`;
+    } else if (!field.type.isPrimitiveType && !field.type.isArray) {
+      return `    return this._wrapperFields.${field.name};`;
+    } else if (
+      !field.type.isArray &&
+      field.type.type === 'string' &&
+      spec.msgName !== 'String'
+    ) {
+      return `    return this._wrapperFields.${field.name}.data;`;
+    } else if (isBigInt(field.type)) {
+      return `    return BigInt(this._refObject.${field.name});`;
+    } else {
+      return `    return this._refObject.${field.name};`;
+    }
+  }
+
+  function generateSetter(field) {
+    let result = '';
+
+    if (field.type.isArray && field.type.isFixedSizeArray) {
+      result += `    if (value.length !== ${field.type.arraySize}) {
+      throw new RangeError('The length of the array must be ${field.type.arraySize}.');
+    }
+
+`;
+    }
+    if (field.type.isArray && field.type.isUpperBound) {
+      result += `    if (value.length > ${field.type.arraySize}) {
+      throw new RangeError('The length of array ${field.name} must be <= ${field.type.arraySize}.');
+    }
+`;
+    }
+
+    if (field.type.isArray && isTypedArrayType(field.type)) {
+      result += `    this._wrapperFields['${field.name}'].fill(value);`;
+    } else if (field.type.isArray && field.type.isPrimitiveType) {
+      result += `    this._${field.name}Array = value;`;
+    } else if (field.type.isArray && !field.type.isPrimitiveType) {
+      result += `    this._wrapperFields.${field.name}.fill(value);`;
+    } else if (!field.type.isPrimitiveType && !field.type.isArray) {
+      result += `    if (value instanceof ${getWrapperNameByType(field.type)}) {
+      this._wrapperFields.${field.name}.copy(value);
+    } else {
+      this._wrapperFields.${field.name}.copy(new ${getWrapperNameByType(field.type)}(value));
+    }`;
+    } else if (
+      !field.type.isArray &&
+      field.type.type === 'string' &&
+      spec.msgName !== 'String'
+    ) {
+      result += `    this._wrapperFields.${field.name}.data = value;`;
+    } else if (isBigInt(field.type)) {
+      result += `    if (typeof value !== "bigint") {
+      throw new TypeError('${field.name} must be type of bigint');
+    }
+    this._refObject.${field.name} = value.toString();`;
+    } else {
+      if (spec.msgName === 'String') {
+        result += `    this._refObject.size = Buffer.byteLength(value);
+    this._refObject.capacity = Buffer.byteLength(value) + 1;
+`;
+      }
+      result += `    this._refObject.${field.name} = value;`;
+    }
+
+    return result;
+  }
+
+  // Helper function to generate array wrapper class
+  function generateArrayWrapperClass() {
+    return `class ${arrayWrapper} {
+  constructor(size = 0) {
+    this._resize(size);
+  }
+
+  toRawROS() {
+    return this._refObject.ref();
+  }
+
+  fill(values) {
+${
+  willUseTypedArray
+    ? `    if (Array.isArray(values)) {
+      this._wrappers = new ${currentTypedArray}(values);
+    } else {
+      this._wrappers = values;
+    }`
+    : isPrimitivePackage(spec.baseType)
+      ? `    const length = values.length;
+    this._resize(length);
+    for (let i = 0; i < length; ++i) {
+      let wrapper = new ${objectWrapper}();
+      wrapper.data = values[i];
+      this._wrappers[i] = wrapper;
+    }`
+      : `    const length = values.length;
+    this._resize(length);
+    values.forEach((value, index) => {
+      if (value instanceof ${objectWrapper}) {
+        this._wrappers[index].copy(value);
+      } else {
+        this._wrappers[index] = new ${objectWrapper}(value);
+      }
+    });`
+}
+  }
+
+  freeze(own) {
+${
+  !willUseTypedArray
+    ? `    this._wrappers.forEach((wrapper, index) => {
+      wrapper.freeze(own);
+      this._refArray[index] = wrapper.refObject;
+    });
+`
+    : ''
+}
+    this._refObject.size = this._wrappers.length;
+    this._refObject.capacity = this._wrappers.length;
+
+    if (this._refObject.capacity === 0) {
+      this._refObject.data = null
+    } else {
+${
+  willUseTypedArray
+    ? `      const buffer = Buffer.from(new Uint8Array(this._wrappers.buffer));
+      this._refObject.data = buffer;`
+    : `      this._refObject.data = this._refArray.buffer;`
+}
+    }
+  }
+
+  get refObject() {
+    return this._refObject;
+  }
+
+  get data() {
+    return this._wrappers;
+  }
+
+  get size() {
+    return this._wrappers.length;
+  }
+
+  set size(value) {
+    if (typeof value != 'number') {
+      throw new TypeError('Invalid argument: should provide a number to ${arrayWrapper}.size setter');
+    }
+    return this._resize(value);
+  }
+
+  get capacity() {
+    return this._wrappers.length;
+  }
+
+  set capacity(value) {
+    if (typeof value != 'number') {
+      throw new TypeError('Invalid argument: should provide a number to ${arrayWrapper}.capacity setter');
+    }
+    return this._resize(value);
+  }
+
+  _resize(size) {
+    if (size < 0) {
+      throw new RangeError('Invalid argument: should provide a positive number');
+    }
+${
+  willUseTypedArray
+    ? `    this._refArray = undefined;`
+    : `    this._refArray = new ${refArrayType}(size);`
+}
+
+    this._refObject = new ${refObjectArrayType}();
+    this._refObject.size = size;
+    this._refObject.capacity = size;
+
+${
+  willUseTypedArray
+    ? `    this._wrappers = new ${currentTypedArray}(size);`
+    : `    this._wrappers = new Array();
+    for (let i = 0; i < size; i++) {
+      this._wrappers.push(new ${objectWrapper}());
+    }`
+}
+  }
+
+  copyRefObject(refObject) {
+    this._refObject = refObject;
+
+${
+  willUseTypedArray
+    ? `    const byteLen = refObject.size * ref.types.${currentTypedArrayElementType}.size;
+    const arrayBuffer = refObject.data.length !== 0 ?
+        rclnodejs.createArrayBufferFromAddress(refObject.data.hexAddress(), byteLen) :
+        Buffer.alloc(0);
+    this._wrappers = new ${currentTypedArray}(arrayBuffer);`
+    : `    let refObjectArray = this._refObject.data;
+    refObjectArray.length = this._refObject.size;
+    this._resize(this._refObject.size);
+    for (let index = 0; index < this._refObject.size; index++) {
+      this._wrappers[index].copyRefObject(refObjectArray[index]);
+    }`
+}
+  }
+
+  copy(other) {
+    if (! (other instanceof ${arrayWrapper})) {
+      throw new TypeError('Invalid argument: should provide "${arrayWrapper}".');
+    }
+
+    this._resize(other.size);
+${
+  willUseTypedArray
+    ? `    this._wrappers = other._wrappers.slice();`
+    : `    other._wrappers.forEach((wrapper, index) => {
+      this._wrappers[index].copy(wrapper);
+    });`
+}
+  }
+
+  static freeArray(refObject) {
+${
+  !willUseTypedArray
+    ? `    let refObjectArray = refObject.data;
+    refObjectArray.length = refObject.size;
+    for (let index = 0; index < refObject.size; index++) {
+      ${objectWrapper}.freeStruct(refObjectArray[index]);
+    }`
+    : ''
+}
+  }
+
+  static get elementType() {
+    return ${objectWrapper};
+  }
+
+  static get isROSArray() {
+    return true;
+  }
+
+  static get useTypedArray() {
+    return ${willUseTypedArray};
+  }
+
+  get classType() {
+    return ${arrayWrapper};
+  }
+
+  toPlainObject(enableTypedArray) {
+    return translator.toPlainObject(this, enableTypedArray);
+  }
+}`;
+  }
+
+  // Helper function to generate constants
+  function generateConstants() {
+    if (spec.constants && spec.constants.length > 0) {
+      return spec.constants
+        .map((c) => {
+          const value = c.type === 'string' ? `"${c.value}"` : c.value;
+          return `Object.defineProperty(${objectWrapper}, "${c.name}", {value: ${value}, writable: false, enumerable: true, configurable: true});`;
+        })
+        .join('\n');
+    }
+    return '';
+  }
+}
+
+module.exports = generateMessage;