Typed array serialization/deserialization

Author: jacereda

src/Data/ArrayBuffer/Deserializer.purs

@@ -1,11 +1,12 @@
 module Data.ArrayBuffer.Deserializer where
 
+import Data.Function
+import Control.Monad.Eff
+import Data.ArrayBuffer.Advancer
 import Data.ArrayBuffer.Types
+import qualified Data.ArrayBuffer.Typed as TA
 import qualified Data.ArrayBuffer as AB
 import qualified Data.ArrayBuffer.DataView as DV
-import Data.Function
-import Data.ArrayBuffer.Advancer
-import Control.Monad.Eff
 
 type Deserializer = Advancer
 
@@ -29,6 +30,32 @@ instance isDeserializableFloat32 :: IsDeserializable Float32 where
 instance isDeserializableFloat64 :: IsDeserializable Float64 where
   get d = advance 8 d >>= DV.getFloat64 d.dv
 
+getDataView :: forall e. Deserializer -> ByteLength -> Eff (reader :: DV.Reader | e) DV.DataView
+getDataView d n = do
+  o <- advance n d
+  return $ DV.slice o n (DV.buffer d.dv)
+
+type AD t = forall e. Deserializer -> Number -> Eff (reader :: DV.Reader | e) t
+
+getInt8Array :: AD TA.Int8Array
+getInt8Array d n = getDataView d n >>= return <<< TA.asInt8Array
+getInt16Array :: AD TA.Int16Array
+getInt16Array d n = getDataView d (n * 2) >>= return <<< TA.asInt16Array
+getInt32Array :: AD TA.Int32Array
+getInt32Array d n = getDataView d (n * 4) >>= return <<< TA.asInt32Array
+getUint8Array :: AD TA.Uint8Array
+getUint8Array d n = getDataView d n >>= return <<< TA.asUint8Array
+getUint16Array :: AD TA.Uint16Array
+getUint16Array d n = getDataView d (n * 2) >>= return <<< TA.asUint16Array
+getUint32Array :: AD TA.Uint32Array
+getUint32Array d n = getDataView d (n * 4) >>= return <<< TA.asUint32Array
+getUint8ClampedArray :: AD TA.Uint8ClampedArray
+getUint8ClampedArray d n = getDataView d n >>= return <<< TA.asUint8ClampedArray
+getFloat32Array :: AD TA.Float32Array
+getFloat32Array d n = getDataView d (n * 4) >>= return <<< TA.asFloat32Array
+getFloat64Array :: AD TA.Float64Array
+getFloat64Array d n = getDataView d (n * 8) >>= return <<< TA.asFloat64Array
+
 deserializer :: forall e. AB.ArrayBuffer -> Eff (reader :: DV.Reader | e) Deserializer
 deserializer ab = return $ { dv : DV.whole ab, off : 0 }
 

src/Data/ArrayBuffer/Serializer.purs

@@ -29,7 +29,10 @@ instance isSerializableFloat32 :: IsSerializable Float32 where
 instance isSerializableFloat64 :: IsSerializable Float64 where
   put s v = advance 8 s >>= DV.setFloat64 s.dv v
 
-
+mapDataView :: forall e. Serializer -> ByteLength -> Eff (writer :: DV.Writer | e) DV.DataView
+mapDataView s n = do
+  o <- advance n s
+  return $ DV.slice o n (DV.buffer s.dv)
 
 serializer :: forall e. ByteLength -> Eff (writer :: DV.Writer | e) Serializer
 serializer l = return $ { dv : DV.whole $ AB.create l, off : 0 }

src/Data/ArrayBuffer/Typed.purs

@@ -10,14 +10,14 @@ import Data.ArrayBuffer.Types
 foreign import data ArrayView :: * -> *
 
 type Int8Array = ArrayView Int8
+type Int16Array = ArrayView Int16
+type Int32Array = ArrayView Int32
 type Uint8Array = ArrayView Uint8
---type Uint8ClampedArray = ArrayView Uint8Clamped
---type Int16Array = ArrayView Int16
---type Uint16Array = ArrayView Uint16
---type Int32Array = ArrayView Int32
---type Uint32Array = ArrayView Uint32
---type Float32Array = ArrayView Float32
---type Float64Array = ArrayView Float64 
+type Uint16Array = ArrayView Uint16
+type Uint32Array = ArrayView Uint32
+type Uint8ClampedArray = ArrayView Uint8Clamped
+type Float32Array = ArrayView Float32
+type Float64Array = ArrayView Float64 
 
 foreign import asInt8Array
 """
@@ -26,13 +26,62 @@ function asInt8Array(v) {
 }
 """:: DataView -> Int8Array
 
+foreign import asInt16Array
+"""
+function asInt16Array(v) {
+  return new Int16Array(v.buffer, v.byteOffset, v.byteLength >>> 1);
+}
+""":: DataView -> Int16Array
+
+foreign import asInt32Array
+"""
+function asInt32Array(v) {
+  return new Int32Array(v.buffer, v.byteOffset, v.byteLength >>> 2);
+}
+""":: DataView -> Int32Array
+
 foreign import asUint8Array
 """
 function asUint8Array(v) {
   return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
 }
 """:: DataView -> Uint8Array
 
+foreign import asUint16Array
+"""
+function asUint16Array(v) {
+  return new Uint16Array(v.buffer, v.byteOffset, v.byteLength >>> 1);
+}
+""":: DataView -> Uint16Array
+
+foreign import asUint32Array
+"""
+function asUint32Array(v) {
+  return new Uint32Array(v.buffer, v.byteOffset, v.byteLength >>> 2);
+}
+""":: DataView -> Uint32Array
+
+foreign import asUint8ClampedArray
+"""
+function asUint8ClampedArray(v) {
+  return new Uint8ClampedArray(v.buffer, v.byteOffset, v.byteLength);
+}
+""":: DataView -> Uint8ClampedArray
+
+foreign import asFloat32Array
+"""
+function asFloat32Array(v) {
+  return new Float32Array(v.buffer, v.byteOffset, v.byteLength >>> 2);
+}
+""":: DataView -> Float32Array
+
+foreign import asFloat64Array
+"""
+function asFloat64Array(v) {
+  return new Float64Array(v.buffer, v.byteOffset, v.byteLength >>> 3);
+}
+""":: DataView -> Float64Array
+
 foreign import dataView
 """
 function dataView(a) {
@@ -66,8 +115,9 @@ at a n = if a `hasIndex` n then
 foreign import toArray
 """
 function toArray(a) {
-  var ret = [];
-  for (var i = 0, l = a.length; i < l; i++)
+  var l = a.length;
+  var ret = new Array(l);
+  for (var i = 0; i < l; i++)
     ret[i] = a[i];
   return ret;
 }