{-# OPTIONS_GHC -fno-warn-orphans #-}
module Data.Repa.Convert.Format.Fields where
import Data.Repa.Convert.Internal.Format
import Data.Repa.Convert.Internal.Packable
import Data.Repa.Scalar.Product
#include "repa-convert.h"


---------------------------------------------------------------------------------------------------
instance Format () where
 type Value () = ()
 fieldCount :: () -> Int
fieldCount ()
_   = Int
0
 minSize :: () -> Int
minSize    ()
_   = Int
0
 fixedSize :: () -> Maybe Int
fixedSize  ()
_   = Int -> Maybe Int
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
0
 packedSize :: () -> Value () -> Maybe Int
packedSize ()
_ Value ()
_ = Int -> Maybe Int
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
0
 {-# INLINE minSize    #-}
 {-# INLINE fieldCount #-}
 {-# INLINE fixedSize  #-}
 {-# INLINE packedSize #-}


instance Packable () where
 packer :: () -> Value () -> Addr# -> IO () -> (Addr# -> IO ()) -> IO ()
packer  ()
_f Value ()
_v Addr#
dst IO ()
_fails Addr# -> IO ()
k
        = Addr# -> IO ()
k Addr#
dst
 {-# INLINE packer #-}


instance Unpackable () where

 unpacker :: ()
-> Addr#
-> Addr#
-> (Word8 -> Bool)
-> IO ()
-> (Addr# -> Value () -> IO ())
-> IO ()
unpacker ()
_f Addr#
start Addr#
_end Word8 -> Bool
_stop IO ()
_fail Addr# -> Value () -> IO ()
eat
        = Addr# -> Value () -> IO ()
eat Addr#
start ()
 {-# INLINE unpacker #-}


---------------------------------------------------------------------------------------------------
-- | Formatting fields.
instance (Format a, Format b) 
       => Format (a :*: b) where

 type Value (a :*: b)
  = Value a :*: Value b

 fieldCount :: (a :*: b) -> Int
fieldCount (a
fa :*: b
fb)
  = a -> Int
forall f. Format f => f -> Int
fieldCount a
fa Int -> Int -> Int
forall a. Num a => a -> a -> a
+ b -> Int
forall f. Format f => f -> Int
fieldCount b
fb
 {-# NOINLINE fieldCount #-}

 minSize :: (a :*: b) -> Int
minSize    (a
fa :*: b
fb)
  = a -> Int
forall f. Format f => f -> Int
minSize a
fa Int -> Int -> Int
forall a. Num a => a -> a -> a
+ b -> Int
forall f. Format f => f -> Int
minSize b
fb
 {-# NOINLINE minSize #-}

 fixedSize :: (a :*: b) -> Maybe Int
fixedSize  (a
fa :*: b
fb)
  = do  Int
sa      <- a -> Maybe Int
forall f. Format f => f -> Maybe Int
fixedSize a
fa
        Int
sb      <- b -> Maybe Int
forall f. Format f => f -> Maybe Int
fixedSize b
fb
        Int -> Maybe Int
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return  (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$  Int
sa Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
sb
 {-# NOINLINE fixedSize #-}

 packedSize :: (a :*: b) -> Value (a :*: b) -> Maybe Int
packedSize (a
fa :*: b
fb) (Value a
xa :*: Value b
xb)
  = do  Int
sa      <- a -> Value a -> Maybe Int
forall f. Format f => f -> Value f -> Maybe Int
packedSize a
fa Value a
xa
        Int
sb      <- b -> Value b -> Maybe Int
forall f. Format f => f -> Value f -> Maybe Int
packedSize b
fb Value b
xb
        Int -> Maybe Int
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return  (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$  Int
sa Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
sb
 {-# NOINLINE packedSize #-}