Error handling in array deserialization

Author: jacereda

src/Data/ArrayBuffer/DataView.purs

@@ -17,12 +17,12 @@ function whole(b) {
 
 foreign import sliceImpl
 """
-function sliceImpl(s, l, b) {
-  return new DataView(b, s, l);
+function sliceImpl(just, nothing, s, l, b) {
+  return s + l <= b.byteLength? just(new DataView(b, s, l)) : nothing;
 }
-""" :: forall e. Fn3 ByteOffset ByteLength ArrayBuffer DataView
-slice :: forall e. ByteOffset -> ByteLength -> ArrayBuffer -> DataView
-slice = runFn3 sliceImpl
+""" :: forall e. Fn5 (DataView -> Maybe DataView) (Maybe DataView) ByteOffset ByteLength ArrayBuffer (Maybe DataView)
+slice :: forall e. ByteOffset -> ByteLength -> ArrayBuffer -> Maybe DataView
+slice = runFn5 sliceImpl Just Nothing
 
 foreign import buffer
 """

src/Data/ArrayBuffer/Deserializer.purs

@@ -47,31 +47,42 @@ instance isDeserializableFloat32 :: IsDeserializable Float32 where
 instance isDeserializableFloat64 :: IsDeserializable Float64 where
   get = getFloat64
 
-getDataView :: forall e. Deserializer -> ByteLength -> Eff (reader :: DV.Reader | e) DV.DataView
+getDataView :: forall e. Deserializer -> ByteLength -> Eff (reader :: DV.Reader | e) (Either String DV.DataView)
 getDataView d n = do
   o <- advance n d
-  return $ DV.slice o n (DV.buffer d.dv)
+  return $ case DV.slice o n (DV.buffer d.dv) of
+    (Just dv) -> Right dv
+    otherwise -> Left "short read"
+
+type AD t = forall e. Deserializer -> Number -> Eff (reader :: DV.Reader | e) (Either String t)
+
+
+getTypedArray :: forall e t. Deserializer -> Number -> (DV.DataView -> t) -> Eff (reader :: DV.Reader | e) (Either String t)
+getTypedArray d sz conv = do
+  edv <- getDataView d sz
+  return $ case edv of
+    Right dv -> Right $ conv dv
+    Left err -> Left err
 
-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
+getInt8Array d n = getTypedArray d n TA.asInt8Array
 getInt16Array :: AD TA.Int16Array
-getInt16Array d n = getDataView d (n * 2) >>= return <<< TA.asInt16Array
+getInt16Array d n = getTypedArray d (n * 2) TA.asInt16Array
 getInt32Array :: AD TA.Int32Array
-getInt32Array d n = getDataView d (n * 4) >>= return <<< TA.asInt32Array
+getInt32Array d n = getTypedArray d (n * 4) TA.asInt32Array
 getUint8Array :: AD TA.Uint8Array
-getUint8Array d n = getDataView d n >>= return <<< TA.asUint8Array
+getUint8Array d n = getTypedArray d n TA.asUint8Array
 getUint16Array :: AD TA.Uint16Array
-getUint16Array d n = getDataView d (n * 2) >>= return <<< TA.asUint16Array
+getUint16Array d n = getTypedArray d (n * 2) TA.asUint16Array
 getUint32Array :: AD TA.Uint32Array
-getUint32Array d n = getDataView d (n * 4) >>= return <<< TA.asUint32Array
+getUint32Array d n = getTypedArray d (n * 4) TA.asUint32Array
 getUint8ClampedArray :: AD TA.Uint8ClampedArray
-getUint8ClampedArray d n = getDataView d n >>= return <<< TA.asUint8ClampedArray
+getUint8ClampedArray d n = getTypedArray d n TA.asUint8ClampedArray
 getFloat32Array :: AD TA.Float32Array
-getFloat32Array d n = getDataView d (n * 4) >>= return <<< TA.asFloat32Array
+getFloat32Array d n = getTypedArray d (n * 4) TA.asFloat32Array
 getFloat64Array :: AD TA.Float64Array
-getFloat64Array d n = getDataView d (n * 8) >>= return <<< TA.asFloat64Array
+getFloat64Array d n = getTypedArray d (n * 8) 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

@@ -5,6 +5,7 @@ import qualified Data.ArrayBuffer as AB
 import qualified Data.ArrayBuffer.DataView as DV
 import Data.ArrayBuffer.Advancer
 import Data.Function
+import Data.Maybe
 import Control.Monad.Eff
 
 type Serializer = Advancer
@@ -29,7 +30,7 @@ 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 :: forall e. Serializer -> ByteLength -> Eff (writer :: DV.Writer | e) (Maybe DV.DataView)
 mapDataView s n = do
   o <- advance n s
   return $ DV.slice o n (DV.buffer s.dv)

test/Main.purs

@@ -114,8 +114,8 @@ main = do
   assert $ AB.byteLength (AB.slice 2 4 ab) == 2
   assert $ AB.byteLength (AB.slice (-2) (-2) ab) == 0
   assert $ AB.byteLength (AB.slice (-2) (-1) ab) == 1     
-  assert $ DV.byteLength (DV.slice 0 2 ab) == 2
-  assert $ DV.byteLength (DV.slice 2 2 ab) == 2
+  assert $ (DV.byteLength <$> (DV.slice 0 2 ab)) == Just 2
+  assert $ (DV.byteLength <$> (DV.slice 2 2 ab)) == Just 2
   let aab = AB.fromArray [1, 2, 3, 4]
   assert $ AB.byteLength aab == 4
   let sab = AB.fromString "hola"
@@ -127,7 +127,8 @@ main = do
 
   assert $ AB.byteLength (DV.buffer $ TA.dataView (TA.asInt8Array dv)) == 8
 
-  assert $ DV.byteLength (DV.slice 0 4 nab) == 4
+  assert $ (DV.byteLength <$> DV.slice 0 4 nab) == Just 4
+  assert $ (DV.byteLength <$> DV.slice 0 40 nab) == Nothing
 
   assert $ do
      let ab = AB.fromArray [1,2,3,4]