new schema format

rzcoder · rzcoder · commit e3f6b7d22055 · 2014-05-29T22:35:41.000+06:00
diff --git a/README.md b/README.md
@@ -1,45 +1,93 @@
-# data-struct
+# Data structure
 
-Convert between JS object and Node.js buffer
+Convert between JS object and Node.js buffer with with rigidly predetermined scheme.
 
+## Installing
+
+```shell
+    npm install data-struct
 ```
-{
-	propname: DataTypes.uint
-	propname2: [DataTypes.list, DataTypes.string]
-	propname3: [{
-		propname: [{
-			propname: DataTypes.uint 
-		}]
-	propname4: [DataTypes.list, DataTypes.uint]
-	}],
-	propname5: [DataTypes.struct, {
-		propname: propvalue
-	}],
-	propname6: [DataTypes.list, 
-		{
-			list: []
-		}
-	]
-	
-}
-
-
-{
-	propname: 42
-	propname2: ['42','43','45']
-	propname3: [
-		{
-				propname: [1,2,3]
-		},
-		{
-				propname: [1,2,3]
-		},
-	],
-	propname4: [ 
-		[1,2,3],
-		[1,2,3],
-		[1,2,3]
-	]
-	
-}
+
+
+## Example & usage
+
+```javascript
+
+var DataTypes = require("data-struct").DataTypes;
+var DataReader = require("data-struct").DataReader;
+var DataWriter = require("data-struct").DataWriter;
+
+var hero = {
+    id: 9,
+    name: 'CirnoBaka',
+    hp: 146,
+    skills: [
+        {
+            id: 34,
+            description: 'freezing frogs'
+        },
+        {
+            id: 16,
+            description: 'perfect math'
+        }
+    ],
+    playable: false,
+    experience: 99999999,
+    position: {
+        x: 2,
+        y: 3
+    }
+};
+
+var heroScheme = {
+    id: DataTypes.uint32,
+    name: DataTypes.string,
+    hp: DataTypes.int16,
+    skills: [{
+        id: DataTypes.uint16,
+        description: DataTypes.string
+    }],
+    playable: DataTypes.boolean,
+    experience: DataTypes.uint32,
+    position: {
+        x: DataTypes.uint16,
+        y: DataTypes.uint16
+    }
+};
+
+var heroBuf = DataWriter(hero, heroScheme);
+var heroClone = DataReader(heroBuf, heroScheme);
+
+
+//nested arrays
+var map = [
+    [0,1,0,0,1,1,1,1]
+    [1,1,0,0,0,1,1,1]
+    [1,1,0,0,0,0,1,1]
+    [1,1,1,1,0,0,1,1]
+    [0,1,1,0,0,0,1,1]
+    [0,0,0,0,0,1,1,1]
+    [0,0,0,0,1,1,1,1]
+];
+
+var mapScheme = [[DataTypes.uint8]];
+
+var mapBuf = DataWriter(map, mapScheme);
+var mapClone = DataReader(mapBuf, mapScheme);
 ```
+
+
+## Data types
+
+  * **boolean** - 1 byte
+  * **int8** - 1 byte
+  * **uint8** - 1 byte
+  * **int16** - 2 bytes
+  * **uint16** - 2 bytes
+  * **int32** - 4 bytes
+  * **uint32** - 4 bytes
+  * **float** - 4 bytes
+  * **double** - 8 bytes
+  * **string** - 2 bytes header + string bytes length (max length: 65535 bytes, **not string length!**)
+  * **shortBuffer**  - 2 bytes header  + buffer length (max length: 65535 bytes)
+  * **buffer**  - 4 bytes header + buffer length (max length 4294967295 bytes)
diff --git a/benchmark/benchmark.js b/benchmark/benchmark.js
@@ -0,0 +1,52 @@
+var Benchmark = require('benchmark');
+var suite = new Benchmark.Suite;
+
+DataTypes = require("../src/index").DataTypes;
+DataReader = require("../src/index").DataReader;
+DataWriter = require("../src/index").DataWriter;
+
+
+
+var suites = {
+    'int32': {
+        object: 0x0F00FF00,
+        scheme: DataTypes.int32
+    },
+    'string': {
+        object: 'Hello I String',
+        scheme: DataTypes.string
+    },
+    'nested': {
+        object: { nested: { nested2: { nested3: { nested4: { nested5: 42 } } } } },
+        scheme: { nested: { nested2: { nested3: { nested4: { nested5: DataTypes.uint8 } } } } }
+    },
+    'list of list': {
+        object: [
+            [90,10,101],
+            [20,30,400],
+            [100,110,1]
+        ],
+        scheme: [[DataTypes.int16]]
+    }
+};
+
+for(s in suites) {
+    var object = suites[s].object;
+    var scheme = suites[s].scheme;
+
+    (function(s, object, scheme) {
+        var buf = null;
+        var obj = null;
+        suite.add(s + '#writing to buffer', function () {
+            buf = DataWriter(object, scheme);
+        })
+        .add(s + '#reading from buffer', function () {
+            obj = DataReader(buf, scheme);
+        });
+    })(s, object, scheme);
+}
+
+
+suite.on('cycle', function(event) {
+    console.log(String(event.target));
+}).run();
diff --git a/package.json b/package.json
@@ -27,8 +27,8 @@
     "grunt-simple-mocha": "^0.4.0",
     "jit-grunt": "^0.3.2",
     "chai": "^1.9.1",
