feat(Struct)

src/index.js

@@ -1,8 +1,11 @@
 import { limits } from "./limits"
 import { memcpy } from "./mem"
-import { ConstArray, ConstString } from "./type"
+import { Type } from "./Type"
+import { ConstString } from './ConstString'
+import { ConstArray } from "./ConstArray" 
+import { Struct } from './Struct'
 
-export { limits, memcpy, ConstString, ConstArray}
+export { limits, memcpy, Type, ConstString, ConstArray, Struct }
 
 export function serialize(dv, src, ...types) {
   const [type, ...inner_types] = types
@@ -14,19 +17,12 @@ export function serialize(dv, src, ...types) {
     dv.setFloat64(0, src)
     return
   }
-  if ((type == String || type._func == ConstString) && typeof src == 'string') {
+  if (type == String && typeof src == 'string') {
     const encoder = new TextEncoder('utf-8')
-    let encoded
-    if (type == String) {
-      encoded = new DataView(encoder.encode(src).buffer)
-      if (dv.byteLength < 4 + encoded.byteLength) {
-        throw new Error('too small buffer')
-      }
-    } else {
-      encoded = new DataView(encoder.encode(src).buffer, 0, type._size)
-      if (dv.byteLength < encoded.byteLength) {
-        throw new Error('too small buffer')
-      }
+    let encoded = new DataView(encoder.encode(src).buffer)
+
+    if (dv.byteLength < 4 + encoded.byteLength) {
+      throw new Error('too small buffer')
     }
     if (encoded.byteLength > limits.u32.MAX_VALUE) {
       throw new Error('string is too long')
@@ -38,21 +34,13 @@ export function serialize(dv, src, ...types) {
     memcpy(frame, encoded)
     return
   }
-  if ((type == Array || type._func == ConstArray) && Array.isArray(src)) {
+  if (type == Array && Array.isArray(src)) {
 
     const item_size = sizeofHead(src[0])
-    let size
+    const size = src.length
 
-    if (type == Array) {
-      size = src.length
-      if (dv.byteLength < 4 + size * item_size) {
-        throw new Error('too small buffer')
-      }
-    } else {
-      size = type._size
-      if (dv.byteLength < size * item_size) {
-        throw new Error('too small buffer')
-      }
+    if (dv.byteLength < 4 + size * item_size) {
+      throw new Error('too small buffer')
     }
     if (size > limits.u32.MAX_VALUE) {
       throw new Error('array is too long')
@@ -61,11 +49,15 @@ export function serialize(dv, src, ...types) {
     dv.setUint32(0, size)
 
     for (let i = 0; i < size; i++) {
-      const item_frame = new DataView(dv.buffer, dv.byteOffset + item_size * i)
+      const item_frame = new DataView(dv.buffer, dv.byteOffset + 4 + item_size * i)
       serialize(item_frame, src[i], ...inner_types)
     }
     return
   }
+  if (type instanceof Type) {
+    type.serialize(dv, src, ...inner_types)
+    return
+  }
 }
 
 export function parse(dv, ...types) {
@@ -74,46 +66,38 @@ export function parse(dv, ...types) {
   if (type == Number) {
     return dv.getFloat64(0)
   }
-  if (type == String || type._func == ConstString) {
-    let size
-    let frame
-    if (type == String) {
-      size = dv.getUint32(0)
-      frame = new DataView(dv.buffer, 4 + dv.byteOffset, size)
-    } else {
-      size = type._size
-      frame = new DataView(dv.buffer, dv.byteOffset, size)
-    }
+  if (type == String) {
+    const size = dv.getUint32(0)
+    const frame = new DataView(dv.buffer, 4 + dv.byteOffset, size)
     const decoder = new TextDecoder('utf-8')
     return decoder.decode(frame)
   }
-  if (type == Array || type._func == ConstArray) {
-    let size
-    let offset = 0
-    if (type == Array) {
-      size = dv.getUint32(0)
-      offset = 4
-    } else {
-      size = type._size
-    }
+  if (type == Array) {
+    const size = dv.getUint32(0)
     const item_size = sizeofHead(inner_types[0])
     const array = Array(size)
 
     for (let i = 0; i < size; i++) {
-      const item_frame = new DataView(dv.buffer, dv.byteOffset + offset + item_size * i)
+      const item_frame = new DataView(dv.buffer, dv.byteOffset + 4 + item_size * i)
       array[i] = parse(item_frame, ...inner_types)
     }
 
     return array
   }
+  if (type instanceof Type) {
+    return type.parse(dv, ...inner_types)
+  }
 }
 
 export function isHeadless(...args) {
-  const [first_arg] = args
-  return first_arg == Array ||
-    first_arg == String ||
-    Array.isArray(first_arg) ||
-    typeof first_arg == 'string'
+  const [arg, ...inner_args] = args
+  if (arg instanceof Type) {
+    return arg.isHeadless(...inner_args)
+  }
+  return arg == Array ||
+    arg == String ||
+    Array.isArray(arg) ||
+    typeof arg == 'string'
 }
 
 export function sizeofHead(...args) {
@@ -125,23 +109,24 @@ export function sizeofHead(...args) {
 }
 
 export function sizeof(...args) {
-  const [first_arg, ...remain_args] = args
+  const [arg, ...inner_args] = args
 
-  if (first_arg == Number || typeof first_arg == 'number') {
+  if (arg == Number || typeof arg == 'number') {
     return 8
   }
-  if (first_arg._func == ConstArray) {
-    return sizeofHead(...remain_args) * first_arg._size
-  }
-  if (first_arg._func == ConstString) {
-    return first_arg._size
-  }
-  if (typeof first_arg == 'string') {
+  if (typeof arg == 'string') {
     const encoder = new TextEncoder('utf-8')
-    return 4 + encoder.encode(first_arg).byteLength
+    return 4 + encoder.encode(arg).byteLength
   }
-  if (Array.isArray(first_arg)) {
-    return 4 + sizeofHead(first_arg[0]) * first_arg.length
+  if (Array.isArray(arg)) {
+    return 4 + sizeofHead(arg[0]) * arg.length
   }
-  throw new Error('unknown size of ' + args)
+  if (arg instanceof Type) {
+    return arg.sizeof(...inner_args)
+  }
+  const [arg2, ...inner_args2] = inner_args
+  if (arg2 instanceof Type) {
+    return arg2.sizeof(arg, ...inner_args2)
+  }
+  throw new Error('unknown size of ' + arg)
 }