1module Throughput.BinaryBuilderDeclarative ( 2 serialize 3) where 4 5import Data.Monoid 6import Data.Word 7import qualified Data.ByteString.Lazy as L 8 9import Data.Binary.Builder 10 11import Control.Monad 12 13import Throughput.Utils 14 15serialize :: Int -> Int -> Endian -> Int -> Maybe L.ByteString 16serialize wordSize chunkSize end iters = fmap toLazyByteString $ 17 case (wordSize, chunkSize, end) of 18 (1, 1,_) -> return $ writeByteN1 iters 19 20 (2, 1, Big) -> return $ writeWord16N1Big iters 21 (2, 1, Little) -> return $ writeWord16N1Little iters 22 (2, 1, Host) -> return $ writeWord16N1Host iters 23 24 (4, 1, Big) -> return $ writeWord32N1Big iters 25 (4, 1, Little) -> return $ writeWord32N1Little iters 26 (4, 1, Host) -> return $ writeWord32N1Host iters 27 28 (8, 1, Host) -> return $ writeWord64N1Host iters 29 (8, 1, Big) -> return $ writeWord64N1Big iters 30 (8, 1, Little) -> return $ writeWord64N1Little iters 31 32 _ -> mzero 33 34------------------------------------------------------------------------ 35-- Word8 36------------------------------------------------------------------------ 37 38word8List :: Int -> [Word8] 39word8List n = take n $ cycle $ [0..] 40 41------------------------------------------------------------------------ 42 43writeByteN1 = mconcat . map singleton . word8List 44 45 46------------------------------------------------------------------------ 47-- Word16 48------------------------------------------------------------------------ 49 50word16List :: Int -> [Word16] 51word16List n = take n $ cycle $ [0..] 52 53------------------------------------------------------------------------ 54-- Big endian, word16 writes 55 56writeWord16N1Big = mconcat . map putWord16be . word16List 57 58 59------------------------------------------------------------------------ 60-- Little endian, word16 writes 61 62writeWord16N1Little = mconcat . map putWord16le . word16List 63 64 65------------------------------------------------------------------------ 66-- Host endian, unaligned, word16 writes 67 68writeWord16N1Host = mconcat . map putWord16host . word16List 69 70 71------------------------------------------------------------------------ 72-- Word32 73------------------------------------------------------------------------ 74 75word32List :: Int -> [Word32] 76word32List n = [0..fromIntegral (n-1)] 77 78------------------------------------------------------------------------ 79-- Big endian, word16 writes 80 81writeWord32N1Big = mconcat . map putWord32be . word32List 82 83 84------------------------------------------------------------------------ 85-- Little endian, word32 writes 86 87writeWord32N1Little = mconcat . map putWord32le . word32List 88 89 90------------------------------------------------------------------------ 91-- Host endian, unaligned, word32 writes 92 93writeWord32N1Host = mconcat . map putWord32host . word32List 94 95 96------------------------------------------------------------------------ 97-- Word64 98------------------------------------------------------------------------ 99 100word64List :: Int -> [Word64] 101word64List n = [0..fromIntegral (n-1)] 102 103------------------------------------------------------------------------ 104-- Big endian, word16 writes 105 106writeWord64N1Big = mconcat . map putWord64be . word64List 107 108 109------------------------------------------------------------------------ 110-- Little endian, word64 writes 111 112writeWord64N1Little = mconcat . map putWord64le . word64List 113 114------------------------------------------------------------------------ 115-- Host endian, unaligned, word64 writes 116 117writeWord64N1Host = mconcat . map putWord64host . word64List 118 119