@canboat/canboatjs 2.4.5 → 2.5.0

package/lib/fromPgn.js

@@ -19,7 +19,7 @@ const trace = require('debug')('canboatjs:fromPgn:trace')
 const EventEmitter = require('events')
 const pkg = require('../package.json')
 const _ = require('lodash')
-const { pgns, getCustomPgn, addCustomPgns, lookupEnumerationName, lookupBitEnumerationName } = require('./pgns')
+const { pgns, getCustomPgn, addCustomPgns, lookupEnumerationName, lookupFieldTypeEnumerationName, lookupBitEnumerationName, lookupFieldTypeEnumerationBits, lookupFieldTypeEnumerationValue } = require('./pgns')
 const BitStream = require('bit-buffer').BitStream
 const BitView = require('bit-buffer').BitView
 const Int64LE = require('int64-buffer').Int64LE
@@ -212,7 +212,7 @@ class Parser extends EventEmitter {
         var field = fields[i]
         var hasMatch = !_.isUndefined(field.Match)
 
-        var value = readField(this.options, !hasMatch, pgn, field, bs)
+        var value = readField(this.options, !hasMatch, pgn, field, bs, fields)
 
         if ( hasMatch ) {
           //console.log(`looking for ${field.Name} == ${value}`)
@@ -270,7 +270,7 @@ class Parser extends EventEmitter {
           var group = {}
           repeating.forEach(field => {
             if ( bs.bitsLeft > 0 ) {
-              var value = readField(this.options, true, pgn, field, bs)
+              var value = readField(this.options, true, pgn, field, bs, fields)
               if ( !_.isUndefined(value) && value != null ) {
                 group[field.Name] = value
               }
@@ -561,11 +561,17 @@ function pad(n, p, c)
 }
 
 function lookup(field, value) {
-  var name = lookupEnumerationName(field.LookupEnumeration, value)
+  var name
+  if ( field.LookupEnumeration ) {
+    name = lookupEnumerationName(field.LookupEnumeration, value)
+  } else {
+    name = lookupFieldTypeEnumerationName(field.LookupFieldTypeEnumeration, value)
+  }
+    
   return name ? name : value
 }
 
-function readField(options, runPostProcessor, pgn, field, bs) {
+function readField(options, runPostProcessor, pgn, field, bs, fields) {
   var value
 
   var reader = fieldTypeReaders[field.FieldType]
@@ -577,7 +583,7 @@ function readField(options, runPostProcessor, pgn, field, bs) {
       bs.readBits(bs.bitsLeft, false)
       return
     }
-    value = readValue(options, pgn, field, bs)
+    value = readValue(options, pgn, field, bs, fields)
   }
 
   //console.log(`${field.Name} ${value} ${field.Resolution}`)
@@ -650,10 +656,14 @@ function readField(options, runPostProcessor, pgn, field, bs) {
   return value
 }
 
-function readValue(options, pgn, field, bs, bitLength) {
+function readValue(options, pgn, field, bs, fields, bitLength) {
   var value
   if ( _.isUndefined(bitLength) ) {
-    bitLength = field.BitLength
+    if ( field.BitLengthVariable && field.FieldType === "KEY_VALUE" ) {
+      bitLength = lookupKeyBitLength(pgn.fields, fields)
+    } else {
+      bitLength = field.BitLength
+    }
   }
   if ( field.FieldType == 'VARIABLE' ) {
     return readVariableLengthField(options, pgn, field, bs)
@@ -896,6 +906,17 @@ fieldTypeReaders['BITLOOKUP'] = (pgn, field, bs) => {
   return value
 }
 
+function lookupKeyBitLength(data, fields)
+{
+  let field = fields.find(field => (field.Name === 'Key'))
+
+  let val = data['Key']
+  if ( typeof val === 'string' ) {
+    val = lookupFieldTypeEnumerationValue(field.LookupFieldTypeEnumeration, val)
+  }
+  return lookupFieldTypeEnumerationBits(field.LookupFieldTypeEnumeration, val)
+}
+
 fieldTypePostProcessors['DATE'] = (field, value) => {
   if ( value >= 0xfffd ) {
     value = undefined

package/lib/pgns.js

@@ -54,6 +54,29 @@ function getEnumeration(name) {
   return enumeration
 }
 
+function getFieldTypeEnumeration(name) {
+  const enumeration = lookupFieldTypeEnumerations[name]
+  if ( enumeration ) {
+    if ( !enumeration.value2name ) {
+      enumeration.value2name = {}
+      enumeration.EnumFieldTypeValues.forEach((enumPair) => {
+        enumeration.value2name[Number(enumPair.value)] = enumPair.name
+      })
+      
+      enumeration.name2value = {}
+      enumeration.EnumFieldTypeValues.forEach((enumPair) => {
+        enumeration.name2value[enumPair.name] = Number(enumPair.value)
+      })
+      
+      enumeration.value2bits = {}
+      enumeration.EnumFieldTypeValues.forEach((enumPair) => {
+        enumeration.value2bits[enumPair.value] = Number(enumPair.Bits)
+      })
+    }
+  }
+  return enumeration
+}
+
 function getBitEnumeration(name) {
   const enumeration = lookupBitEnumerations[name]
   if ( enumeration ) {
@@ -82,6 +105,21 @@ function lookupEnumerationValue(enumName, name) {
   return enumeration && enumeration.name2value[name]
 }
 
+function lookupFieldTypeEnumerationName(enumName, value) {
+  const enumeration = getFieldTypeEnumeration(enumName)
+  return enumeration && enumeration.value2name[value]
+}
+
+function lookupFieldTypeEnumerationBits(enumName, value) {
+  const enumeration = getFieldTypeEnumeration(enumName)
+  return enumeration && enumeration.value2bits[value]
+}
+
+function lookupFieldTypeEnumerationValue(enumName, name) {
+  const enumeration = getFieldTypeEnumeration(enumName)
+  return enumeration && enumeration.name2value[name]
+}
+
 function lookupBitEnumerationName(enumName, value) {
   const enumeration = getBitEnumeration(enumName)
   return enumeration && enumeration.value2name[value]
@@ -101,6 +139,7 @@ function organizeEnumerations(enums) {
 }
 
 const lookupEnumerations = organizeEnumerations(pgns.LookupEnumerations)
+const lookupFieldTypeEnumerations = organizeEnumerations(pgns.LookupFieldTypeEnumerations)
 const lookupBitEnumerations = organizeEnumerations(pgns.LookupBitEnumerations)
 const organizedPGNs = organizePGNs()
 const getPgn = pgn => organizedPGNs[pgn]
@@ -113,6 +152,9 @@ module.exports = {
   pgns: organizedPGNs,
   lookupEnumerationName,
   lookupEnumerationValue,
+  lookupFieldTypeEnumerationName,
+  lookupFieldTypeEnumerationValue,
+  lookupFieldTypeEnumerationBits,
   lookupBitEnumerationName,
   lookupBitEnumerationValue,
   addCustomPgns: (pgns, setter) => {

package/lib/toPgn.js

@@ -15,7 +15,7 @@
  */
 
 const { getField } = require('./fromPgn')
-const { pgns, getCustomPgn, lookupEnumerationValue, lookupBitEnumerationName } = require('./pgns')
+const { pgns, getCustomPgn, lookupEnumerationValue, lookupFieldTypeEnumerationValue, lookupBitEnumerationName, lookupFieldTypeEnumerationBits } = require('./pgns')
 const _ = require('lodash')
 const BitStream = require('bit-buffer').BitStream
 const Int64LE = require('int64-buffer').Int64LE
@@ -95,7 +95,7 @@ function toPgn(data) {
         RepeatingFields = pgnData.RepeatingFieldSet1Size ? pgnData.RepeatingFieldSet1Size : 0
       }
     }
-    writeField(bs, pgn_number, field, data, value)
+    writeField(bs, pgn_number, field, data, value, fields)
   }
 
   if ( data.list ) {
@@ -104,7 +104,7 @@ function toPgn(data) {
         var field = fields[pgnData.Fields.length-RepeatingFields+index]
         var value = repeat[field.Name];
 
-        writeField(bs, pgn_number, field, data, value)
+        writeField(bs, pgn_number, field, data, value, fields)
       }
     })
   }
@@ -147,11 +147,15 @@ function dumpWritten(bs, field, startPos, value) {
   console.log(string + `] ${value}`)
 }
 
-function writeField(bs, pgn_number, field, data, value, bitLength) {
+function writeField(bs, pgn_number, field, data, value, fields, bitLength) {
   var startPos = bs.byteIndex
 
   if ( _.isUndefined(bitLength) ) {
-    bitLength = field.BitLength
+    if ( field.BitLengthVariable && field.FieldType === "KEY_VALUE" ) {
+      bitLength = lookupKeyBitLength(data, fields)
+    } else {
+      bitLength = field.BitLength
+    }
   }
 
   // console.log(`${field.Name}:${value}(${bitLength}-${field.Resolution})`)
@@ -204,7 +208,7 @@ function writeField(bs, pgn_number, field, data, value, bitLength) {
       }
 
       if ( field.FieldType === 'VARIABLE' ) { 
-        writeVariableLengthField(bs, pgn_number, data, field, value)
+        writeVariableLengthField(bs, pgn_number, data, field, value, fields)
       } else if ( _.isBuffer(value) ) {
         value.copy(bs.view.buffer, bs.byteIndex)
         bs.byteIndex += value.length
@@ -259,21 +263,37 @@ function writeField(bs, pgn_number, field, data, value, bitLength) {
   //dumpWritten(bs, field, startPos, value)
 }
 
-function writeVariableLengthField(bs, pgn_number, pgn, field, value) {
+  function writeVariableLengthField(bs, pgn_number, pgn, field, value, fields) {
   var refField = getField(pgn.PGN, bs.view.buffer[bs.byteIndex-1]-1, pgn)
 
   if ( refField ) {
     var bits = (refField.BitLength + 7) & ~7; // Round # of bits in field refField up to complete bytes: 1->8, 7->8, 8->8 etc.
 
-    return writeField(bs, pgn_number, refField, pgn, value, bits)
+    return writeField(bs, pgn_number, refField, pgn, value, fields, bits)
   }
 }
 
 function lookup(field, stringValue) {
-  var res = lookupEnumerationValue(field.LookupEnumeration, stringValue)
+  var res
+  if ( field.LookupEnumeration ) {
+    res = lookupEnumerationValue(field.LookupEnumeration, stringValue)
+  } else {
+    res = lookupFieldTypeEnumerationValue(field.LookupFieldTypeEnumeration, stringValue)
+  }
   return _.isUndefined(res) ? stringValue : res
 }
 
+function lookupKeyBitLength(data, fields)
+{
+  let field = fields.find(field => (field.Name === 'Key'))
+
+  let val = data['Key']
+  if ( typeof val === 'string' ) {
+    val = lookupFieldTypeEnumerationValue(field.LookupFieldTypeEnumeration, val)
+  }
+  return lookupFieldTypeEnumerationBits(field.LookupFieldTypeEnumeration, val)
+}
+
 function isDefined(value) {
   return typeof value !== 'undefined' && value != null
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canboat/canboatjs",
-  "version": "2.4.5",
+  "version": "2.5.0",
   "description": "Native javascript version of canboat",
   "main": "index.js",
   "scripts": {