node-opcua-generator 2.55.0 → 2.60.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,893 +1,899 @@
1
- /* istanbul ignore file */
2
- /**
3
- * @module node-opcua-generator
4
- */
5
-
6
- // tslint:disable:max-line-length
7
- // tslint:disable:max-depth
8
-
9
- import * as fs from "fs";
10
- import { assert } from "node-opcua-assert";
11
- import {
12
- check_schema_correctness,
13
- extract_all_fields,
14
- FieldCategory,
15
- FieldType,
16
- getStructuredTypeSchema,
17
- StructuredTypeSchema
18
- } from "node-opcua-factory";
19
- import * as os from "os";
20
- import * as path from "path";
21
-
22
- import { DataTypeIds, ObjectIds } from "node-opcua-constants";
23
- import { make_debugLog } from "node-opcua-debug";
24
- import { coerceNodeId, NodeId } from "node-opcua-nodeid";
25
- import { capitalizeFirstLetter } from "node-opcua-utils";
26
-
27
- import { makeWrite, WriteFunc } from "./utils/write_func";
28
- import { LineFile1, normalize_require_file } from "./utils/index";
29
-
30
- const produceComment = false;
31
- const debugLog = make_debugLog(__filename);
32
-
33
- const generatedObjectSchema: any = {};
34
-
35
- function quotify(str: string): string {
36
- return '"' + str + '"';
37
- }
38
-
39
- function makeFieldType(field: FieldType) {
40
- return "{" + field.fieldType + (field.isArray ? "[" : "") + (field.isArray ? "]" : "") + "}";
41
- }
42
-
43
- function convertToJavascriptCode(obj: any): string {
44
- const lines: string[] = [];
45
-
46
- if (typeof obj === "object" && !(obj instanceof Array)) {
47
- lines.push("{");
48
- for (const prop of Object.keys(obj)) {
49
- lines.push(prop, ": ", convertToJavascriptCode(obj[prop]), ",");
50
- }
51
- lines.push("}");
52
- } else if (obj instanceof Array) {
53
- lines.push("[");
54
- for (const prop of obj) {
55
- lines.push(convertToJavascriptCode(prop), ",");
56
- }
57
- lines.push("]");
58
-
59
- // tslint:disable:no-empty
60
- } else if (typeof obj === "function") {
61
- } else {
62
- lines.push(JSON.stringify(obj));
63
- }
64
- return lines.join("");
65
- }
66
-
67
- function get_class_folder(schemaName: string, optionalFolder?: string): string {
68
- let folder;
69
- if (optionalFolder) {
70
- if (!fs.existsSync(optionalFolder)) {
71
- fs.mkdirSync(optionalFolder);
72
- if (!fs.existsSync(optionalFolder)) {
73
- throw new Error("get_class_TScript_filename: Cannot find folder " + optionalFolder);
74
- }
75
- }
76
- folder = optionalFolder;
77
- } else {
78
- folder = exports.folder_for_generated_file;
79
- throw new Error("get_class_javascript_filename : DEPRECATED ");
80
- }
81
- return folder;
82
- }
83
-
84
- export function get_class_TScript_filename(schemaName: string, optionalFolder?: string): string {
85
- const folder = get_class_folder(schemaName, optionalFolder);
86
- return path.join(folder, "_" + schemaName + ".ts");
87
- }
88
-
89
- export function get_class_JScript_filename(schemaName: string, optionalFolder?: string): string {
90
- const folder = get_class_folder(schemaName, optionalFolder);
91
- return path.join(folder, "_" + schemaName + ".js");
92
- }
93
-
94
- function get_class_TScript_filename_local(schemaName: string): string {
95
- let schema = getStructuredTypeSchema(schemaName);
96
- if (!schema) {
97
- schema = generatedObjectSchema[schemaName];
98
- if (!schema) {
99
- throw new Error("cannot find script file for " + schemaName);
100
- }
101
- return "./_" + schemaName;
102
- }
103
- let generateTypeScriptSource = "/* fix me schema.prototype.schema.generate_ts_source*/";
104
- if (!generateTypeScriptSource) {
105
- const folder = "."; // exports.folder_for_generated_file;
106
- generateTypeScriptSource = path.join(folder, "_" + schemaName + ".ts");
107
- }
108
- return generateTypeScriptSource;
109
- }
110
-
111
- function write_enumeration_setter(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string): void {
112
- const capMember = capitalizeFirstLetter(member);
113
- write(` public set${capMember}(value: any): ${field.fieldType} {`);
114
- write(` const coercedValue = _enumeration${field.fieldType}.get(value);`);
115
- write(` /* istanbul ignore next */`);
116
- write(` if (coercedValue === undefined || coercedValue === null) {`);
117
- write(` throw new Error("value cannot be coerced to ${field.fieldType} :" + value);`);
118
- write(` }`);
119
- write(` this.${member} = coercedValue.value as ${field.fieldType};`);
120
- write(` return this.${member};`);
121
- write(` }`);
122
- }
123
-
124
- function write_enumeration_fast_init(
125
- write: WriteFunc,
126
- schema: StructuredTypeSchema,
127
- field: FieldType,
128
- member: string,
129
- i: number
130
- ): void {
131
- write(` this.${member} = 0 as ${field.fieldType};`);
132
- }
133
-
134
- function write_enumeration(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
135
- assert(!field.isArray); // would not work in this case
136
- const capMember = capitalizeFirstLetter(member);
137
- write(` this.${field.name} = this.set${capMember}(initialize_field(schema.fields[${i}], options?.${field.name}));`);
138
- }
139
-
140
- function write_complex_fast_init(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string) {
141
- if (field.isArray) {
142
- write(` this.${member} = null; /* null array */`);
143
- } else {
144
- write(` this.${member} = new ${field.fieldType}(null);`);
145
- }
146
- }
147
-
148
- function write_complex(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string /*, i*/) {
149
- if (field.isArray) {
150
- if (field.hasOwnProperty("defaultValue")) {
151
- // todo: fix me => should call field defaultValue in the live version
152
- write(` this.${member} = []; // should default`);
153
- } else {
154
- write(` this.${member} = [];`);
155
- }
156
- write(` if (options.${member}) {`);
157
- write(` assert(Array.isArray(options.${member}));`);
158
- write(` this.${member} = options.${member}.map((e: any) => new ${field.fieldType}(e));`);
159
- // write(` self.${member} = options.${member}.map(function(e){ return construct${field.fieldType}(e); } );`);
160
- write(" }");
161
- } else {
162
- if (field.defaultValue === null || field.fieldType === schema.name) {
163
- write(` this.${member} = (options.${member}) ? new ${field.fieldType}( options.${member}) : null;`);
164
- // xx write(` self.${member} = (options.${member}) ? construct${field.fieldType}( options.${member}) : null;`);
165
- } else {
166
- write(` this.${member} = new ${field.fieldType}(options.${member});`);
167
- // xx write(` self.${member} = construct${field.fieldType}(options.${member});`);
168
- }
169
- }
170
- }
171
-
172
- function write_basic(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
173
- assert(field.category === FieldCategory.basic);
174
-
175
- if (field.isArray) {
176
- // write(`this.${member} = [];`);
177
- // write(`if (options.${member}) {`);
178
- // write(` assert(Array.isArray(options.${member}));`);
179
- // write(` this.${member} = options.browsePath.map(e => field.coerce(e) );`);
180
- // write(`}`);
181
- write(` this.${member} = initialize_field_array(schema.fields[${i}], options?.${field.name});`);
182
- } else {
183
- write(` this.${member} = initialize_field(schema.fields[${i}], options?.${field.name});`);
184
- }
185
- }
186
- function write_basic_fast_init(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
187
- if (field.isArray) {
188
- // write(`this.${member} = [];`);
189
- // write(`if (options.${member}) {`);
190
- // write(` assert(Array.isArray(options.${member}));`);
191
- // write(` this.${member} = options.browsePath.map(e => field.coerce(e) );`);
192
- // write(`}`);
193
- write(` this.${member} = []`);
194
- } else {
195
- switch (field.schema.name) {
196
- case "Variant":
197
- write(` this.${member} = new Variant(null);`);
198
- break;
199
- case "UABoolean":
200
- case "Boolean":
201
- write(` this.${member} = false;`);
202
- break;
203
- case "UAString":
204
- write(` this.${member} = null;`);
205
- break;
206
- case "ExpandedNodeId":
207
- write(` this.${member} = new ExpandedNodeId(null);`);
208
- break;
209
- case "NodeId":
210
- write(` this.${member} = new NodeId(null);`);
211
- break;
212
- case "QualifiedName":
213
- write(` this.${member} = new QualifiedName(null);`);
214
- break;
215
- case "DateTime":
216
- write(` this.${member} = new Date();`);
217
- break;
218
- case "ByteString":
219
- write(` this.${member} = Buffer.alloc(0);`);
220
- break;
221
- case "StatusCode":
222
- write(` this.${member} = StatusCodes.Good;`);
223
- break;
224
- case "DiagnosticInfo":
225
- case "ExtensionObject":
226
- write(` this.${member} = null;`);
227
- break;
228
- case "NumericRange":
229
- write(` this.${member} = new NumericRange(null);`);
230
- break;
231
- case "LocalizedText":
232
- write(` this.${member} = new LocalizedText(null);`);
233
- break;
234
- case "Guid":
235
- write(` this.${member} = "";`);
236
- break;
237
- case "UInt64":
238
- write(` this.${member} = [];`);
239
- break;
240
- case "Int64":
241
- write(` this.${member} = [];`);
242
- break;
243
- case "DataValue":
244
- write(` this.${member} = new DataValue(null);`);
245
- break;
246
-
247
- default:
248
- write(` this.${member} = 0;`);
249
- }
250
- }
251
- }
252
- function write_fast_init_member(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, i: number) {
253
- const member = field.name;
254
- switch (field.category) {
255
- case FieldCategory.enumeration:
256
- write_enumeration_fast_init(write, schema, field, member, i);
257
- break;
258
- case FieldCategory.basic:
259
- write_basic_fast_init(write, schema, field, member, i);
260
- break;
261
- case FieldCategory.complex:
262
- write_complex_fast_init(write, schema, field, member);
263
- break;
264
- }
265
- }
266
-
267
- function write_constructor(write: WriteFunc, schema: StructuredTypeSchema): void {
268
- const baseClass = schema.baseType;
269
- const className = schema.name;
270
- write("");
271
- const n = schema.fields.length;
272
-
273
- if (produceComment) {
274
- write(" /**");
275
- if (schema.documentation && schema.documentation.length > 0) {
276
- write(" * " + schema.documentation);
277
- }
278
- let def = "";
279
- for (let i = 0; i < n; i++) {
280
- const field = schema.fields[i];
281
- const fieldType = field.fieldType;
282
- const documentation = field.documentation ? field.documentation : "";
283
- def = "";
284
- if (field.defaultValue !== undefined) {
285
- if (typeof field.defaultValue === "function") {
286
- def = " = " + field.defaultValue();
287
- } else {
288
- def = " = " + field.defaultValue;
289
- }
290
- }
291
- const ft = makeFieldType(field);
292
- // xx write(" * @param [options." + field.name + def + "] " + ft + " " + documentation);
293
- }
294
-
295
- write(" */");
296
- }
297
-
298
- write(` constructor(options?: ${className}Options | null) {`);
299
- write("");
300
- if (baseClass) {
301
- if (baseClass === "BaseUAObject") {
302
- write(" super();");
303
- } else {
304
- write(" super(options);");
305
- }
306
- write("");
307
- }
308
-
309
- // detect de-serialization constructor
310
- // -----------------------------------------------------------------------------------------------------------------
311
- // Special case when options === null => fast constructor for de-serialization
312
- // -----------------------------------------------------------------------------------------------------------------
313
- write(` if (options === null) {`);
314
- for (let i = 0; i < n; i++) {
315
- const field = schema.fields[i];
316
- write_fast_init_member(write, schema, field, i);
317
- }
318
- write(" return;");
319
- write(" }");
320
-
321
- write(` const schema = ${className}.schema;`);
322
- if (typeof schema.constructHook === "function") {
323
- write(` options = schema.constructHook(options) as ${className}Options;`);
324
- } else {
325
- write(` options = (schema.constructHook ? schema.constructHook(options) as ${className}Options: options ) || {};`);
326
- }
327
- // write(" if (options === undefined) { options = {}; }");
328
-
329
- write(" /* istanbul ignore next */");
330
- write(" if (parameters.debugSchemaHelper) {");
331
- write(" check_options_correctness_against_schema(this, schema, options);");
332
- write(" }");
333
-
334
- // -----------------------------------------------------------------------------------------------------------------
335
-
336
- for (let i = 0; i < n; i++) {
337
- const field = schema.fields[i];
338
- const member = field.name;
339
-
340
- if (produceComment) {
341
- write("");
342
- write(" /**");
343
- const documentation = field.documentation ? field.documentation : "";
344
- if (documentation && documentation.length > 0) {
345
- write(" * ", documentation);
346
- }
347
-
348
- if (produceComment) {
349
- write(" * @property ", field.name);
350
- // write(" * @type {", (field.isArray ? "Array[" : "") + field.fieldType + (field.isArray ? " ]" : "")+"}");
351
- write(" * @type " + makeFieldType(field));
352
- }
353
- if (field.defaultValue !== undefined && typeof field.defaultValue !== "function") {
354
- write(" * @default ", field.defaultValue);
355
- }
356
-
357
- write(" */");
358
- }
359
-
360
- switch (field.category) {
361
- case FieldCategory.enumeration:
362
- write_enumeration(write, schema, field, member, i);
363
- break;
364
- case FieldCategory.complex:
365
- write_complex(write, schema, field, member);
366
- break;
367
- default:
368
- write_basic(write, schema, field, member, i);
369
- break;
370
- }
371
- }
372
- write(" }");
373
- }
374
-
375
- function write_possible_fields(write: WriteFunc, className: string, possibleFields: string[]): void {
376
- write(" public static possibleFields: string[] = [");
377
- write(" " + possibleFields.map(quotify).join("," + os.EOL + " "));
378
- write(" ];");
379
- }
380
-
381
- function write_isValid(write: WriteFunc, schema: StructuredTypeSchema): void {
382
- // ---------------------------------------
383
- if (typeof schema.isValid === "function") {
384
- if (produceComment) {
385
- write(" /**");
386
- write(" *");
387
- write(" * verify that all object attributes values are valid according to schema");
388
- write(" * @method isValid");
389
- write(" * @return {Boolean}");
390
- write(" */");
391
- }
392
- write(" isValid(): boolean { return schema.isValid(this); };");
393
- }
394
- }
395
-
396
- function write_encode(write: WriteFunc, schema: StructuredTypeSchema): void {
397
- if (typeof schema.encode === "function") {
398
- write(" public encode(stream: OutputBinaryStream): void {");
399
- write(" " + "schema" + ".encode(this, stream);");
400
- write(" }");
401
- } else {
402
- if (produceComment) {
403
- write(" /**");
404
- write(" * encode the object into a binary stream");
405
- write(" * @method encode");
406
- write(" *");
407
- write(" * @param stream {BinaryStream}");
408
- write(" */");
409
- }
410
- write(" public encode(stream: OutputBinaryStream): void {");
411
- write(" /* NEEDED */ super.encode(stream);");
412
-
413
- const n = schema.fields.length;
414
- for (let i = 0; i < n; i++) {
415
- const field = schema.fields[i];
416
- const member = field.name;
417
-
418
- switch (field.category) {
419
- case FieldCategory.enumeration:
420
- case FieldCategory.basic:
421
- if (field.isArray) {
422
- write(` encodeArray(this.${member}, stream, encode${field.fieldType});`);
423
- } else {
424
- write(` encode${field.fieldType}(this.${member}, stream);`);
425
- }
426
- break;
427
- case FieldCategory.complex:
428
- if (field.isArray) {
429
- write(` encodeArray(this.${member}, stream, (obj, stream1) => { obj.encode(stream1); });`);
430
- } else {
431
- write(` this.${member}.encode(stream);`);
432
- }
433
- break;
434
- }
435
- }
436
- write(" }");
437
- }
438
- }
439
-
440
- function write_decode(write: WriteFunc, schema: StructuredTypeSchema): void {
441
- // --------------------------------------------------------------
442
- // implement decode
443
- function write_field(field: FieldType, member: string, i: number) {
444
- if (field.category === FieldCategory.enumeration || field.category === FieldCategory.basic) {
445
- if (field.isArray) {
446
- write(" this." + member + " = decodeArray(stream, decode" + field.fieldType + ");");
447
- } else {
448
- if (false) {
449
- write(" this." + member + ".decode(stream);");
450
- } else {
451
- if (typeof field.decode === "function") {
452
- write(" this." + member + " = " + "schema" + ".fields[" + i + "].decode(stream);");
453
- } else {
454
- write(" this." + member + " = decode" + field.fieldType + "(stream, this." + member + ");");
455
- }
456
- }
457
- }
458
- } else {
459
- assert(field.category === FieldCategory.complex);
460
- if (field.isArray) {
461
- write(" this." + member + " = decodeArray(stream, (stream1: BinaryStream) => {");
462
- write(" const obj = new " + field.fieldType + "(null);");
463
- write(" obj.decode(stream1);");
464
- write(" return obj;");
465
- write(" });");
466
- } else {
467
- write(" this." + member + ".decode(stream);");
468
- // xx write(" this." + member + ".decode(stream);");
469
- }
470
- }
471
- }
472
-
473
- // ---------------------------------------------------------------
474
- if (typeof schema.decode === "function") {
475
- if (produceComment) {
476
- write(" /**");
477
- write(" * decode the object from a binary stream");
478
- write(" * @method decode");
479
- write(" *");
480
- write(" * @param stream {BinaryStream}");
481
- write(" */");
482
- }
483
- write(" public decode(stream: BinaryStream): void {");
484
- write(" " + "schema" + ".decode(this,stream);");
485
- write(" }");
486
-
487
- if (typeof schema.decodeDebug !== "function") {
488
- throw new Error("schema decode requires also to provide a decodeDebug " + schema.name);
489
- }
490
- write(" public decodeDebug(stream: BinaryStream, options: any): void {");
491
- write(" " + "schema" + ".decodeDebug(this,stream,options);");
492
- write(" }");
493
- } else {
494
- if (produceComment) {
495
- write(" /**");
496
- write(" * decode the object from a binary stream");
497
- write(" * @method decode");
498
- write(" *");
499
- write(" * @param stream {BinaryStream}");
500
- write(" */");
501
- }
502
- write(" public decode(stream: BinaryStream): void {");
503
- write(" // call base class implementation first");
504
- write(" /* NEEDED !!! */ super.decode(stream);");
505
-
506
- const n = schema.fields.length;
507
- for (let i = 0; i < n; i++) {
508
- const field = schema.fields[i];
509
- const fieldType = field.fieldType;
510
- const member = field.name;
511
- write_field(field, member, i);
512
- }
513
- write(" }");
514
- }
515
- }
516
-
517
- function hasEnumeration(schema: StructuredTypeSchema): boolean {
518
- for (const field of schema.fields) {
519
- if (field.category === FieldCategory.enumeration) {
520
- return true;
521
- }
522
- }
523
- return false;
524
- }
525
-
526
- function hasComplex(schema: StructuredTypeSchema): boolean {
527
- for (const field of schema.fields) {
528
- if (field.category === FieldCategory.complex) {
529
- return true;
530
- }
531
- }
532
- return false;
533
- }
534
-
535
- function write_class_constructor_options(write: WriteFunc, schema: StructuredTypeSchema): void {
536
- const n = schema.fields.length;
537
- for (let i = 0; i < n; i++) {
538
- const field = schema.fields[i];
539
- const member = field.name;
540
-
541
- const arrayOpt = field.isArray ? "[] | null" : "";
542
-
543
- switch (field.category) {
544
- case FieldCategory.enumeration: {
545
- write(` ${member}?: ${field.fieldType}${arrayOpt};`);
546
- break;
547
- }
548
- case FieldCategory.basic: {
549
- if (field.fieldType === "ExtensionObject") {
550
- write(` ${member}?: (${field.fieldType} | null)${arrayOpt};`);
551
- } else if (field.fieldType === "DiagnosticInfo") {
552
- write(` ${member}?: (${field.fieldType} | null)${arrayOpt};`);
553
- } else if (
554
- field.fieldType === "Variant" ||
555
- field.fieldType === "DataValue" ||
556
- field.fieldType === "NodeId" ||
557
- field.fieldType === "QualifiedName" ||
558
- field.fieldType === "LocalizedText"
559
- ) {
560
- write(` ${member}?: (${field.fieldType}Like | null)${arrayOpt};`);
561
- } else {
562
- write(` ${member}?: ${field.fieldType} ${arrayOpt};`);
563
- }
564
- break;
565
- }
566
- case FieldCategory.complex: {
567
- write(` ${member}?: ${field.fieldType}Options ${arrayOpt};`);
568
- break;
569
- }
570
- }
571
- }
572
- }
573
-
574
- function write_declare_class_member(write: WriteFunc, schema: StructuredTypeSchema): void {
575
- const n = schema.fields.length;
576
- for (let i = 0; i < n; i++) {
577
- const field = schema.fields[i];
578
- const member = field.name;
579
-
580
- const arrayOpt = field.isArray ? "[] | null" : "";
581
-
582
- switch (field.category) {
583
- case FieldCategory.enumeration: {
584
- write(` public ${member}: ${field.fieldType}${arrayOpt};`);
585
- break;
586
- }
587
- case FieldCategory.basic: {
588
- if (field.fieldType === "DiagnosticInfo") {
589
- write(` public ${member}: (${field.fieldType} | null)${arrayOpt};`);
590
- } else if (field.fieldType === "ExtensionObject") {
591
- write(` public ${member}: (${field.fieldType} | null)${arrayOpt};`);
592
- } else {
593
- write(` public ${member}: ${field.fieldType}${arrayOpt};`);
594
- }
595
- break;
596
- }
597
- case FieldCategory.complex: {
598
- write(` public ${member}: ${field.fieldType}${arrayOpt};`);
599
- break;
600
- }
601
- }
602
- }
603
- }
604
-
605
- function write_enumerations(write: WriteFunc, schema: StructuredTypeSchema): void {
606
- if (!hasEnumeration(schema)) {
607
- return;
608
- }
609
-
610
- write("");
611
- write(" // Define Enumeration setters");
612
-
613
- const n = schema.fields.length;
614
-
615
- for (let i = 0; i < n; i++) {
616
- const field = schema.fields[i];
617
- const member = field.name;
618
- if (field.category === FieldCategory.enumeration) {
619
- write_enumeration_setter(write, schema, field, member);
620
- }
621
- }
622
- }
623
-
624
- function write_expose_encoder_decoder(write: WriteFunc, schema: StructuredTypeSchema): void {
625
- write("");
626
- write('import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";');
627
- write('import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";');
628
-
629
- const n = schema.fields.length;
630
- const done: any = {};
631
- for (let i = 0; i < n; i++) {
632
- const field = schema.fields[i];
633
- const fieldType = field.fieldType;
634
- if (!(fieldType in done)) {
635
- done[fieldType] = field;
636
- switch (field.category) {
637
- case FieldCategory.basic:
638
- break;
639
- case FieldCategory.enumeration:
640
- write("const _enumeration" + field.fieldType + " = " + 'getEnumeration("' + field.fieldType + '");');
641
- write(
642
- "const encode" +
643
- field.fieldType +
644
- ': (value: any, stream: OutputBinaryStream) => void = getEnumeration("' +
645
- field.fieldType +
646
- '").encode;'
647
- );
648
- write(
649
- "const decode" +
650
- field.fieldType +
651
- ': (stream: BinaryStream) => void = getEnumeration("' +
652
- field.fieldType +
653
- '").decode;'
654
- );
655
- break;
656
- case FieldCategory.complex:
657
- write(
658
- "const encode" +
659
- field.fieldType +
660
- ': (value: any, stream: OutputBinaryStream) => void = getBuildInType("' +
661
- field.fieldType +
662
- '").encode;'
663
- );
664
- write(
665
- "const decode" +
666
- field.fieldType +
667
- ': (stream: BinaryStream) => void = getBuildInType("' +
668
- field.fieldType +
669
- '").decode;'
670
- );
671
- break;
672
- }
673
- }
674
- }
675
- }
676
-
677
- export function writeStructuredType(write: WriteFunc, schema: StructuredTypeSchema) {
678
- const className = schema.name;
679
- const baseClass = schema.baseType;
680
-
681
- const dataTypeNodeId = getDataTypeNodeId(schema);
682
- const encodingBinaryNodeId = getEncodingBinaryId(schema);
683
- const encodingXmlNodeId = getEncodingXmlId(schema);
684
- const encodingJsonNodeId = getEncodingJsonId(schema);
685
-
686
- const needRegistration = encodingBinaryNodeId.value !== 0;
687
-
688
- // ----------------------------------------------- Options
689
- if (baseClass === "BaseUAObject" || baseClass === "ExtensionObject" || baseClass === "DataTypeDefinition") {
690
- write(`export interface ${className}Options {`);
691
- } else {
692
- write(`export interface ${className}Options extends ${baseClass}Options {`);
693
- }
694
- {
695
- write_class_constructor_options(write, schema);
696
- }
697
- write(`}`);
698
-
699
- write(`export class ${className} extends ${baseClass} {`);
700
- {
701
- write(` public static get schema(): StructuredTypeSchema { return schema${className}; }`);
702
- const possibleFields = extract_all_fields(schema);
703
- write_possible_fields(write, className, possibleFields);
704
- // -------------------------------------------------------------------------
705
- // - encodingDefaultBinary
706
- // -------------------------------------------------------------------------
707
- write(` public static dataTypeNodeId = makeExpandedNodeId(${dataTypeNodeId.value}, ${dataTypeNodeId.namespace});`);
708
- if (encodingBinaryNodeId) {
709
- write(
710
- ` public static encodingDefaultBinary = makeExpandedNodeId(${encodingBinaryNodeId.value}, ${encodingBinaryNodeId.namespace});`
711
- );
712
- }
713
-
714
- if (encodingXmlNodeId) {
715
- write(
716
- ` public static encodingDefaultXml = makeExpandedNodeId(${encodingXmlNodeId.value}, ${encodingXmlNodeId.namespace});`
717
- );
718
- } else {
719
- write(" public static encodingDefaultXml = null;");
720
- }
721
- if (encodingJsonNodeId) {
722
- write(
723
- ` public static encodingDefaultJson = makeExpandedNodeId(${encodingJsonNodeId.value}, ${encodingJsonNodeId.namespace});`
724
- );
725
- } else {
726
- write(" public static encodingDefaultJson = null;");
727
- }
728
- // xx write(` static schema = schema${className};`);
729
-
730
- write_declare_class_member(write, schema);
731
- write_constructor(write, schema);
732
-
733
- write_encode(write, schema);
734
- write_decode(write, schema);
735
-
736
- write_enumerations(write, schema);
737
- write_isValid(write, schema);
738
-
739
- write(` public get schema(): StructuredTypeSchema { return schema${className}; }`);
740
- }
741
- write("}");
742
-
743
- if (dataTypeNodeId) {
744
- write(`${className}.schema.dataTypeNodeId = ${className}.dataTypeNodeId;`);
745
- }
746
- if (encodingBinaryNodeId) {
747
- write(`${className}.schema.encodingDefaultBinary = ${className}.encodingDefaultBinary;`);
748
- }
749
-
750
- if (encodingXmlNodeId) {
751
- write(`${className}.schema.encodingDefaultXml = ${className}.encodingDefaultXml;`);
752
- }
753
- if (encodingJsonNodeId) {
754
- write(`${className}.schema.encodingDefaultJson = ${className}.encodingDefaultJson;`);
755
- }
756
-
757
- if (needRegistration) {
758
- write(`registerClassDefinition( ${className}.dataTypeNodeId, "${className}", ${className});`);
759
- }
760
- }
761
-
762
- function getDataTypeNodeId(schema: StructuredTypeSchema): NodeId {
763
- const className = schema.name;
764
- const encodingBinaryId = (DataTypeIds as any)[className];
765
- return coerceNodeId(encodingBinaryId);
766
- }
767
- function getEncodingBinaryId(schema: StructuredTypeSchema): NodeId {
768
- const className = schema.name;
769
- const encodingBinaryId = (ObjectIds as any)[className + "_Encoding_DefaultBinary"];
770
- return coerceNodeId(encodingBinaryId);
771
- }
772
-
773
- function getEncodingXmlId(schema: StructuredTypeSchema): NodeId {
774
- const className = schema.name;
775
- const encodingXmlId = (ObjectIds as any)[className + "_Encoding_DefaultXml"];
776
- return coerceNodeId(encodingXmlId);
777
- }
778
- function getEncodingJsonId(schema: StructuredTypeSchema): NodeId {
779
- const className = schema.name;
780
- const encodingXmlId = (ObjectIds as any)[className + "_Encoding_DefaultJson"];
781
- return coerceNodeId(encodingXmlId);
782
- }
783
-
784
- /* eslint complexity:[0,50], max-statements: [1, 254]*/
785
- export function produce_TScript_code(schema: StructuredTypeSchema, localSchemaFile: string, generatedTypescriptFilename: string) {
786
- const className = schema.name;
787
-
788
- generatedObjectSchema[className] = generatedTypescriptFilename;
789
-
790
- schema.baseType = schema.baseType || "BaseUAObject";
791
-
792
- const baseClass = schema.baseType;
793
-
794
- check_schema_correctness(schema);
795
-
796
- const f = new LineFile1();
797
-
798
- const write = makeWrite(f);
799
-
800
- const complexTypes = schema.fields.filter(
801
- (field: FieldType) => field.category === FieldCategory.complex && field.fieldType !== schema.name
802
- );
803
-
804
- const folderForSourceFile = path.dirname(generatedTypescriptFilename);
805
-
806
- // -------------------------------------------------------------------------
807
- // - insert common requires
808
- // -------------------------------------------------------------------------
809
- write("/**");
810
- write(" * @module node-opcua-address-space.types");
811
- write(" */");
812
- write("/* istanbul ignore file */\n");
813
- write('import { assert } from "node-opcua-assert";');
814
- write('import * as util from "util";');
815
- write('import { makeNodeId, makeExpandedNodeId } from "node-opcua-nodeid";');
816
- write(`import {`);
817
- write(` parameters,`);
818
- write(` check_options_correctness_against_schema,`);
819
- write(` resolve_schema_field_types,`);
820
- write(` initialize_field,`);
821
- write(` initialize_field_array,`);
822
- write(` generate_new_id,`);
823
- write(` getBuildInType,`);
824
- write(` registerClassDefinition,`);
825
- write(` getStructuredTypeSchema,`);
826
- write(` BaseUAObject,`);
827
- write(` getEnumeration`);
828
- write(` } from "node-opcua-factory";`);
829
- write('import { encodeArray, decodeArray } from "node-opcua-basic-types";');
830
- // xx write('import { BaseUAObject } from "node-opcua-factory";');
831
- write("/* tslint:disable:no-this-assignment */");
832
- write("/* tslint:disable:max-classes-per-file */");
833
-
834
- const schemaObjName = schema.name + "_Schema";
835
-
836
- write(`import { ${schemaObjName} } from "${localSchemaFile}";`);
837
- write("const schema = " + schemaObjName + ";");
838
-
839
- // -------------------------------------------------------------------------
840
- // - insert definition of complex type used by this class
841
- // -------------------------------------------------------------------------
842
- const tmpMap: any = {};
843
- for (const field of complexTypes) {
844
- if (tmpMap.hasOwnProperty(field.fieldType)) {
845
- continue;
846
- }
847
- tmpMap[field.fieldType] = 1;
848
-
849
- const filename = get_class_TScript_filename_local(field.fieldType);
850
- const localFilename = normalize_require_file(folderForSourceFile, filename);
851
-
852
- if (fs.existsSync(filename)) {
853
- // xx write("const " + field.fieldType + ' = require("' + local_filename + '").' + field.fieldType + ";");
854
- write(`import { ${field.fieldType} } from "${localFilename}";`);
855
- } else {
856
- write(`import { ${field.fieldType} } from "../source/imports";`);
857
- }
858
- }
859
-
860
- // -------------------------------------------------------------------------
861
- // - insert definition of base class
862
- // -------------------------------------------------------------------------
863
-
864
- if (baseClass !== "BaseUAObject") {
865
- const filename = get_class_TScript_filename_local(baseClass);
866
- const localFilename = normalize_require_file(folderForSourceFile, filename);
867
- // xx console.log(" ===> filename", filename, localFilename, fs.existsSync(filename));
868
-
869
- if (fs.existsSync(filename)) {
870
- assert(!localFilename.match(/\\/));
871
- write("import { " + baseClass + ' } from "' + localFilename + '";');
872
- } else {
873
- write("const " + baseClass + ' = getStructureTypeConstructor("' + baseClass + '");');
874
- }
875
- }
876
-
877
- write_expose_encoder_decoder(write, schema);
878
-
879
- writeStructuredType(write, schema);
880
-
881
- f.saveFormat(generatedTypescriptFilename, (code) => {
882
- return code;
883
- /*
884
- const options: prettier.Options = {
885
- bracketSpacing: true,
886
- insertPragma: true,
887
- parser: "typescript",
888
- printWidth: 120
889
- };
890
- return prettier.format(code, options);
891
- */
892
- });
893
- }
1
+ /* istanbul ignore file */
2
+ /**
3
+ * @module node-opcua-generator
4
+ */
5
+
6
+ // tslint:disable:max-line-length
7
+ // tslint:disable:max-depth
8
+
9
+ import * as os from "os";
10
+ import * as path from "path";
11
+ import * as fs from "fs";
12
+
13
+ import { assert } from "node-opcua-assert";
14
+ import {
15
+ check_schema_correctness,
16
+ extract_all_fields,
17
+ FieldCategory,
18
+ FieldType,
19
+ getStructuredTypeSchema,
20
+ StructuredTypeSchema
21
+ } from "node-opcua-factory";
22
+
23
+ import { DataTypeIds, ObjectIds } from "node-opcua-constants";
24
+ import { make_debugLog } from "node-opcua-debug";
25
+ import { coerceNodeId, NodeId } from "node-opcua-nodeid";
26
+ import { capitalizeFirstLetter } from "node-opcua-utils";
27
+
28
+ import { makeWrite, WriteFunc } from "./utils/write_func";
29
+ import { LineFile1, normalize_require_file } from "./utils/index";
30
+
31
+ const produceComment = false;
32
+ const debugLog = make_debugLog(__filename);
33
+
34
+ const generatedObjectSchema: any = {};
35
+
36
+ function quotify(str: string): string {
37
+ return '"' + str + '"';
38
+ }
39
+
40
+ function makeFieldType(field: FieldType) {
41
+ return "{" + field.fieldType + (field.isArray ? "[" : "") + (field.isArray ? "]" : "") + "}";
42
+ }
43
+
44
+ function convertToJavascriptCode(obj: any): string {
45
+ const lines: string[] = [];
46
+
47
+ if (typeof obj === "object" && !(obj instanceof Array)) {
48
+ lines.push("{");
49
+ for (const prop of Object.keys(obj)) {
50
+ lines.push(prop, ": ", convertToJavascriptCode(obj[prop]), ",");
51
+ }
52
+ lines.push("}");
53
+ } else if (obj instanceof Array) {
54
+ lines.push("[");
55
+ for (const prop of obj) {
56
+ lines.push(convertToJavascriptCode(prop), ",");
57
+ }
58
+ lines.push("]");
59
+
60
+ // tslint:disable:no-empty
61
+ } else if (typeof obj === "function") {
62
+ /** */
63
+ } else {
64
+ lines.push(JSON.stringify(obj));
65
+ }
66
+ return lines.join("");
67
+ }
68
+
69
+ function get_class_folder(schemaName: string, optionalFolder?: string): string {
70
+ let folder;
71
+ if (optionalFolder) {
72
+ if (!fs.existsSync(optionalFolder)) {
73
+ fs.mkdirSync(optionalFolder);
74
+ if (!fs.existsSync(optionalFolder)) {
75
+ throw new Error("get_class_TScript_filename: Cannot find folder " + optionalFolder);
76
+ }
77
+ }
78
+ folder = optionalFolder;
79
+ } else {
80
+ folder = exports.folder_for_generated_file;
81
+ throw new Error("get_class_javascript_filename : DEPRECATED ");
82
+ }
83
+ return folder;
84
+ }
85
+
86
+ export function get_class_TScript_filename(schemaName: string, optionalFolder?: string): string {
87
+ const folder = get_class_folder(schemaName, optionalFolder);
88
+ return path.join(folder, "_" + schemaName + ".ts");
89
+ }
90
+
91
+ export function get_class_JScript_filename(schemaName: string, optionalFolder?: string): string {
92
+ const folder = get_class_folder(schemaName, optionalFolder);
93
+ return path.join(folder, "_" + schemaName + ".js");
94
+ }
95
+
96
+ function get_class_TScript_filename_local(schemaName: string): string {
97
+ let schema = getStructuredTypeSchema(schemaName);
98
+ if (!schema) {
99
+ schema = generatedObjectSchema[schemaName];
100
+ if (!schema) {
101
+ throw new Error("cannot find script file for " + schemaName);
102
+ }
103
+ return "./_" + schemaName;
104
+ }
105
+ let generateTypeScriptSource = "/* fix me schema.prototype.schema.generate_ts_source*/";
106
+ if (!generateTypeScriptSource) {
107
+ const folder = "."; // exports.folder_for_generated_file;
108
+ generateTypeScriptSource = path.join(folder, "_" + schemaName + ".ts");
109
+ }
110
+ return generateTypeScriptSource;
111
+ }
112
+
113
+ function write_enumeration_setter(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string): void {
114
+ const capMember = capitalizeFirstLetter(member);
115
+ write(` public set${capMember}(value: any): ${field.fieldType} {`);
116
+ write(` const coercedValue = _enumeration${field.fieldType}.get(value);`);
117
+ write(` /* istanbul ignore next */`);
118
+ write(` if (coercedValue === undefined || coercedValue === null) {`);
119
+ write(` throw new Error("value cannot be coerced to ${field.fieldType} :" + value);`);
120
+ write(` }`);
121
+ write(` this.${member} = coercedValue.value as ${field.fieldType};`);
122
+ write(` return this.${member};`);
123
+ write(` }`);
124
+ }
125
+
126
+ function write_enumeration_fast_init(
127
+ write: WriteFunc,
128
+ schema: StructuredTypeSchema,
129
+ field: FieldType,
130
+ member: string,
131
+ i: number
132
+ ): void {
133
+ write(` this.${member} = 0 as ${field.fieldType};`);
134
+ }
135
+
136
+ function write_enumeration(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
137
+ assert(!field.isArray); // would not work in this case
138
+ const capMember = capitalizeFirstLetter(member);
139
+ write(` this.${field.name} = this.set${capMember}(initialize_field(schema.fields[${i}], options?.${field.name}));`);
140
+ }
141
+
142
+ function write_complex_fast_init(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string) {
143
+ if (field.isArray) {
144
+ write(` this.${member} = null; /* null array */`);
145
+ } else {
146
+ write(` this.${member} = new ${field.fieldType}(null);`);
147
+ }
148
+ }
149
+
150
+ function write_complex(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string /*, i*/) {
151
+ if (field.isArray) {
152
+ if (Object.prototype.hasOwnProperty.call(field, "defaultValue")) {
153
+ // todo: fix me => should call field defaultValue in the live version
154
+ write(` this.${member} = []; // should default`);
155
+ } else {
156
+ write(` this.${member} = [];`);
157
+ }
158
+ write(` if (options.${member}) {`);
159
+ write(` assert(Array.isArray(options.${member}));`);
160
+ write(` this.${member} = options.${member}.map((e: any) => new ${field.fieldType}(e));`);
161
+ // write(` self.${member} = options.${member}.map(function(e){ return construct${field.fieldType}(e); } );`);
162
+ write(" }");
163
+ } else {
164
+ if (field.defaultValue === null || field.fieldType === schema.name) {
165
+ write(` this.${member} = (options.${member}) ? new ${field.fieldType}( options.${member}) : null;`);
166
+ // xx write(` self.${member} = (options.${member}) ? construct${field.fieldType}( options.${member}) : null;`);
167
+ } else {
168
+ write(` this.${member} = new ${field.fieldType}(options.${member});`);
169
+ // xx write(` self.${member} = construct${field.fieldType}(options.${member});`);
170
+ }
171
+ }
172
+ }
173
+
174
+ function write_basic(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
175
+ assert(field.category === FieldCategory.basic);
176
+
177
+ if (field.isArray) {
178
+ // write(`this.${member} = [];`);
179
+ // write(`if (options.${member}) {`);
180
+ // write(` assert(Array.isArray(options.${member}));`);
181
+ // write(` this.${member} = options.browsePath.map(e => field.coerce(e) );`);
182
+ // write(`}`);
183
+ write(` this.${member} = initialize_field_array(schema.fields[${i}], options?.${field.name});`);
184
+ } else {
185
+ write(` this.${member} = initialize_field(schema.fields[${i}], options?.${field.name});`);
186
+ }
187
+ }
188
+ function write_basic_fast_init(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, member: string, i: number): void {
189
+ if (field.isArray) {
190
+ // write(`this.${member} = [];`);
191
+ // write(`if (options.${member}) {`);
192
+ // write(` assert(Array.isArray(options.${member}));`);
193
+ // write(` this.${member} = options.browsePath.map(e => field.coerce(e) );`);
194
+ // write(`}`);
195
+ write(` this.${member} = []`);
196
+ } else {
197
+ switch (field.schema.name) {
198
+ case "Variant":
199
+ write(` this.${member} = new Variant(null);`);
200
+ break;
201
+ case "UABoolean":
202
+ case "Boolean":
203
+ write(` this.${member} = false;`);
204
+ break;
205
+ case "UAString":
206
+ write(` this.${member} = null;`);
207
+ break;
208
+ case "ExpandedNodeId":
209
+ write(` this.${member} = new ExpandedNodeId(null);`);
210
+ break;
211
+ case "NodeId":
212
+ write(` this.${member} = new NodeId(null);`);
213
+ break;
214
+ case "QualifiedName":
215
+ write(` this.${member} = new QualifiedName(null);`);
216
+ break;
217
+ case "DateTime":
218
+ write(` this.${member} = new Date();`);
219
+ break;
220
+ case "ByteString":
221
+ write(` this.${member} = Buffer.alloc(0);`);
222
+ break;
223
+ case "StatusCode":
224
+ write(` this.${member} = StatusCodes.Good;`);
225
+ break;
226
+ case "DiagnosticInfo":
227
+ case "ExtensionObject":
228
+ write(` this.${member} = null;`);
229
+ break;
230
+ case "NumericRange":
231
+ write(` this.${member} = new NumericRange(null);`);
232
+ break;
233
+ case "LocalizedText":
234
+ write(` this.${member} = new LocalizedText(null);`);
235
+ break;
236
+ case "Guid":
237
+ write(` this.${member} = "";`);
238
+ break;
239
+ case "UInt64":
240
+ write(` this.${member} = [];`);
241
+ break;
242
+ case "Int64":
243
+ write(` this.${member} = [];`);
244
+ break;
245
+ case "DataValue":
246
+ write(` this.${member} = new DataValue(null);`);
247
+ break;
248
+
249
+ default:
250
+ write(` this.${member} = 0;`);
251
+ }
252
+ }
253
+ }
254
+ function write_fast_init_member(write: WriteFunc, schema: StructuredTypeSchema, field: FieldType, i: number) {
255
+ const member = field.name;
256
+ switch (field.category) {
257
+ case FieldCategory.enumeration:
258
+ write_enumeration_fast_init(write, schema, field, member, i);
259
+ break;
260
+ case FieldCategory.basic:
261
+ write_basic_fast_init(write, schema, field, member, i);
262
+ break;
263
+ case FieldCategory.complex:
264
+ write_complex_fast_init(write, schema, field, member);
265
+ break;
266
+ }
267
+ }
268
+
269
+ function write_constructor(write: WriteFunc, schema: StructuredTypeSchema): void {
270
+ const baseClass = schema.baseType;
271
+ const className = schema.name;
272
+ write("");
273
+ const n = schema.fields.length;
274
+
275
+ if (produceComment) {
276
+ write(" /**");
277
+ if (schema.documentation && schema.documentation.length > 0) {
278
+ write(" * " + schema.documentation);
279
+ }
280
+ let def = "";
281
+ for (let i = 0; i < n; i++) {
282
+ const field = schema.fields[i];
283
+ const fieldType = field.fieldType;
284
+ const documentation = field.documentation ? field.documentation : "";
285
+ def = "";
286
+ if (field.defaultValue !== undefined) {
287
+ if (typeof field.defaultValue === "function") {
288
+ def = " = " + field.defaultValue();
289
+ } else {
290
+ def = " = " + field.defaultValue;
291
+ }
292
+ }
293
+ const ft = makeFieldType(field);
294
+ // xx write(" * @param [options." + field.name + def + "] " + ft + " " + documentation);
295
+ }
296
+
297
+ write(" */");
298
+ }
299
+
300
+ write(` constructor(options?: ${className}Options | null) {`);
301
+ write("");
302
+ if (baseClass) {
303
+ if (baseClass === "BaseUAObject") {
304
+ write(" super();");
305
+ } else {
306
+ write(" super(options);");
307
+ }
308
+ write("");
309
+ }
310
+
311
+ // detect de-serialization constructor
312
+ // -----------------------------------------------------------------------------------------------------------------
313
+ // Special case when options === null => fast constructor for de-serialization
314
+ // -----------------------------------------------------------------------------------------------------------------
315
+ write(` if (options === null) {`);
316
+ for (let i = 0; i < n; i++) {
317
+ const field = schema.fields[i];
318
+ write_fast_init_member(write, schema, field, i);
319
+ }
320
+ write(" return;");
321
+ write(" }");
322
+
323
+ write(` const schema = ${className}.schema;`);
324
+ if (typeof schema.constructHook === "function") {
325
+ write(` options = schema.constructHook(options) as ${className}Options;`);
326
+ } else {
327
+ write(` options = (schema.constructHook ? schema.constructHook(options) as ${className}Options: options ) || {};`);
328
+ }
329
+ // write(" if (options === undefined) { options = {}; }");
330
+
331
+ write(" /* istanbul ignore next */");
332
+ write(" if (parameters.debugSchemaHelper) {");
333
+ write(" check_options_correctness_against_schema(this, schema, options);");
334
+ write(" }");
335
+
336
+ // -----------------------------------------------------------------------------------------------------------------
337
+
338
+ for (let i = 0; i < n; i++) {
339
+ const field = schema.fields[i];
340
+ const member = field.name;
341
+
342
+ if (produceComment) {
343
+ write("");
344
+ write(" /**");
345
+ const documentation = field.documentation ? field.documentation : "";
346
+ if (documentation && documentation.length > 0) {
347
+ write(" * ", documentation);
348
+ }
349
+
350
+ if (produceComment) {
351
+ write(" * @property ", field.name);
352
+ // write(" * @type {", (field.isArray ? "Array[" : "") + field.fieldType + (field.isArray ? " ]" : "")+"}");
353
+ write(" * @type " + makeFieldType(field));
354
+ }
355
+ if (field.defaultValue !== undefined && typeof field.defaultValue !== "function") {
356
+ write(" * @default ", field.defaultValue);
357
+ }
358
+
359
+ write(" */");
360
+ }
361
+
362
+ switch (field.category) {
363
+ case FieldCategory.enumeration:
364
+ write_enumeration(write, schema, field, member, i);
365
+ break;
366
+ case FieldCategory.complex:
367
+ write_complex(write, schema, field, member);
368
+ break;
369
+ default:
370
+ write_basic(write, schema, field, member, i);
371
+ break;
372
+ }
373
+ }
374
+ write(" }");
375
+ }
376
+
377
+ function write_possible_fields(write: WriteFunc, className: string, possibleFields: string[]): void {
378
+ write(" public static possibleFields: string[] = [");
379
+ write(" " + possibleFields.map(quotify).join("," + os.EOL + " "));
380
+ write(" ];");
381
+ }
382
+
383
+ function write_isValid(write: WriteFunc, schema: StructuredTypeSchema): void {
384
+ // ---------------------------------------
385
+ if (typeof schema.isValid === "function") {
386
+ if (produceComment) {
387
+ write(" /**");
388
+ write(" *");
389
+ write(" * verify that all object attributes values are valid according to schema");
390
+ write(" * @method isValid");
391
+ write(" * @return {Boolean}");
392
+ write(" */");
393
+ }
394
+ write(" isValid(): boolean { return schema.isValid(this); };");
395
+ }
396
+ }
397
+
398
+ function write_encode(write: WriteFunc, schema: StructuredTypeSchema): void {
399
+ if (typeof schema.encode === "function") {
400
+ write(" public encode(stream: OutputBinaryStream): void {");
401
+ write(" " + "schema" + ".encode(this, stream);");
402
+ write(" }");
403
+ } else {
404
+ if (produceComment) {
405
+ write(" /**");
406
+ write(" * encode the object into a binary stream");
407
+ write(" * @method encode");
408
+ write(" *");
409
+ write(" * @param stream {BinaryStream}");
410
+ write(" */");
411
+ }
412
+ write(" public encode(stream: OutputBinaryStream): void {");
413
+ write(" /* NEEDED */ super.encode(stream);");
414
+
415
+ const n = schema.fields.length;
416
+ for (let i = 0; i < n; i++) {
417
+ const field = schema.fields[i];
418
+ const member = field.name;
419
+
420
+ switch (field.category) {
421
+ case FieldCategory.enumeration:
422
+ case FieldCategory.basic:
423
+ if (field.isArray) {
424
+ write(` encodeArray(this.${member}, stream, encode${field.fieldType});`);
425
+ } else {
426
+ write(` encode${field.fieldType}(this.${member}, stream);`);
427
+ }
428
+ break;
429
+ case FieldCategory.complex:
430
+ if (field.isArray) {
431
+ write(` encodeArray(this.${member}, stream, (obj, stream1) => { obj.encode(stream1); });`);
432
+ } else {
433
+ write(` this.${member}.encode(stream);`);
434
+ }
435
+ break;
436
+ }
437
+ }
438
+ write(" }");
439
+ }
440
+ }
441
+
442
+ function write_decode(write: WriteFunc, schema: StructuredTypeSchema): void {
443
+ // --------------------------------------------------------------
444
+ // implement decode
445
+ function write_field(field: FieldType, member: string, i: number) {
446
+ if (field.category === FieldCategory.enumeration || field.category === FieldCategory.basic) {
447
+ if (field.isArray) {
448
+ write(" this." + member + " = decodeArray(stream, decode" + field.fieldType + ");");
449
+ } else {
450
+ if (false) {
451
+ write(" this." + member + ".decode(stream);");
452
+ } else {
453
+ if (typeof field.decode === "function") {
454
+ write(" this." + member + " = " + "schema" + ".fields[" + i + "].decode(stream);");
455
+ } else {
456
+ write(" this." + member + " = decode" + field.fieldType + "(stream, this." + member + ");");
457
+ }
458
+ }
459
+ }
460
+ } else {
461
+ assert(field.category === FieldCategory.complex);
462
+ if (field.isArray) {
463
+ write(" this." + member + " = decodeArray(stream, (stream1: BinaryStream) => {");
464
+ write(" const obj = new " + field.fieldType + "(null);");
465
+ write(" obj.decode(stream1);");
466
+ write(" return obj;");
467
+ write(" });");
468
+ } else {
469
+ write(" this." + member + ".decode(stream);");
470
+ // xx write(" this." + member + ".decode(stream);");
471
+ }
472
+ }
473
+ }
474
+
475
+ // ---------------------------------------------------------------
476
+ if (typeof schema.decode === "function") {
477
+ if (produceComment) {
478
+ write(" /**");
479
+ write(" * decode the object from a binary stream");
480
+ write(" * @method decode");
481
+ write(" *");
482
+ write(" * @param stream {BinaryStream}");
483
+ write(" */");
484
+ }
485
+ write(" public decode(stream: BinaryStream): void {");
486
+ write(" " + "schema" + ".decode(this,stream);");
487
+ write(" }");
488
+
489
+ if (typeof schema.decodeDebug !== "function") {
490
+ throw new Error("schema decode requires also to provide a decodeDebug " + schema.name);
491
+ }
492
+ write(" public decodeDebug(stream: BinaryStream, options: any): void {");
493
+ write(" " + "schema" + ".decodeDebug(this,stream,options);");
494
+ write(" }");
495
+ } else {
496
+ if (produceComment) {
497
+ write(" /**");
498
+ write(" * decode the object from a binary stream");
499
+ write(" * @method decode");
500
+ write(" *");
501
+ write(" * @param stream {BinaryStream}");
502
+ write(" */");
503
+ }
504
+ write(" public decode(stream: BinaryStream): void {");
505
+ write(" // call base class implementation first");
506
+ write(" /* NEEDED !!! */ super.decode(stream);");
507
+
508
+ const n = schema.fields.length;
509
+ for (let i = 0; i < n; i++) {
510
+ const field = schema.fields[i];
511
+ const fieldType = field.fieldType;
512
+ const member = field.name;
513
+ write_field(field, member, i);
514
+ }
515
+ write(" }");
516
+ }
517
+ }
518
+
519
+ function hasEnumeration(schema: StructuredTypeSchema): boolean {
520
+ for (const field of schema.fields) {
521
+ if (field.category === FieldCategory.enumeration) {
522
+ return true;
523
+ }
524
+ }
525
+ return false;
526
+ }
527
+
528
+ function hasComplex(schema: StructuredTypeSchema): boolean {
529
+ for (const field of schema.fields) {
530
+ if (field.category === FieldCategory.complex) {
531
+ return true;
532
+ }
533
+ }
534
+ return false;
535
+ }
536
+
537
+ function write_class_constructor_options(write: WriteFunc, schema: StructuredTypeSchema): void {
538
+ const n = schema.fields.length;
539
+ for (let i = 0; i < n; i++) {
540
+ const field = schema.fields[i];
541
+ const member = field.name;
542
+
543
+ const arrayOpt = field.isArray ? "[] | null" : "";
544
+
545
+ switch (field.category) {
546
+ case FieldCategory.enumeration: {
547
+ write(` ${member}?: ${field.fieldType}${arrayOpt};`);
548
+ break;
549
+ }
550
+ case FieldCategory.basic: {
551
+ if (field.fieldType === "ExtensionObject") {
552
+ write(` ${member}?: (${field.fieldType} | null)${arrayOpt};`);
553
+ } else if (field.fieldType === "DiagnosticInfo") {
554
+ write(` ${member}?: (${field.fieldType} | null)${arrayOpt};`);
555
+ } else if (
556
+ field.fieldType === "Variant" ||
557
+ field.fieldType === "DataValue" ||
558
+ field.fieldType === "NodeId" ||
559
+ field.fieldType === "QualifiedName" ||
560
+ field.fieldType === "LocalizedText"
561
+ ) {
562
+ write(` ${member}?: (${field.fieldType}Like | null)${arrayOpt};`);
563
+ } else {
564
+ write(` ${member}?: ${field.fieldType} ${arrayOpt};`);
565
+ }
566
+ break;
567
+ }
568
+ case FieldCategory.complex: {
569
+ write(` ${member}?: ${field.fieldType}Options ${arrayOpt};`);
570
+ break;
571
+ }
572
+ }
573
+ }
574
+ }
575
+
576
+ function write_declare_class_member(write: WriteFunc, schema: StructuredTypeSchema): void {
577
+ const n = schema.fields.length;
578
+ for (let i = 0; i < n; i++) {
579
+ const field = schema.fields[i];
580
+ const member = field.name;
581
+
582
+ const arrayOpt = field.isArray ? "[] | null" : "";
583
+
584
+ switch (field.category) {
585
+ case FieldCategory.enumeration: {
586
+ write(` public ${member}: ${field.fieldType}${arrayOpt};`);
587
+ break;
588
+ }
589
+ case FieldCategory.basic: {
590
+ if (field.fieldType === "DiagnosticInfo") {
591
+ write(` public ${member}: (${field.fieldType} | null)${arrayOpt};`);
592
+ } else if (field.fieldType === "ExtensionObject") {
593
+ write(` public ${member}: (${field.fieldType} | null)${arrayOpt};`);
594
+ } else {
595
+ write(` public ${member}: ${field.fieldType}${arrayOpt};`);
596
+ }
597
+ break;
598
+ }
599
+ case FieldCategory.complex: {
600
+ write(` public ${member}: ${field.fieldType}${arrayOpt};`);
601
+ break;
602
+ }
603
+ }
604
+ }
605
+ }
606
+
607
+ function write_enumerations(write: WriteFunc, schema: StructuredTypeSchema): void {
608
+ if (!hasEnumeration(schema)) {
609
+ return;
610
+ }
611
+
612
+ write("");
613
+ write(" // Define Enumeration setters");
614
+
615
+ const n = schema.fields.length;
616
+
617
+ for (let i = 0; i < n; i++) {
618
+ const field = schema.fields[i];
619
+ const member = field.name;
620
+ if (field.category === FieldCategory.enumeration) {
621
+ write_enumeration_setter(write, schema, field, member);
622
+ }
623
+ }
624
+ }
625
+
626
+ function write_expose_encoder_decoder(write: WriteFunc, schema: StructuredTypeSchema): void {
627
+ write("");
628
+ write('import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";');
629
+ write('import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";');
630
+
631
+ const n = schema.fields.length;
632
+ const done: any = {};
633
+ for (let i = 0; i < n; i++) {
634
+ const field = schema.fields[i];
635
+ const fieldType = field.fieldType;
636
+ if (!(fieldType in done)) {
637
+ done[fieldType] = field;
638
+ switch (field.category) {
639
+ case FieldCategory.basic:
640
+ break;
641
+ case FieldCategory.enumeration:
642
+ write("const _enumeration" + field.fieldType + " = " + 'getEnumeration("' + field.fieldType + '");');
643
+ write(
644
+ "const encode" +
645
+ field.fieldType +
646
+ ': (value: any, stream: OutputBinaryStream) => void = getEnumeration("' +
647
+ field.fieldType +
648
+ '").encode;'
649
+ );
650
+ write(
651
+ "const decode" +
652
+ field.fieldType +
653
+ ': (stream: BinaryStream) => void = getEnumeration("' +
654
+ field.fieldType +
655
+ '").decode;'
656
+ );
657
+ break;
658
+ case FieldCategory.complex:
659
+ write(
660
+ "const encode" +
661
+ field.fieldType +
662
+ ': (value: any, stream: OutputBinaryStream) => void = getBuildInType("' +
663
+ field.fieldType +
664
+ '").encode;'
665
+ );
666
+ write(
667
+ "const decode" +
668
+ field.fieldType +
669
+ ': (stream: BinaryStream) => void = getBuildInType("' +
670
+ field.fieldType +
671
+ '").decode;'
672
+ );
673
+ break;
674
+ }
675
+ }
676
+ }
677
+ }
678
+
679
+ export function writeStructuredType(write: WriteFunc, schema: StructuredTypeSchema): void {
680
+ const className = schema.name;
681
+ const baseClass = schema.baseType;
682
+
683
+ const dataTypeNodeId = getDataTypeNodeId(schema);
684
+ const encodingBinaryNodeId = getEncodingBinaryId(schema);
685
+ const encodingXmlNodeId = getEncodingXmlId(schema);
686
+ const encodingJsonNodeId = getEncodingJsonId(schema);
687
+
688
+ const needRegistration = encodingBinaryNodeId.value !== 0;
689
+
690
+ // ----------------------------------------------- Options
691
+ if (baseClass === "BaseUAObject" || baseClass === "ExtensionObject" || baseClass === "DataTypeDefinition") {
692
+ write(`export interface ${className}Options {`);
693
+ } else {
694
+ write(`export interface ${className}Options extends ${baseClass}Options {`);
695
+ }
696
+ {
697
+ write_class_constructor_options(write, schema);
698
+ }
699
+ write(`}`);
700
+
701
+ write(`export class ${className} extends ${baseClass} {`);
702
+ {
703
+ write(` public static get schema(): StructuredTypeSchema { return schema${className}; }`);
704
+ const possibleFields = extract_all_fields(schema);
705
+ write_possible_fields(write, className, possibleFields);
706
+ // -------------------------------------------------------------------------
707
+ // - encodingDefaultBinary
708
+ // -------------------------------------------------------------------------
709
+ write(` public static dataTypeNodeId = makeExpandedNodeId(${dataTypeNodeId.value}, ${dataTypeNodeId.namespace});`);
710
+ if (encodingBinaryNodeId) {
711
+ write(
712
+ ` public static encodingDefaultBinary = makeExpandedNodeId(${encodingBinaryNodeId.value}, ${encodingBinaryNodeId.namespace});`
713
+ );
714
+ }
715
+
716
+ if (encodingXmlNodeId) {
717
+ write(
718
+ ` public static encodingDefaultXml = makeExpandedNodeId(${encodingXmlNodeId.value}, ${encodingXmlNodeId.namespace});`
719
+ );
720
+ } else {
721
+ write(" public static encodingDefaultXml = null;");
722
+ }
723
+ if (encodingJsonNodeId) {
724
+ write(
725
+ ` public static encodingDefaultJson = makeExpandedNodeId(${encodingJsonNodeId.value}, ${encodingJsonNodeId.namespace});`
726
+ );
727
+ } else {
728
+ write(" public static encodingDefaultJson = null;");
729
+ }
730
+ // xx write(` static schema = schema${className};`);
731
+
732
+ write_declare_class_member(write, schema);
733
+ write_constructor(write, schema);
734
+
735
+ write_encode(write, schema);
736
+ write_decode(write, schema);
737
+
738
+ write_enumerations(write, schema);
739
+ write_isValid(write, schema);
740
+
741
+ write(` public get schema(): StructuredTypeSchema { return schema${className}; }`);
742
+ }
743
+ write("}");
744
+
745
+ if (dataTypeNodeId) {
746
+ write(`${className}.schema.dataTypeNodeId = ${className}.dataTypeNodeId;`);
747
+ }
748
+ if (encodingBinaryNodeId) {
749
+ write(`${className}.schema.encodingDefaultBinary = ${className}.encodingDefaultBinary;`);
750
+ }
751
+
752
+ if (encodingXmlNodeId) {
753
+ write(`${className}.schema.encodingDefaultXml = ${className}.encodingDefaultXml;`);
754
+ }
755
+ if (encodingJsonNodeId) {
756
+ write(`${className}.schema.encodingDefaultJson = ${className}.encodingDefaultJson;`);
757
+ }
758
+
759
+ if (needRegistration) {
760
+ write(`registerClassDefinition( ${className}.dataTypeNodeId, "${className}", ${className});`);
761
+ }
762
+ }
763
+
764
+ function getDataTypeNodeId(schema: StructuredTypeSchema): NodeId {
765
+ const className = schema.name;
766
+ const encodingBinaryId = (DataTypeIds as any)[className];
767
+ return coerceNodeId(encodingBinaryId);
768
+ }
769
+ function getEncodingBinaryId(schema: StructuredTypeSchema): NodeId {
770
+ const className = schema.name;
771
+ const encodingBinaryId = (ObjectIds as any)[className + "_Encoding_DefaultBinary"];
772
+ return coerceNodeId(encodingBinaryId);
773
+ }
774
+
775
+ function getEncodingXmlId(schema: StructuredTypeSchema): NodeId {
776
+ const className = schema.name;
777
+ const encodingXmlId = (ObjectIds as any)[className + "_Encoding_DefaultXml"];
778
+ return coerceNodeId(encodingXmlId);
779
+ }
780
+ function getEncodingJsonId(schema: StructuredTypeSchema): NodeId {
781
+ const className = schema.name;
782
+ const encodingXmlId = (ObjectIds as any)[className + "_Encoding_DefaultJson"];
783
+ return coerceNodeId(encodingXmlId);
784
+ }
785
+
786
+ /* eslint complexity:[0,50], max-statements: [1, 254]*/
787
+ export function produce_TScript_code(
788
+ schema: StructuredTypeSchema,
789
+ localSchemaFile: string,
790
+ generatedTypescriptFilename: string
791
+ ): void {
792
+ const className = schema.name;
793
+
794
+ generatedObjectSchema[className] = generatedTypescriptFilename;
795
+
796
+ schema.baseType = schema.baseType || "BaseUAObject";
797
+
798
+ const baseClass = schema.baseType;
799
+
800
+ check_schema_correctness(schema);
801
+
802
+ const f = new LineFile1();
803
+
804
+ const write = makeWrite(f);
805
+
806
+ const complexTypes = schema.fields.filter(
807
+ (field: FieldType) => field.category === FieldCategory.complex && field.fieldType !== schema.name
808
+ );
809
+
810
+ const folderForSourceFile = path.dirname(generatedTypescriptFilename);
811
+
812
+ // -------------------------------------------------------------------------
813
+ // - insert common requires
814
+ // -------------------------------------------------------------------------
815
+ write("/**");
816
+ write(" * @module node-opcua-address-space.types");
817
+ write(" */");
818
+ write("/* istanbul ignore file */\n");
819
+ write('import { assert } from "node-opcua-assert";');
820
+ write('import * as util from "util";');
821
+ write('import { makeNodeId, makeExpandedNodeId } from "node-opcua-nodeid";');
822
+ write(`import {`);
823
+ write(` parameters,`);
824
+ write(` check_options_correctness_against_schema,`);
825
+ write(` resolve_schema_field_types,`);
826
+ write(` initialize_field,`);
827
+ write(` initialize_field_array,`);
828
+ write(` generate_new_id,`);
829
+ write(` getBuildInType,`);
830
+ write(` registerClassDefinition,`);
831
+ write(` getStructuredTypeSchema,`);
832
+ write(` BaseUAObject,`);
833
+ write(` getEnumeration`);
834
+ write(` } from "node-opcua-factory";`);
835
+ write('import { encodeArray, decodeArray } from "node-opcua-basic-types";');
836
+ // xx write('import { BaseUAObject } from "node-opcua-factory";');
837
+ write("/* tslint:disable:no-this-assignment */");
838
+ write("/* tslint:disable:max-classes-per-file */");
839
+
840
+ const schemaObjName = schema.name + "_Schema";
841
+
842
+ write(`import { ${schemaObjName} } from "${localSchemaFile}";`);
843
+ write("const schema = " + schemaObjName + ";");
844
+
845
+ // -------------------------------------------------------------------------
846
+ // - insert definition of complex type used by this class
847
+ // -------------------------------------------------------------------------
848
+ const tmpMap: any = {};
849
+ for (const field of complexTypes) {
850
+ if (Object.prototype.hasOwnProperty.call(tmpMap, field.fieldType)) {
851
+ continue;
852
+ }
853
+ tmpMap[field.fieldType] = 1;
854
+
855
+ const filename = get_class_TScript_filename_local(field.fieldType);
856
+ const localFilename = normalize_require_file(folderForSourceFile, filename);
857
+
858
+ if (fs.existsSync(filename)) {
859
+ // xx write("const " + field.fieldType + ' = require("' + local_filename + '").' + field.fieldType + ";");
860
+ write(`import { ${field.fieldType} } from "${localFilename}";`);
861
+ } else {
862
+ write(`import { ${field.fieldType} } from "../source/imports";`);
863
+ }
864
+ }
865
+
866
+ // -------------------------------------------------------------------------
867
+ // - insert definition of base class
868
+ // -------------------------------------------------------------------------
869
+
870
+ if (baseClass !== "BaseUAObject") {
871
+ const filename = get_class_TScript_filename_local(baseClass);
872
+ const localFilename = normalize_require_file(folderForSourceFile, filename);
873
+ // xx console.log(" ===> filename", filename, localFilename, fs.existsSync(filename));
874
+
875
+ if (fs.existsSync(filename)) {
876
+ assert(!localFilename.match(/\\/));
877
+ write("import { " + baseClass + ' } from "' + localFilename + '";');
878
+ } else {
879
+ write("const " + baseClass + ' = getStructureTypeConstructor("' + baseClass + '");');
880
+ }
881
+ }
882
+
883
+ write_expose_encoder_decoder(write, schema);
884
+
885
+ writeStructuredType(write, schema);
886
+
887
+ f.saveFormat(generatedTypescriptFilename, (code) => {
888
+ return code;
889
+ /*
890
+ const options: prettier.Options = {
891
+ bracketSpacing: true,
892
+ insertPragma: true,
893
+ parser: "typescript",
894
+ printWidth: 120
895
+ };
896
+ return prettier.format(code, options);
897
+ */
898
+ });
899
+ }