Merge pull request #11269 from thingsboard/tbel_add_some_methods_bytesToInt_Long

TBEL: added parameter length to methods parseBytesToNumber

common/script/script-api/src/main/java/org/thingsboard/script/api/tbel/TbUtils.java

@@ -130,10 +130,18 @@ public class TbUtils {
                 String.class)));
         parserConfig.addImport("parseHexToInt", new MethodStub(TbUtils.class.getMethod("parseHexToInt",
                 String.class, boolean.class)));
+        parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
+                List.class)));
+        parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
+                List.class, int.class)));
         parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
                 List.class, int.class, int.class)));
         parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
                 List.class, int.class, int.class, boolean.class)));
+        parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
+                byte[].class)));
+        parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
+                byte[].class, int.class)));
         parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
                 byte[].class, int.class, int.class)));
         parserConfig.addImport("parseBytesToInt", new MethodStub(TbUtils.class.getMethod("parseBytesToInt",
@@ -146,10 +154,18 @@ public class TbUtils {
                 String.class)));
         parserConfig.addImport("parseHexToLong", new MethodStub(TbUtils.class.getMethod("parseHexToLong",
                 String.class, boolean.class)));
+        parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
+                List.class)));
+        parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
+                List.class, int.class)));
         parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
                 List.class, int.class, int.class)));
         parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
                 List.class, int.class, int.class, boolean.class)));
+        parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
+                byte[].class)));
+        parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
+                byte[].class, int.class)));
         parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
                 byte[].class, int.class, int.class)));
         parserConfig.addImport("parseBytesToLong", new MethodStub(TbUtils.class.getMethod("parseBytesToLong",
@@ -163,17 +179,21 @@ public class TbUtils {
         parserConfig.addImport("parseHexToFloat", new MethodStub(TbUtils.class.getMethod("parseHexToFloat",
                 String.class, boolean.class)));
         parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
-                byte[].class, int.class)));
+                List.class)));
         parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
                 List.class, int.class)));
         parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
-                byte[].class, int.class, boolean.class)));
+                List.class, int.class, int.class)));
-        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
-                List.class, int.class, boolean.class)));
-        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
-                byte[].class, int.class, int.class, boolean.class)));
         parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
                 List.class, int.class, int.class, boolean.class)));
+        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
+                byte[].class)));
+        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
+                byte[].class, int.class)));
+        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
+                byte[].class, int.class, int.class)));
+        parserConfig.addImport("parseBytesToFloat", new MethodStub(TbUtils.class.getMethod("parseBytesToFloat",
+                byte[].class, int.class, int.class, boolean.class)));
         parserConfig.addImport("parseLittleEndianHexToDouble", new MethodStub(TbUtils.class.getMethod("parseLittleEndianHexToDouble",
                 String.class)));
         parserConfig.addImport("parseBigEndianHexToDouble", new MethodStub(TbUtils.class.getMethod("parseBigEndianHexToDouble",
@@ -183,17 +203,21 @@ public class TbUtils {
         parserConfig.addImport("parseHexToDouble", new MethodStub(TbUtils.class.getMethod("parseHexToDouble",
                 String.class, boolean.class)));
         parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
-                byte[].class, int.class)));
+                List.class)));
-        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
-                byte[].class, int.class, boolean.class)));
-        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
-                byte[].class, int.class, int.class, boolean.class)));
         parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
                 List.class, int.class)));
         parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
-                List.class, int.class, boolean.class)));
+                List.class, int.class, int.class)));
         parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
                 List.class, int.class, int.class, boolean.class)));
