buffer: add indexOf/lastIndexOf method

doc/api/buffer.markdown

@@ -764,6 +764,24 @@ buffer.
  var b = new Buffer(50);
  b.fill("h");
 
+### buf.indexOf(value[, fromIndex])
+
+* `value` Buffer or String or Number
+* `fromIndex` Number, Optional, Default: 0
+
+Finds the index within the buffer of the first occurrence of the
+specified value, starting the search at fromIndex. Returns -1 if the
+value is not found.
+
+### buf.lastIndexOf(value[, fromIndex])
+
+* `value` Buffer or String or Number
+* `fromIndex` Number, Optional, Default: 0
+
+Finds the index within the buffer of the *last* occurrence of the
+specified value, starting the search at fromIndex. Returns -1 if the
+value is not found.
+
 ## buffer.INSPECT_MAX_BYTES
 
 * Number, Default: 50

lib/buffer.js

@@ -332,6 +332,27 @@ Buffer.prototype.fill = function fill(val, start, end) {
  return this;
 };
 
+Buffer.prototype.indexOf = function indexOf(needle, pos) {
+ if (typeof needle === 'number') {
+ needle = new Buffer([needle]);
+ } else if (typeof needle === 'string') {
+ needle = new Buffer(needle);
+ } else if (!(needle instanceof Buffer)) {
+ throw new TypeError('Argument must be a Buffer, number or string');
+ }
+ return internal.indexOf(this, needle, pos);
+};
+
+Buffer.prototype.lastIndexOf = function indexOf(needle, pos) {
+ if (typeof needle === 'number') {
+ needle = new Buffer([needle]);
+ } else if (typeof needle === 'string') {
+ needle = new Buffer(needle);
+ } else if (!(needle instanceof Buffer)) {
+ throw new TypeError('Argument must be a Buffer, number or string');
+ }
+ return internal.lastIndexOf(this, needle, pos);
+};
 
 // XXX remove in v0.13
 Buffer.prototype.get = util.deprecate(function get(offset) {

src/node_buffer.cc

@@ -34,6 +34,7 @@
 #include <limits.h>
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
 #define CHECK_NOT_OOB(r) \
  do { \
@@ -585,6 +586,97 @@ void Compare(const FunctionCallbackInfo<Value> &args) {
  args.GetReturnValue().Set(val);
 }
 
+int32_t IndexOf_DoSearch(char* obj_data, int32_t obj_length,
+ char* search_data, int32_t search_length,
+ int32_t start) {
+ while (search_length <= obj_length - start) {
+ // Search for the first byte of the needle.
+ char *chr = reinterpret_cast<char *>(
+ memchr(&obj_data[start], search_data[0], obj_length - start));
+ int32_t chrpos = (intptr_t)chr - (intptr_t)obj_data;
+ if (chr == NULL) {
+ // First byte not found, short circuit.
+ return -1;
+ }
+ if (search_length == 1) {
+ // Nothing more to compare, we found it.
+ return chrpos;
+ }
+ if (search_length > obj_length - chrpos) {
+ // Needle is longer than the rest of the haystack,
+ // no way it is contained in there.
+ return -1;
+ }
+ int cmp = memcmp(&chr[1], &search_data[1], search_length - 1);
+ if (cmp == 0) {
+ // All bytes are equal, we found it.
+ return chrpos;
+ }
+ // Advance start position for next iteration.
+ start = chrpos + 1;
+ }
+
+ return -1;
+}
+
+void IndexOf_Do(const FunctionCallbackInfo<Value> &args, bool isLast) {
+ Local<Object> obj = args[0]->ToObject();
+ char* obj_data =
+ static_cast<char*>(obj->GetIndexedPropertiesExternalArrayData());
+ int32_t obj_length = obj->GetIndexedPropertiesExternalArrayDataLength();
+
+ Local<Object> search = args[1]->ToObject();
+ char* search_data =
+ static_cast<char*>(search->GetIndexedPropertiesExternalArrayData());
+ int32_t search_length = search->GetIndexedPropertiesExternalArrayDataLength();
+
+ int32_t pos = args[2]->Int32Value();
+ int32_t start = MIN(MAX(pos, 0), obj_length);
+ int32_t end = obj_length;
+
+ if (isLast) {
+ if (search_length == 0) {
+ return args.GetReturnValue().Set(end);
+ }
+ int32_t best = -1;
+ while (search_length <= end - start) {
+ int32_t t = IndexOf_DoSearch(obj_data, obj_length,
+ search_data, search_length,
+ start);
+ if (t < 0) {
+ if (best < 0) {
+ break;
+ } else {
+ end = start;
+ start = best + 1;
+ if (start >= end) {
+ break;
+ }
+ }
+ } else {
+ best = t;
+ start = t + 1 + ((int32_t)(end - t) / 2);
+ }
+ }
+ args.GetReturnValue().Set(best);
+ } else {
+ if (search_length == 0) {
+ return args.GetReturnValue().Set(start);
+ }
+ int32_t ret = IndexOf_DoSearch(obj_data, obj_length,
+ search_data, search_length,
+ start);
+ args.GetReturnValue().Set(ret);
+ }
+}
+
+void IndexOf(const FunctionCallbackInfo<Value> &args) {
+ IndexOf_Do(args, false);
+}
+
+void LastIndexOf(const FunctionCallbackInfo<Value> &args) {
+ IndexOf_Do(args, true);
+}
 
 // pass Buffer object to load prototype methods
 void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
@@ -629,6 +721,8 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
  env->SetMethod(internal, "byteLength", ByteLength);
  env->SetMethod(internal, "compare", Compare);
  env->SetMethod(internal, "fill", Fill);
+ env->SetMethod(internal, "indexOf", IndexOf);
+ env->SetMethod(internal, "lastIndexOf", LastIndexOf);
 
  env->SetMethod(internal, "readDoubleBE", ReadDoubleBE);
  env->SetMethod(internal, "readDoubleLE", ReadDoubleLE);

test/simple/test-buffer.js

@@ -1184,3 +1184,23 @@ assert.throws(function() {
  var b = new Buffer(1);
  b.equals('abc');
 });
+
+// IndexOf Tests
+assert.equal(Buffer('abc').indexOf(''), 0)
+assert.equal(Buffer('abc').indexOf('bd'), -1)
+assert.equal(Buffer('abc').indexOf('bc'), 1)
+assert.equal(Buffer('abc').indexOf(0x62), 1)
+assert.equal(Buffer('abc').indexOf(Buffer('bc')), 1)
+assert.equal(Buffer('abc').indexOf(Buffer([0x62,0x63])), 1)
+assert.equal(Buffer('abc').indexOf('bc', 1), 1)
+assert.equal(Buffer('abc').indexOf('bc', 2), -1)
+
+// LastIndexOf Tests
+assert.equal(Buffer('abcabc').lastIndexOf(''), 6)
+assert.equal(Buffer('abcabc').lastIndexOf('bd'), -1)
+assert.equal(Buffer('abcabc').lastIndexOf('bc'), 4)
+assert.equal(Buffer('abcabc').lastIndexOf(0x62), 4)
+assert.equal(Buffer('abcabc').lastIndexOf(Buffer('bc')), 4)
+assert.equal(Buffer('abcabc').lastIndexOf(Buffer([0x62,0x63])), 4)
+assert.equal(Buffer('abcabc').lastIndexOf('bc', 1), 4)
+assert.equal(Buffer('abcabc').lastIndexOf('bc', 5), -1)