Refactor DbgpConnection chunk buffering

Save chunks in an array instead of overwriting the buffer everytime

Author: felixfbecker

src/dbgp.ts

@@ -22,15 +22,15 @@ export abstract class DbgpConnection {
 
     private _socket: net.Socket;
     private _parsingState: ParsingState;
-    private _dataLengthBuffer: Buffer;
-    private _responseBuffer: Buffer;
+    private _chunksDataLength: number;
+    private _chunks: Buffer[];
     private _dataLength: number;
 
     constructor(socket: net.Socket) {
         this._socket = socket;
         this._parsingState = ParsingState.DataLength;
-        this._dataLengthBuffer = new Buffer(0);
-        this._responseBuffer = new Buffer(0);
+        this._chunksDataLength = 0;
+        this._chunks = [];
         socket.on('data', (data: Buffer) => this._handleDataChunk(data));
     }
 
@@ -43,8 +43,9 @@ export abstract class DbgpConnection {
             if (nullByteIndex !== -1) {
                 // YES -> we received the data length and are ready to receive the response
                 this._dataLength = parseInt(iconv.decode(data.slice(0, nullByteIndex), ENCODING));
-                // reset buffer
-                this._dataLengthBuffer = new Buffer(0);
+                // reset buffered chunks
+                this._chunks = [];
+                this._chunksDataLength = 0;
                 // switch to response parsing state
                 this._parsingState = ParsingState.Response;
                 // if data contains more info (except the NULL byte)
@@ -54,20 +55,24 @@ export abstract class DbgpConnection {
                     this._handleDataChunk(rest);
                 }
             } else {
-                // NO -> this is only part of the data length. We buffer it and wait for the next data event
-                this._dataLengthBuffer = Buffer.concat([this._dataLengthBuffer, data], this._dataLengthBuffer.length + data.length);
+                // NO -> this is only part of the data length. We wait for the next data event
+                this._chunks.push(data);
+                this._chunksDataLength += data.length;
             }
         } else if (this._parsingState === ParsingState.Response) {
             // does the new data together with the buffered data add up to the data length?
-            if (this._responseBuffer.length + data.length >= this._dataLength) {
+            if (this._chunksDataLength + data.length >= this._dataLength) {
                 // YES -> we received the whole response
-                const lastResponsePiece = data.slice(0, this._dataLength - this._responseBuffer.length);
                 // append the last piece of the response
-                const response = Buffer.concat([this._responseBuffer, lastResponsePiece], this._dataLength);
+                const lastResponsePiece = data.slice(0, this._dataLength - this._chunksDataLength);
+                this._chunks.push(lastResponsePiece);
+                this._chunksDataLength += data.length;
+                const response = Buffer.concat(this._chunks, this._chunksDataLength);
                 // call response handler
                 this.handleResponse(parseResponse(response));
                 // reset buffer
-                this._responseBuffer = new Buffer(0);
+                this._chunks = [];
+                this._chunksDataLength = 0;
                 // switch to data length parsing state
                 this._parsingState = ParsingState.DataLength;
                 // if data contains more info (except the NULL byte)
@@ -78,7 +83,8 @@ export abstract class DbgpConnection {
                 }
             } else {
                 // NO -> this is not the whole response yet. We buffer it and wait for the next data event.
-                this._responseBuffer = Buffer.concat([this._responseBuffer, data], this._responseBuffer.length + data.length);
+                this._chunks.push(data);
+                this._chunksDataLength += data.length;
             }
         }
     }