Buffer, feat: support Buffer.reverse.

Author: xicilion

fibjs/include/Buffer.h

@@ -104,6 +104,7 @@ class Buffer : public Buffer_base {
     virtual result_t writeDoubleBE(double value, int32_t offset, bool noAssert);
     virtual result_t slice(int32_t start, obj_ptr<Buffer_base>& retVal);
     virtual result_t slice(int32_t start, int32_t end, obj_ptr<Buffer_base>& retVal);
+    virtual result_t reverse(obj_ptr<Buffer_base>& retVal);
     virtual result_t hex(exlib::string& retVal);
     virtual result_t base64(exlib::string& retVal);
     virtual result_t keys(v8::Local<v8::Object>& retVal);

fibjs/include/ifs/Buffer.h

@@ -107,6 +107,7 @@ class Buffer_base : public object_base {
     virtual result_t writeDoubleBE(double value, int32_t offset, bool noAssert) = 0;
     virtual result_t slice(int32_t start, obj_ptr<Buffer_base>& retVal) = 0;
     virtual result_t slice(int32_t start, int32_t end, obj_ptr<Buffer_base>& retVal) = 0;
+    virtual result_t reverse(obj_ptr<Buffer_base>& retVal) = 0;
     virtual result_t hex(exlib::string& retVal) = 0;
     virtual result_t base64(exlib::string& retVal) = 0;
     virtual result_t keys(v8::Local<v8::Object>& retVal) = 0;
@@ -179,6 +180,7 @@ class Buffer_base : public object_base {
     static void s_writeDoubleLE(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void s_writeDoubleBE(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void s_slice(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void s_reverse(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void s_hex(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void s_base64(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void s_keys(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -249,6 +251,7 @@ inline ClassInfo& Buffer_base::class_info()
         { "writeDoubleLE", s_writeDoubleLE, false },
         { "writeDoubleBE", s_writeDoubleBE, false },
         { "slice", s_slice, false },
+        { "reverse", s_reverse, false },
         { "hex", s_hex, false },
         { "base64", s_base64, false },
         { "keys", s_keys, false },
@@ -1404,6 +1407,20 @@ inline void Buffer_base::s_slice(const v8::FunctionCallbackInfo<v8::Value>& args
     METHOD_RETURN();
 }
 
+inline void Buffer_base::s_reverse(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    obj_ptr<Buffer_base> vr;
+
+    METHOD_INSTANCE(Buffer_base);
+    METHOD_ENTER();
+
+    METHOD_OVER(0, 0);
+
+    hr = pInst->reverse(vr);
+
+    METHOD_RETURN();
+}
+
 inline void Buffer_base::s_hex(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     exlib::string vr;

fibjs/src/global/Buffer.cpp

@@ -945,6 +945,24 @@ result_t Buffer::slice(int32_t start, int32_t end, obj_ptr<Buffer_base>& retVal)
     return 0;
 }
 
+result_t Buffer::reverse(obj_ptr<Buffer_base>& retVal)
+{
+    exlib::string strBuf;
+    toString(strBuf);
+
+    char* buf = strBuf.c_buffer();
+    int32_t len = (int32_t)strBuf.length();
+    for (int32_t i = 0; i < len / 2; i++) {
+        char ch = buf[i];
+        buf[i] = buf[len - i - 1];
+        buf[len - i - 1] = ch;
+    }
+
+    retVal = new Buffer(strBuf);
+
+    return 0;
+}
+
 result_t Buffer::toString(exlib::string& retVal)
 {
     retVal = m_data;

idl/zh-cn/Buffer.idl

@@ -561,6 +561,11 @@ interface Buffer : object
      */
     Buffer slice(Integer start, Integer end);
 
+    /*! @brief 返回一个新缓存对象，包含当前对象数据的倒序
+     @return 返回新的缓存对象
+     */
+    Buffer reverse();
+
     /*! @brief 使用 16 进制编码缓存对象内容
      @return 返回编码字符串
      */

test/buffer_test.js

@@ -724,6 +724,48 @@ describe('Buffer', () => {
         assert.equal(buf.indexOf(new Buffer([0x00, 0x36])), 5);
 
     });
+
+    var fixtures = [{
+            "a": "ffff00",
+            "expected": "00ffff"
+        },
+        {
+            "a": "ffff",
+            "expected": "ffff"
+        },
+        {
+            "a": "0000",
+            "expected": "0000"
+        },
+        {
+            "a": "0000ff",
+            "expected": "ff0000"
+        },
+        {
+            "a": "000000",
+            "expected": "000000"
+        },
+        {
+            "a": "ffffff",
+            "expected": "ffffff"
+        },
+        {
+            "a": "00ffff00ff",
+            "expected": "ff00ffff00"
+        },
+        {
+            "a": "0000ff00ffff00ff",
+            "expected": "ff00ffff00ff0000"
+        }
+    ];
+
+    it('reverse', () => {
+        fixtures.forEach((f) => {
+            var a = new Buffer(f.a, 'hex');
+            assert.equal(a.reverse().toString('hex'), f.expected);
+            assert.equal(a.toString('hex'), f.a);
+        })
+    });
 });
 
 repl && test.run(console.DEBUG);