changed encoder to preserve a single buffer, exposed encoder

index.js

@@ -3,5 +3,8 @@
 exports.encode = require("./lib/encode").encode;
 exports.decode = require("./lib/decode").decode;
 
+exports.Encoder = require("./lib/encode").Encoder;
+exports.Decoder = require("./lib/decode").Decoder;
+
 exports.createEncodeStream = require("./lib/encode-stream").createEncodeStream;
 exports.createDecodeStream = require("./lib/decode-stream").createDecodeStream;

lib/decode.js

@@ -1,12 +1,13 @@
 // decode.js
-
 exports.decode = decode;
 
 var Decoder = require("./decoder").Decoder;
 
+exports.Decoder = Decoder;
+
 function decode(input) {
   var output = [];
   var decoder = new Decoder(output);
   decoder.decode(input);
   return output[0];
-}
+}

lib/encode-stream.js

@@ -12,5 +12,5 @@ function EncodeStream() {
   if (!(this instanceof EncodeStream)) return new EncodeStream();
   Transform.call(this, {objectMode: true});
   var encoder = new Encoder(this);
-  this._transform = encoder.encode.bind(encoder);
+  this._transform = encoder.transform.bind(encoder);
 }

lib/encode.js

@@ -1,12 +1,11 @@
 // encode.js
-
 exports.encode = encode;
 
 var Encoder = require("./encoder").Encoder;
 
+exports.Encoder = Encoder;
+
 function encode(input) {
-  var output = [];
-  var encoder = new Encoder(output);
-  encoder.encode(input);
-  return (output.length === 1) ? output[0] : Buffer.concat(output);
-}
+  var encoder = new Encoder();
+  return encoder.encode(input);
+}

lib/encoder.js

@@ -12,39 +12,50 @@ var IS_BUFFER_SHIM = ("TYPED_ARRAY_SUPPORT" in Buffer);
 var NO_TYPED_ARRAY = IS_BUFFER_SHIM && !Buffer.TYPED_ARRAY_SUPPORT;
 var IS_ARRAY = Array.isArray || isArray;
 
-function Encoder(option) {
-  if (!(this instanceof Encoder)) return new Encoder(option);
-  this.option = option;
+function Encoder(initialSize,output) {
+  if (!(this instanceof Encoder)) return new Encoder(output);
+
+  // check if size was passed in as the first or sec
+  this.option = (typeof initialSize) == "number" ? output : initialSize; 
+
+  // create the buffer now.
+  this.reserve( initialSize || BUFFER_LENGTH ); 
 }
 
-Encoder.prototype.encode = function(chunk, encoding, callback) {
-  if (!this.buffer) this.flush();
+Encoder.prototype.encode = function(chunk) {
+  this.offset=0;
   encode(this, chunk);
-  this.flush();
+  return this.buffer.slice(0,this.offset);
+};
+
+Encoder.prototype.transform = function(chunk, encoding, callback) {
+  this.option.push(this.encode(chunk) );
   if (callback) callback();
 };
 
-Encoder.prototype.flush = function(length) {
-  if (this.offset) {
-    this.option.push(this.buffer.slice(0, this.offset));
-    this.buffer = null;
-  }
-  if (length < BUFFER_LENGTH) length = 0;
-  if (!this.buffer || length) {
-    this.buffer = new Buffer(length || BUFFER_LENGTH);
-  }
-  this.offset = 0;
+Encoder.prototype.reserve = function(length) {
+    // no buffer?
+    if( !this.buffer ) {
+        this.buffer = new Buffer(length || BUFFER_LENGTH);
+        return;
+    }
+
+    length = length || 0;
+    // is it long enough?
+    if( this.buffer.length > (this.offset + length) ) {
+        return;
+    }
+
+    // resize it to 2x current length (or at least length!)
+    var newbuffer = new Buffer( Math.max(this.buffer.length * 2, length+this.offset ) );
+    this.buffer.copy( newbuffer, 0, 0, this.offset );
+    this.buffer = newbuffer;
 };
 
 Encoder.prototype.write = function(buffer) {
-  var end = this.offset + buffer.length;
-  if (end >= BUFFER_LENGTH) {
-    this.flush();
-    this.option.push(buffer);
-  } else {
-    buffer.copy(this.buffer, this.offset);
-    this.offset = end;
-  }
+  this.reserve( buffer.length );
+  buffer.copy(this.buffer, this.offset);
+  this.offset += buffer.length;
 };
 
 var constant = new Array(256);
@@ -150,16 +161,14 @@ function init_compatible() {
 
 function write0(type) {
   return function(encoder) {
-    var end = encoder.offset + 1;
-    if (end >= BUFFER_LENGTH) encoder.flush();
+    encoder.reserve(1);
     encoder.buffer[encoder.offset++] = type;
   };
 }
 
 function write1(type) {
   return function(encoder, value) {
-    var end = encoder.offset + 2;
-    if (end >= BUFFER_LENGTH) encoder.flush();
+    encoder.reserve(2);
     var buffer = encoder.buffer;
     var offset = encoder.offset;
     buffer[offset++] = type;
@@ -170,8 +179,7 @@ function write1(type) {
 
 function write2(type) {
   return function(encoder, value) {
-    var end = encoder.offset + 3;
-    if (end >= BUFFER_LENGTH) encoder.flush();
+    encoder.reserve(3);
     var buffer = encoder.buffer;
     var offset = encoder.offset;
     buffer[offset++] = type;
@@ -183,8 +191,7 @@ function write2(type) {
 
 function write4(type) {
   return function(encoder, value) {
-    var end = encoder.offset + 5;
-    if (end >= BUFFER_LENGTH) encoder.flush();
+    encoder.reserve(5);
     var buffer = encoder.buffer;
     var offset = encoder.offset;
     buffer[offset++] = type;
@@ -198,8 +205,7 @@ function write4(type) {
 
 function writeN(type, len, method) {
   return function(encoder, value) {
-    var end = encoder.offset + 1 + len;
-    if (end >= BUFFER_LENGTH) encoder.flush();
+    encoder.reserve(len+1);
     encoder.buffer[encoder.offset++] = type;
     method.call(encoder.buffer, value, encoder.offset, NO_ASSERT);
     encoder.offset += len;
@@ -266,10 +272,8 @@ function string(encoder, value) {
   // prepare buffer
   var length = value.length;
   var maxsize = 5 + length * 3;
-  if (encoder.offset + maxsize > BUFFER_LENGTH) {
-    encoder.flush(maxsize);
-  }
-
+  encoder.reserve(maxsize);
+
   // expected header size
   var expected = (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <= 0xFFFF) ? 3 : 5;