-    "grunt-contrib-jshint": "^0.9.2"
+    "grunt-contrib-jshint": "^0.9.2",
+    "benchmark": "^1.0.0"
   },
-  "dependencies": {
-  }
+  "dependencies": {}
 }
diff --git a/src/dataReader.js b/src/dataReader.js
@@ -83,11 +83,7 @@ typesTable[DataTypes.buffer] = function (pointer, buffer) {
     return res;
 };
 
-typesTable[DataTypes.struct] = function (pointer, buffer, scheme) {
-    return structureReader(pointer, buffer, scheme);
-};
-
-typesTable[DataTypes.list] = function (pointer, buffer, scheme) {
+function list (pointer, buffer, scheme) {
     var length = buffer.readUInt16BE(pointer.offset);
     pointer.offset += 2;
 
@@ -96,10 +92,10 @@ typesTable[DataTypes.list] = function (pointer, buffer, scheme) {
         res.push(structureReader(pointer, buffer, scheme));
     }
     return res;
-};
+}
 
 var structureReader = function (pointer, buffer, scheme) {
-    var res;
+    var res = {};
 
     if (arguments.length === 2) {
         scheme = buffer;
@@ -111,17 +107,21 @@ var structureReader = function (pointer, buffer, scheme) {
 
     if(typeof scheme  === 'number') {
         res = typesTable[scheme](pointer, buffer);
+    } else if (Array.isArray(scheme)) {
+        res = list(pointer, buffer, scheme[0]);
     } else {
-        res = {};
         for (var el in scheme) {
             var s = scheme[el];
             if (typeof s === 'number') {
                 res[el] = typesTable[s](pointer, buffer);
+            }  else if (Array.isArray(s)) {
+                res[el] = list(pointer, buffer, s[0]);
             } else {
-                res[el] = typesTable[s.type](pointer, buffer, s.scheme);
+                res[el] = structureReader(pointer, buffer, s);
             }
         }
     }
+
     return res;
 };
 
diff --git a/src/dataTypes.js b/src/dataTypes.js
@@ -11,8 +11,5 @@ module.exports = {
 
     string: 0x200,
     shortBuffer: 0x210,
-    buffer: 0x211,
-
-    struct: 0x500,
-    list: 0x501
+    buffer: 0x211
 };
diff --git a/src/dataWriter.js b/src/dataWriter.js
@@ -97,11 +97,7 @@ typesTable[DataTypes.buffer] = function (value) {
     return res;
 };
 
-typesTable[DataTypes.struct] = function (value, scheme) {
-    return structureWriter(value, scheme);
-};
-
-typesTable[DataTypes.list] = function (value, scheme) {
+function list (value, scheme) {
     if (!Array.isArray(value)) {
         throw Error('Value is not array.');
     }
@@ -117,23 +113,24 @@ typesTable[DataTypes.list] = function (value, scheme) {
     }
 
     return Buffer.concat(res);
-};
+}
 
 var structureWriter = function (object, scheme) {
     var res = [];
+
     if(typeof scheme  === 'number') {
         res.push(typesTable[scheme](object));
+    } else if(Array.isArray(scheme)) {
+        res.push(list(object, scheme[0]));
     } else {
-        if(Array.isArray(scheme)) {
-            console.log('bingo')
-        } else {
-            for (var el in scheme) {
-                var s = scheme[el];
-                if (typeof s === 'number') {
-                    res.push(typesTable[s](object[el]));
-                } else {
-                    res.push(typesTable[s.type](object[el], s.scheme));
-                }
+        for (var el in scheme) {
+            var s = scheme[el];
+            if (typeof s === 'number') {
+                res.push(typesTable[s](object[el]));
+            } else if (Array.isArray(s)) {
+                res.push(list(object[el], s[0]));
+            } else {
+                res.push(structureWriter(object[el], s));
             }
         }
     }
diff --git a/test/tests.js b/test/tests.js
