refactored unpack method

Author: lutovich

src/v1/internal/connector.js

@@ -480,7 +480,6 @@ class Connection {
     const serverVersion = metadata ? metadata.server : null;
     if (!this.server.version) {
       this.server.version = serverVersion;
-
       const version = ServerVersion.fromString(serverVersion);
       if (version.compareTo(VERSION_3_2_0) < 0) {
         this._packer.disableByteArrays();

src/v1/internal/packstream.js

@@ -316,54 +316,65 @@ class Unpacker {
     this.structMappers = {};
   }
 
-  unpackList (size, buffer) {
-    let value = [];
-    for(let i = 0; i < size; i++) {
-      value.push( this.unpack( buffer ) );
-    } 
-    return value;
-  }
+  unpack(buffer) {
+    const marker = buffer.readUInt8();
+    const markerHigh = marker & 0xF0;
+    const markerLow = marker & 0x0F;
 
-  unpackBytes(size, buffer) {
-    const value = new Int8Array(size);
-    for (let i = 0; i < size; i++) {
-      value[i] = buffer.readInt8();
+    if (marker == NULL) {
+      return null;
     }
-    return value;
-  }
 
-  unpackMap (size, buffer) {
-    let value = {};
-    for(let i = 0; i < size; i++) {
-      let key = this.unpack(buffer);
-      value[key] = this.unpack(buffer);
+    const boolean = this._unpackBoolean(marker);
+    if (boolean !== null) {
+      return boolean;
     }
-    return value;
-  }
 
-  unpackStruct (size, buffer) {
-    let signature = buffer.readUInt8();
-    let mapper = this.structMappers[signature];
-    if( mapper ) {
-      return mapper( this, buffer );
-    } else {
-      let value = new Structure(signature, []);
-      for(let i = 0; i < size; i++) {
-        value.fields.push(this.unpack(buffer));
-      } 
-      return value;
+    const number = this._unpackNumber(marker, buffer);
+    if (number !== null) {
+      return number;
+    }
+
+    const string = this._unpackString(marker, markerHigh, markerLow, buffer);
+    if (string !== null) {
+      return string;
+    }
+
+    const list = this._unpackList(marker, markerHigh, markerLow, buffer);
+    if (list !== null) {
+      return list;
     }
+
+    const byteArray = this._unpackByteArray(marker, buffer);
+    if (byteArray !== null) {
+      return byteArray;
+    }
+
+    const map = this._unpackMap(marker, markerHigh, markerLow, buffer);
+    if (map !== null) {
+      return map;
+    }
+
+    const struct = this._unpackStruct(marker, markerHigh, markerLow, buffer);
+    if (struct !== null) {
+      return struct;
+    }
+
+    throw newError('Unknown packed value with marker ' + marker.toString(16));
   }
 
-  unpack ( buffer ) {
-    let marker = buffer.readUInt8();
-    if (marker == NULL) {
-      return null;
-    } else if (marker == TRUE) {
+  _unpackBoolean(marker) {
+    if (marker == TRUE) {
       return true;
     } else if (marker == FALSE) {
       return false;
-    } else if (marker == FLOAT_64) {
+    } else {
+      return null;
+    }
+  }
+
+  _unpackNumber(marker, buffer) {
+    if (marker == FLOAT_64) {
       return buffer.readFloat64();
     } else if (marker >= 0 && marker < 128) {
       return int(marker);
@@ -378,55 +389,122 @@ class Unpacker {
       return int(b);
     } else if (marker == INT_64) {
       let high = buffer.readInt32();
-      let low  = buffer.readInt32();
-      return new Integer( low, high );
+      let low = buffer.readInt32();
+      return new Integer(low, high);
+    } else {
+      return null;
+    }
+  }
+
+  _unpackString(marker, markerHigh, markerLow, buffer) {
+    if (markerHigh == TINY_STRING) {
+      return utf8.decode(buffer, markerLow);
     } else if (marker == STRING_8) {
-      return utf8.decode( buffer, buffer.readUInt8());
+      return utf8.decode(buffer, buffer.readUInt8());
     } else if (marker == STRING_16) {
-      return utf8.decode( buffer, buffer.readUInt16() );
+      return utf8.decode(buffer, buffer.readUInt16());
     } else if (marker == STRING_32) {
-      return utf8.decode( buffer, buffer.readUInt32() );
+      return utf8.decode(buffer, buffer.readUInt32());
+    } else {
+      return null;
+    }
+  }
+
+  _unpackList(marker, markerHigh, markerLow, buffer) {
+    if (markerHigh == TINY_LIST) {
+      return this._unpackListWithSize(markerLow, buffer);
     } else if (marker == LIST_8) {
-      return this.unpackList(buffer.readUInt8(), buffer);
+      return this._unpackListWithSize(buffer.readUInt8(), buffer);
     } else if (marker == LIST_16) {
-      return this.unpackList(buffer.readUInt16(), buffer);
+      return this._unpackListWithSize(buffer.readUInt16(), buffer);
     } else if (marker == LIST_32) {
-      return this.unpackList(buffer.readUInt32(), buffer);
-    } else if (marker == BYTES_8) {
-      return this.unpackBytes(buffer.readUInt8(), buffer);
+      return this._unpackListWithSize(buffer.readUInt32(), buffer);
+    } else {
+      return null;
+    }
+  }
+
+  _unpackListWithSize(size, buffer) {
+    let value = [];
+    for (let i = 0; i < size; i++) {
+      value.push(this.unpack(buffer));
+    }
+    return value;
+  }
+
+  _unpackByteArray(marker, buffer) {
+    if (marker == BYTES_8) {
+      return this._unpackByteArrayWithSize(buffer.readUInt8(), buffer);
     } else if (marker == BYTES_16) {
-      return this.unpackBytes(buffer.readUInt16(), buffer);
+      return this._unpackByteArrayWithSize(buffer.readUInt16(), buffer);
     } else if (marker == BYTES_32) {
-      return this.unpackBytes(buffer.readUInt32(), buffer);
+      return this._unpackByteArrayWithSize(buffer.readUInt32(), buffer);
+    } else {
+      return null;
+    }
+  }
+
+  _unpackByteArrayWithSize(size, buffer) {
+    const value = new Int8Array(size);
+    for (let i = 0; i < size; i++) {
+      value[i] = buffer.readInt8();
+    }
+    return value;
+  }
+
+  _unpackMap(marker, markerHigh, markerLow, buffer) {
+    if (markerHigh == TINY_MAP) {
+      return this._unpackMapWithSize(markerLow, buffer);
     } else if (marker == MAP_8) {
-      return this.unpackMap(buffer.readUInt8(), buffer);
+      return this._unpackMapWithSize(buffer.readUInt8(), buffer);
     } else if (marker == MAP_16) {
-      return this.unpackMap(buffer.readUInt16(), buffer);
+      return this._unpackMapWithSize(buffer.readUInt16(), buffer);
     } else if (marker == MAP_32) {
-      return this.unpackMap(buffer.readUInt32(), buffer);
+      return this._unpackMapWithSize(buffer.readUInt32(), buffer);
+    } else {
+      return null;
+    }
+  }
+
+  _unpackMapWithSize(size, buffer) {
+    let value = {};
+    for (let i = 0; i < size; i++) {
+      let key = this.unpack(buffer);
+      value[key] = this.unpack(buffer);
+    }
+    return value;
+  }
+
+  _unpackStruct(marker, markerHigh, markerLow, buffer) {
+    if (markerHigh == TINY_STRUCT) {
+      return this._unpackStructWithSize(markerLow, buffer);
     } else if (marker == STRUCT_8) {
-      return this.unpackStruct(buffer.readUInt8(), buffer);
+      return this._unpackStructWithSize(buffer.readUInt8(), buffer);
     } else if (marker == STRUCT_16) {
-      return this.unpackStruct(buffer.readUInt16(), buffer);
-    }
-    let markerHigh = marker & 0xF0;
-    let markerLow = marker & 0x0F;
-    if (markerHigh == 0x80) {
-      return utf8.decode( buffer, markerLow );
-    } else if (markerHigh == 0x90) {
-      return this.unpackList(markerLow, buffer);
-    } else if (markerHigh == 0xA0) {
-      return this.unpackMap(markerLow, buffer);
-    } else if (markerHigh == 0xB0) {
-      return this.unpackStruct(markerLow, buffer);
+      return this._unpackStructWithSize(buffer.readUInt16(), buffer);
+    } else {
+      return null;
+    }
+  }
+
+  _unpackStructWithSize(size, buffer) {
+    let signature = buffer.readUInt8();
+    let mapper = this.structMappers[signature];
+    if (mapper) {
+      return mapper(this, buffer);
     } else {
-      throw newError("Unknown packed value with marker " + marker.toString(16));
+      let value = new Structure(signature, []);
+      for (let i = 0; i < size; i++) {
+        value.fields.push(this.unpack(buffer));
+      }
+      return value;
     }
   }
+
 }
 
 export {
   Packer,
   Unpacker,
   Structure
-}
+};