+        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
+                byte[].class)));
+        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
+                byte[].class, int.class)));
+        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
+                byte[].class, int.class, int.class)));
+        parserConfig.addImport("parseBytesToDouble", new MethodStub(TbUtils.class.getMethod("parseBytesToDouble",
+                byte[].class, int.class, int.class, boolean.class)));
         parserConfig.addImport("toFixed", new MethodStub(TbUtils.class.getMethod("toFixed",
                 double.class, int.class)));
         parserConfig.addImport("toFixed", new MethodStub(TbUtils.class.getMethod("toFixed",
@@ -740,16 +764,28 @@ public class TbUtils {
         return Base64.getDecoder().decode(input);
     }
 
+    public static int parseBytesToInt(List<Byte> data) {
+        return parseBytesToInt(Bytes.toArray(data));
+    }
+
+    public static int parseBytesToInt(List<Byte> data, int offset) {
+        return parseBytesToInt(Bytes.toArray(data), offset);
+    }
+
     public static int parseBytesToInt(List<Byte> data, int offset, int length) {
-        return parseBytesToInt(data, offset, length, true);
+        return parseBytesToInt(Bytes.toArray(data), offset, length);
     }
 
     public static int parseBytesToInt(List<Byte> data, int offset, int length, boolean bigEndian) {
-        final byte[] bytes = new byte[data.size()];
+        return parseBytesToInt(Bytes.toArray(data), offset, length, bigEndian);
-        for (int i = 0; i < bytes.length; i++) {
-            bytes[i] = data.get(i);
     }
-        return parseBytesToInt(bytes, offset, length, bigEndian);
+
+    public static int parseBytesToInt(byte[] data) {
+        return parseBytesToInt(data, 0);
+    }
+
+    public static int parseBytesToInt(byte[] data, int offset) {
+        return parseBytesToInt(data, offset, BYTES_LEN_INT_MAX);
     }
 
     public static int parseBytesToInt(byte[] data, int offset, int length) {
@@ -776,16 +812,28 @@ public class TbUtils {
         return bb.getInt();
     }
 
+    public static long parseBytesToLong(List<Byte> data) {
+        return parseBytesToLong(Bytes.toArray(data));
+    }
+
+    public static long parseBytesToLong(List<Byte> data, int offset) {
+        return parseBytesToLong(Bytes.toArray(data), offset);
+    }
+
     public static long parseBytesToLong(List<Byte> data, int offset, int length) {
-        return parseBytesToLong(data, offset, length, true);
+        return parseBytesToLong(Bytes.toArray(data), offset, length);
     }
 
     public static long parseBytesToLong(List<Byte> data, int offset, int length, boolean bigEndian) {
-        final byte[] bytes = new byte[data.size()];
+        return parseBytesToLong(Bytes.toArray(data), offset, length, bigEndian);
-        for (int i = 0; i < bytes.length; i++) {
-            bytes[i] = data.get(i);
     }
-        return parseBytesToLong(bytes, offset, length, bigEndian);
+
+    public static long parseBytesToLong(byte[] data) {
+        return parseBytesToLong(data, 0);
+    }
+
+    public static long parseBytesToLong(byte[] data, int offset) {
+        return parseBytesToLong(data, offset, BYTES_LEN_LONG_MAX);
     }
 
     public static long parseBytesToLong(byte[] data, int offset, int length) {
@@ -812,31 +860,42 @@ public class TbUtils {
         return bb.getLong();
     }
 
-    public static float parseBytesToFloat(byte[] data, int offset) {
+    public static float parseBytesToFloat(List data) {
-        return parseBytesToFloat(data, offset, true);
+        return parseBytesToFloat(Bytes.toArray(data), 0);
     }
 
     public static float parseBytesToFloat(List data, int offset) {
-        return parseBytesToFloat(data, offset, true);
+        return parseBytesToFloat(Bytes.toArray(data), offset, BYTES_LEN_INT_MAX);
     }
 
-    public static float parseBytesToFloat(List data, int offset, boolean bigEndian) {
+    public static float parseBytesToFloat(List data, int offset, int length) {
-        return parseBytesToFloat(Bytes.toArray(data), offset, bigEndian);
+        return parseBytesToFloat(Bytes.toArray(data), offset, length, true);
-    }
-
-    public static float parseBytesToFloat(byte[] data, int offset, boolean bigEndian) {
-        return parseBytesToFloat(data, offset, BYTES_LEN_INT_MAX, bigEndian);
     }
 
     public static float parseBytesToFloat(List data, int offset, int length, boolean bigEndian) {
         return parseBytesToFloat(Bytes.toArray(data), offset, length, bigEndian);
     }
 
+    public static float parseBytesToFloat(byte[] data) {
+        return parseBytesToFloat(data, 0);
+    }
+
+    public static float parseBytesToFloat(byte[] data, int offset) {
+        return parseBytesToFloat(data, offset, BYTES_LEN_INT_MAX);
+    }
+
+    public static float parseBytesToFloat(byte[] data, int offset, int length) {
+        return parseBytesToFloat(data, offset, length, true);
+    }
+
     public static float parseBytesToFloat(byte[] data, int offset, int length, boolean bigEndian) {
-        byte[] bytesToNumber = prepareBytesToNumber(data, offset, length, bigEndian);
         if (length > BYTES_LEN_INT_MAX) {
             throw new IllegalArgumentException("Length: " + length + " is too large. Maximum " + BYTES_LEN_INT_MAX + " bytes is allowed!");
         }
+        if (offset + length > data.length) {
+            throw new IllegalArgumentException("Offset: " + offset + " and Length: " + length + " is out of bounds for array with length: " + data.length + "!");
+        }
+        byte[] bytesToNumber = prepareBytesToNumber(data, offset, length, bigEndian);
         if (bytesToNumber.length < BYTES_LEN_INT_MAX) {
             byte[] extendedBytes = new byte[BYTES_LEN_INT_MAX];
             Arrays.fill(extendedBytes, (byte) 0);
@@ -847,37 +906,48 @@ public class TbUtils {
         if (!Float.isNaN(floatValue)) {
             return floatValue;
         } else {
-            long longValue = parseBytesToLong(bytesToNumber, offset, length, bigEndian);
+            long longValue = parseBytesToLong(bytesToNumber, 0, BYTES_LEN_INT_MAX);
             BigDecimal bigDecimalValue = new BigDecimal(longValue);
             return bigDecimalValue.floatValue();
         }
     }
 
-    public static double parseBytesToDouble(byte[] data, int offset) {
+    public static double parseBytesToDouble(List data) {
-        return parseBytesToDouble(data, offset, true);
+        return parseBytesToDouble(Bytes.toArray(data));
     }
 
     public static double parseBytesToDouble(List data, int offset) {
-        return parseBytesToDouble(data, offset, true);
+        return parseBytesToDouble(Bytes.toArray(data), offset);
     }
 
-    public static double parseBytesToDouble(List data, int offset, boolean bigEndian) {
+    public static double parseBytesToDouble(List data, int offset, int length) {
-        return parseBytesToDouble(Bytes.toArray(data), offset, bigEndian);
+        return parseBytesToDouble(Bytes.toArray(data), offset, length);
     }
 
     public static double parseBytesToDouble(List data, int offset, int length, boolean bigEndian) {
         return parseBytesToDouble(Bytes.toArray(data), offset, length, bigEndian);
     }
 
-    public static double parseBytesToDouble(byte[] data, int offset, boolean bigEndian) {
+    public static double parseBytesToDouble(byte[] data) {
-        return parseBytesToDouble(data, offset, BYTES_LEN_LONG_MAX, bigEndian);
+        return parseBytesToDouble(data, 0);
+    }
+
+    public static double parseBytesToDouble(byte[] data, int offset) {
+        return parseBytesToDouble(data, offset, BYTES_LEN_LONG_MAX);
+    }
+
+    public static double parseBytesToDouble(byte[] data, int offset, int length) {
+        return parseBytesToDouble(data, offset, length, true);
     }
 
     public static double parseBytesToDouble(byte[] data, int offset, int length, boolean bigEndian) {
-        byte[] bytesToNumber = prepareBytesToNumber(data, offset, length, bigEndian);
         if (length > BYTES_LEN_LONG_MAX) {
             throw new IllegalArgumentException("Length: " + length + " is too large. Maximum " + BYTES_LEN_LONG_MAX + " bytes is allowed!");
         }
+        if (offset + length > data.length) {
+            throw new IllegalArgumentException("Offset: " + offset + " and Length: " + length + " is out of bounds for array with length: " + data.length + "!");
+        }
+        byte[] bytesToNumber = prepareBytesToNumber(data, offset, length, bigEndian);
         if (bytesToNumber.length < BYTES_LEN_LONG_MAX) {
             byte[] extendedBytes = new byte[BYTES_LEN_LONG_MAX];
             Arrays.fill(extendedBytes, (byte) 0);

common/script/script-api/src/test/java/org/thingsboard/script/api/tbel/TbUtilsTest.java

@@ -278,11 +278,11 @@ public class TbUtilsTest {
     public void parseBytesToFloat() {
         byte[] floatValByte = {65, -22, 98, -52};
         Assertions.assertEquals(0, Float.compare(floatVal, TbUtils.parseBytesToFloat(floatValByte, 0)));
-        Assertions.assertEquals(0, Float.compare(floatValRev, TbUtils.parseBytesToFloat(floatValByte, 0, false)));
+        Assertions.assertEquals(0, Float.compare(floatValRev, TbUtils.parseBytesToFloat(floatValByte, 0, 4, false)));
 
         List<Byte> floatValList = Bytes.asList(floatValByte);
         Assertions.assertEquals(0, Float.compare(floatVal, TbUtils.parseBytesToFloat(floatValList, 0)));
-        Assertions.assertEquals(0, Float.compare(floatValRev, TbUtils.parseBytesToFloat(floatValList, 0, false)));
+        Assertions.assertEquals(0, Float.compare(floatValRev, TbUtils.parseBytesToFloat(floatValList, 0, 4, false)));
 
         // 4 294 967 295L == {0xFF, 0xFF, 0xFF, 0xFF}
         floatValByte = new byte[]{-1, -1, -1, -1};
@@ -290,12 +290,12 @@ public class TbUtilsTest {
         float floatExpectedLe = 4.2949673E9f;
         float actualBe = TbUtils.parseBytesToFloat(floatValByte, 0, 4, true);
         Assertions.assertEquals(0, Float.compare(floatExpectedBe, actualBe / 1000000));
-        Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValByte, 0, false)));
+        Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValByte, 0, 4, false)));
 
         floatValList = Bytes.asList(floatValByte);
         actualBe = TbUtils.parseBytesToFloat(floatValList, 0);
         Assertions.assertEquals(0, Float.compare(floatExpectedBe, actualBe / 1000000));
-        Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValList, 0, false)));
+        Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValList, 0, 4, false)));
 
         // 2 143 289 344L == {0x7F, 0xC0, 0x00, 0x00}
         floatValByte = new byte[]{0x7F, (byte) 0xC0, (byte) 0xFF, 0x00};
@@ -306,10 +306,18 @@ public class TbUtilsTest {
         Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValByte, 0, 2, false)));
 
         floatValList = Bytes.asList(floatValByte);
-        floatExpectedLe = 8372479.0f;
+        floatExpectedLe = 4.2908055E9f;
         actualBe = TbUtils.parseBytesToFloat(floatValList, 0);
         Assertions.assertEquals(0, Float.compare(floatExpectedBe, actualBe / 1000000));
         Assertions.assertEquals(0, Float.compare(floatExpectedLe, TbUtils.parseBytesToFloat(floatValList, 0, 3, false)));
+        // "01752B0367FA000500010488 FFFFFFFF FFFFFFFF 33";
+        String intToHexBe = "01752B0367FA000500010488FFFFFFFFFFFFFFFF33";
+        floatExpectedLe = 4294.9673f;
+        floatValList = TbUtils.hexToBytes(ctx, intToHexBe);
+        float actualLe = TbUtils.parseBytesToFloat(floatValList, 12, 4, false);
+        Assertions.assertEquals(0, Float.compare(floatExpectedLe, actualLe / 1000000));
+        actualLe = TbUtils.parseBytesToFloat(floatValList, 12 + 4, 4, false);
+        Assertions.assertEquals(0, Float.compare(floatExpectedLe, actualLe / 1000000));
     }
 
     @Test
@@ -384,11 +392,11 @@ public class TbUtilsTest {
     public void parseBytesToDouble() {
         byte[] doubleValByte = {64, -101, 4, -79, 12, -78, -107, -22};
         Assertions.assertEquals(0, Double.compare(doubleVal, TbUtils.parseBytesToDouble(doubleValByte, 0)));
-        Assertions.assertEquals(0, Double.compare(doubleValRev, TbUtils.parseBytesToDouble(doubleValByte, 0, false)));
+        Assertions.assertEquals(0, Double.compare(doubleValRev, TbUtils.parseBytesToDouble(doubleValByte, 0, 8, false)));
 
         List<Byte> doubleValList = Bytes.asList(doubleValByte);
         Assertions.assertEquals(0, Double.compare(doubleVal, TbUtils.parseBytesToDouble(doubleValList, 0)));
-        Assertions.assertEquals(0, Double.compare(doubleValRev, TbUtils.parseBytesToDouble(doubleValList, 0, false)));
+        Assertions.assertEquals(0, Double.compare(doubleValRev, TbUtils.parseBytesToDouble(doubleValList, 0, 8, false)));
 
         // 4 294 967 295L == {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
         doubleValByte = new byte[]{-1, -1, -1, -1, -1, -1, -1, -1};
@@ -396,11 +404,11 @@ public class TbUtilsTest {
         double doubleExpectedLe = 1.8446744073709552E19d;
         double actualBe = TbUtils.parseBytesToDouble(doubleValByte, 0, 8, true);
         Assertions.assertEquals(0, Double.compare(doubleExpectedBe, actualBe / 1000000000000000L));
-        Assertions.assertEquals(0, Double.compare(doubleExpectedLe, TbUtils.parseBytesToDouble(doubleValByte, 0, false)));
+        Assertions.assertEquals(0, Double.compare(doubleExpectedLe, TbUtils.parseBytesToDouble(doubleValByte, 0, 8, false)));
 
         doubleValList = Bytes.asList(doubleValByte);
         Assertions.assertEquals(0, Double.compare(doubleExpectedBe, TbUtils.parseBytesToDouble(doubleValList, 0) / 1000000000000000L));
-        Assertions.assertEquals(0, Double.compare(doubleExpectedLe, TbUtils.parseBytesToDouble(doubleValList, 0, false)));
+        Assertions.assertEquals(0, Double.compare(doubleExpectedLe, TbUtils.parseBytesToDouble(doubleValList, 0, 8, false)));
 
         doubleValByte = new byte[]{0x7F, (byte) 0xC0, (byte) 0xFF, 0x00, 0x7F, (byte) 0xC0, (byte) 0xFF, 0x00};
         doubleExpectedBe = 2387013.651780523d;