updated the ByteBufferPclCommandReader to properly break up compound commands; updated the PclUtil to be more performant when trying to determine if an escape sequence expecting binary data

Author: born2snipe

src/main/java/pcl4j/io/ByteBufferPclCommandReader.java

@@ -17,6 +17,8 @@
 
 import java.io.ByteArrayOutputStream;
 import java.nio.ByteBuffer;
+import java.util.LinkedList;
+import java.util.Queue;
 
 /**
  * A PclCommandReader implementation using the java.nio.ByteBuffer
@@ -26,6 +28,7 @@ public class ByteBufferPclCommandReader implements PclCommandReader {
     private PclUtil pclUtil = new PclUtil();
     protected ByteBuffer buffer;
     private long filePosition = 0;
+    private Queue<PclCommand> queuedCommands = new LinkedList<PclCommand>();
 
     public ByteBufferPclCommandReader(byte[] entirePclFileContents) {
         this(ByteBuffer.wrap(entirePclFileContents));
@@ -45,56 +48,107 @@ public void skip(long numberOfBytesToSkip) throws PclCommandReaderException {
     }
 
     public PclCommand nextCommand() throws PclCommandReaderException {
+        if (commandsAreQueued()) {
+            return queuedCommands.remove();
+        }
+
         if (isFileEmpty() || isEOF()) {
             return null;
         }
 
         long commandPosition = filePosition;
         byte currentByte = readNextByte();
         if (pclUtil.isEscape(currentByte)) {
-            return pclCommand(commandPosition);
+            pclCommand(commandPosition);
+            return queuedCommands.remove();
         } else {
             return textCommand(commandPosition, currentByte);
         }
     }
 
-    private PclCommand pclCommand(long commandPosition) {
-        PclCommand command = null;
+    private void pclCommand(long initialCommandPosition) {
+        long commandPosition = initialCommandPosition;
+        ByteArrayOutputStream commandPrefixBytes = new ByteArrayOutputStream();
+        commandPrefixBytes.write(PclUtil.ESCAPE);
         ByteArrayOutputStream commandData = new ByteArrayOutputStream();
         commandData.write(PclUtil.ESCAPE);
+
         boolean isFirstRead = true;
+        boolean captureByte = true;
+        boolean escapeSequenceComplete = false;
+        boolean groupByteFound = false;
+        boolean parameterByteFound = false;
         boolean commandCompleted = false;
+        boolean compressedCommand = false;
 
-        while (!commandCompleted && isNotEOF()) {
+        while (!escapeSequenceComplete && isNotEOF()) {
             byte currentByte = readNextByte();
-            commandData.write(currentByte);
 
-            if (isFirstRead && pclUtil.is2ByteCommandOperator(currentByte)) {
+            if (!groupByteFound) {
+                commandPrefixBytes.write(currentByte);
+            }
+
+
+            if (isTwoByteCommand(isFirstRead, currentByte)) {
+                escapeSequenceComplete = true;
+            } else if (!parameterByteFound) {
+                parameterByteFound = pclUtil.isParameterizedCharacter(currentByte);
+            } else if (!groupByteFound) {
+                groupByteFound = pclUtil.isGroupCharacter(currentByte);
+            } else if (groupByteFound && pclUtil.isParameterCharacter(currentByte) && isNextByteNotAnEscapeByte()) {
                 commandCompleted = true;
+                compressedCommand = true;
+                currentByte = pclUtil.changeParameterToTerminator(currentByte);
             } else if (pclUtil.isTermination(currentByte)) {
-                if (pclUtil.isCommandExpectingData(commandData.toByteArray())) {
+                escapeSequenceComplete = true;
+            } else if (pclUtil.isEscape(currentByte)) {
+                undoRead();
+                escapeSequenceComplete = true;
+                captureByte = false;
+            }
+
+            if (captureByte) {
+                commandData.write(currentByte);
+            }
+
+            if (escapeSequenceComplete || commandCompleted || isLastByteInFile()) {
+                if (!isFirstRead && pclUtil.isCommandExpectingData(commandData.toByteArray())) {
                     captureBinaryData(commandData);
                 }
-                commandCompleted = true;
+
+                queuedCommands.add(pclCommandFactory.build(commandPosition, commandData.toByteArray()));
+                commandPosition = filePosition;
+
+                if (compressedCommand) {
+                    commandData.reset();
+                    commandData.write(commandPrefixBytes.toByteArray(), 0, 3);
+                    commandCompleted = false;
+                }
             }
 
             isFirstRead = false;
         }
+    }
 
+    private boolean isLastByteInFile() {
         if (isEOF()) {
-            commandCompleted = true;
+            return true;
         }
 
-        if (commandCompleted) {
-            command = pclCommandFactory.build(commandPosition, commandData.toByteArray());
-        }
+        return buffer.position() == buffer.capacity();
+    }
 
-        return command;
+    private boolean isNextByteNotAnEscapeByte() {
+        return !isNextByteAnEscapeByte();
+    }
+
+    private boolean isTwoByteCommand(boolean firstRead, byte currentByte) {
+        return firstRead && pclUtil.is2ByteCommandOperator(currentByte);
     }
 
     private void captureBinaryData(ByteArrayOutputStream commandData) {
-        String valueAsString = new String(pclUtil.getValue(commandData.toByteArray())).replaceAll("\\.[0-9]*", "");
-        Integer numberOfBytesToRead = Integer.valueOf(valueAsString);
+        String valueAsString = new String(pclUtil.getValue(commandData.toByteArray())).replaceAll("\\+|\\.[0-9]*|\\s+", "");
+        Integer numberOfBytesToRead = valueAsString.length() == 0 ? 0 : Integer.valueOf(valueAsString);
         int count = 0;
         while (isNotEOF() && count < numberOfBytesToRead) {
             commandData.write(readNextByte());
@@ -149,7 +203,12 @@ private boolean isFileEmpty() {
         return buffer.capacity() == 0;
     }
 
+    private boolean commandsAreQueued() {
+        return queuedCommands.size() > 0;
+    }
+
     public void close() {
 
     }
+
 }

src/main/java/pcl4j/io/PclCommandBuilder.java

@@ -132,6 +132,7 @@ public PclCommandBuilder copy() {
         child.value = value;
         child.terminator = terminator;
         child.binaryData = binaryData;
+        child.validate = validate;
         return child;
     }
 

src/main/java/pcl4j/io/PclUtil.java

@@ -16,15 +16,13 @@
 
 import java.io.ByteArrayOutputStream;
 import java.util.Arrays;
-import java.util.List;
 
 /**
  * Utility class for checking for the magic PCL bytes
  */
 public class PclUtil {
-    private static final List<String> BINARY_DATA_COMMANDS = Arrays.asList(
-            "*c#E", ")s#W", "(s#W", "(f#W", "&n#W", "*b#W", "*g#W", "*b#Y", "*b#V", "*v#W", "*l#W", "*o#W", "*m#W", "&p#X"
-    );
+    private static final String[] BINARY_DATA_COMMANDS = {"*c#E", ")s#W", "(s#W", "(f#W", "&n#W", "*b#W", "*g#W", "*b#Y", "*b#V", "*v#W", "*l#W", "*o#W", "*m#W", "&p#X"};
+    private static final int[] BINARY_DATA_COMMANDS_HASHES = initializeBinaryDataHashes();
 
     public static final int PARAMETERIZED_BYTE_POSITION = 1;
     public static final int GROUP_BYTE_POSITION = 2;
@@ -246,7 +244,7 @@ public byte[] getValue(byte[] commandBytes) {
         } else {
             for (int i = VALUE_BYTE_START_POSITION; i < commandBytes.length; i++) {
                 byte currentByte = commandBytes[i];
-                if (isTermination(currentByte)) {
+                if (currentByte == getTerminatorByte(commandBytes)) {
                     break;
                 } else if (isParameterCharacter(currentByte)) {
                     output.reset();
@@ -266,12 +264,13 @@ public byte[] getValue(byte[] commandBytes) {
      *         false - is not expecting binary data
      */
     public boolean isCommandExpectingData(byte[] commandBytes) {
-        StringBuilder pattern = new StringBuilder();
-        pattern.append((char) commandBytes[PARAMETERIZED_BYTE_POSITION]);
-        pattern.append((char) commandBytes[GROUP_BYTE_POSITION]);
-        pattern.append("#");
-        pattern.append((char) getTerminatorByte(commandBytes));
-        return BINARY_DATA_COMMANDS.contains(pattern.toString());
+        byte[] commandId = {
+                commandBytes[PARAMETERIZED_BYTE_POSITION],
+                commandBytes[GROUP_BYTE_POSITION],
+                '#',
+                (byte) Character.toUpperCase((char) getTerminatorByte(commandBytes))
+        };
+        return Arrays.binarySearch(BINARY_DATA_COMMANDS_HASHES, Arrays.hashCode(commandId)) > -1;
     }
 
     private void requiresParameterizedCommand(PclCommand command) {
@@ -287,4 +286,13 @@ private boolean is2ByteCommand(PclCommand command) {
     private byte getTerminatorByte(byte[] commandBytes) {
         return commandBytes[commandBytes.length - 1];
     }
+
+    private static int[] initializeBinaryDataHashes() {
+        int[] hashes = new int[BINARY_DATA_COMMANDS.length];
+        for (int i = 0; i < hashes.length; i++) {
+            hashes[i] = Arrays.hashCode(BINARY_DATA_COMMANDS[i].getBytes());
+        }
+        Arrays.sort(hashes);
+        return hashes;
+    }
 }