cereal 0.5.3.0 → 0.5.4.0

raw patch · 4 files changed

+148/−50 lines, 4 filesdep +bytestring-builderdep ~bytestringPVP ok

version bump matches the API change (PVP)

Dependencies added: bytestring-builder

Dependency ranges changed: bytestring

API changes (from Hackage documentation)

Files

• cereal.cabal +17/−4
• src/Data/Serialize.hs +13/−13
• src/Data/Serialize/Get.hs +1/−11
• src/Data/Serialize/Put.hs +117/−22

@@ -1,5 +1,5 @@ name:                   cereal-version:                0.5.3.0+version:                0.5.4.0 license:                BSD3 license-file:           LICENSE author:                 Lennart Kolmodin <kolmodin@dtek.chalmers.se>,@@ -25,16 +25,29 @@   type:     git   location: git://github.com/GaloisInc/cereal.git +flag bytestring-builder+  description:+    Decides whether to use an older version of bytestring along with bytestring-builder or just a newer version of bytestring.+    .+    This flag normally toggles automatically but you can use `-fbytestring-builder` or `-f-bytestring-builder` to explicitly change it.+  default: False+  manual: False+ library         default-language:       Haskell2010 -        build-depends:          bytestring >= 0.10.2.0,-                                base >= 4.4 && < 5, containers, array,+        build-depends:          base >= 4.4 && < 5, containers, array,                                 ghc-prim >= 0.2          if !impl(ghc >= 8.0)           build-depends:        fail == 4.9.* +        if flag(bytestring-builder)+          build-depends:        bytestring >= 0.9    && < 0.10.4,+                                bytestring-builder >= 0.10.4 && < 1+        else+          build-depends:        bytestring >= 0.10.4 && < 1+         hs-source-dirs:         src          exposed-modules:        Data.Serialize,@@ -52,7 +65,7 @@         type:                   exitcode-stdio-1.0          build-depends:          base == 4.*,-                                bytestring >= 0.10.8.1,+                                bytestring >= 0.9,                                 QuickCheck,                                 test-framework,                                 test-framework-quickcheck2,

@@ -16,7 +16,7 @@ -- Module      : Data.Serialize -- Copyright   : Lennart Kolmodin, Galois Inc. 2009 -- License     : BSD3-style (see LICENSE)--- +-- -- Maintainer  : Trevor Elliott <trevor@galois.com> -- Stability   : -- Portability :@@ -199,23 +199,23 @@  -- Int8s are written as a single byte. instance Serialize Int8 where-    put i   = put (fromIntegral i :: Word8)-    get     = liftM fromIntegral (get :: Get Word8)+    put     = putInt8+    get     = getInt8  -- Int16s are written as a 2 bytes in big endian format instance Serialize Int16 where-    put i   = put (fromIntegral i :: Word16)-    get     = liftM fromIntegral (get :: Get Word16)+    put     = putInt16be+    get     = getInt16be  -- Int32s are written as a 4 bytes in big endian format instance Serialize Int32 where-    put i   = put (fromIntegral i :: Word32)-    get     = liftM fromIntegral (get :: Get Word32)+    put     = putInt32be+    get     = getInt32be  -- Int64s are written as a 8 bytes in big endian format instance Serialize Int64 where-    put i   = put (fromIntegral i :: Word64)-    get     = liftM fromIntegral (get :: Get Word64)+    put     = putInt64be+    get     = getInt64be  ------------------------------------------------------------------------ @@ -230,7 +230,7 @@     get     = liftM fromIntegral (get :: Get Int64)  --------------------------------------------------------------------------- +-- -- Portable, and pretty efficient, serialisation of Integer -- @@ -312,7 +312,7 @@  ------------------------------------------------------------------------ --- Safely wrap `chr` to avoid exceptions. +-- Safely wrap `chr` to avoid exceptions. -- `chr` source: http://hackage.haskell.org/package/base-4.7.0.2/docs/src/GHC-Char.html#chr chrEither :: Int -> Either String Char chrEither i@@ -362,7 +362,7 @@                                 return (z .|. shiftL6 (y .|. shiftL6                                         (x .|. shiftL6 (xor 0xf0 w))))         case chrEither r of-            Right r' -> +            Right r' ->                 return $! r'             Left err ->                 fail err@@ -388,7 +388,7 @@     put (a,b,c,d,e)     = put a >> put b >> put c >> put d >> put e     get                 = liftM5 (,,,,) get get get get get --- +-- -- and now just recurse: -- 

@@ -59,10 +59,7 @@     -- ** ByteStrings     , getByteString     , getLazyByteString--#if MIN_VERSION_bytestring(0,10,4)     , getShortByteString-#endif      -- ** Big-endian reads     , getWord16be@@ -116,6 +113,7 @@ import qualified Data.ByteString.Internal as B import qualified Data.ByteString.Unsafe   as B import qualified Data.ByteString.Lazy     as L+import qualified Data.ByteString.Short    as BS import qualified Data.IntMap              as IntMap import qualified Data.IntSet              as IntSet import qualified Data.Map                 as Map@@ -123,12 +121,6 @@ import qualified Data.Set                 as Set import qualified Data.Tree                as T --#if MIN_VERSION_bytestring(0,10,4)-import qualified Data.ByteString.Short as BS-#endif-- #if defined(__GLASGOW_HASKELL__) && !defined(__HADDOCK__) import GHC.Base import GHC.Word@@ -511,12 +503,10 @@ getLazyByteString n = f `fmap` getByteString (fromIntegral n)   where f bs = L.fromChunks [bs] -#if MIN_VERSION_bytestring(0,10,4) getShortByteString :: Int -> Get BS.ShortByteString getShortByteString n = do   bs <- getBytes n   return $! BS.toShort bs-#endif   ------------------------------------------------------------------------

@@ -1,3 +1,4 @@+{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-} @@ -14,7 +15,7 @@ -- Module      : Data.Serialize.Put -- Copyright   : Lennart Kolmodin, Galois Inc. 2009 -- License     : BSD3-style (see LICENSE)--- +-- -- Maintainer  : Trevor Elliott <trevor@galois.com> -- Stability   : -- Portability :@@ -41,28 +42,36 @@      -- * Primitives     , putWord8+    , putInt8     , putByteString     , putLazyByteString--#if MIN_VERSION_bytestring(0,10,4)     , putShortByteString-#endif      -- * Big-endian primitives     , putWord16be     , putWord32be     , putWord64be+    , putInt16be+    , putInt32be+    , putInt64be      -- * Little-endian primitives     , putWord16le     , putWord32le     , putWord64le+    , putInt16le+    , putInt32le+    , putInt64le      -- * Host-endian, unaligned writes     , putWordhost     , putWord16host     , putWord32host     , putWord64host+    , putInthost+    , putInt16host+    , putInt32host+    , putInt64host      -- * Containers     , putTwoOf@@ -81,27 +90,17 @@   ) where  -#if MIN_VERSION_bytestring(0,10,2) import           Data.ByteString.Builder (Builder, toLazyByteString) import qualified Data.ByteString.Builder as B import qualified Data.ByteString.Builder.Extra as B-#elif MIN_VERSION_bytestring(0,10,0)-import           Data.ByteString.Lazy.Builder (Builder, toLazyByteString)-import qualified Data.ByteString.Lazy.Builder as B-import qualified Data.ByteString.Lazy.Builder.Extras as B-#else-#error "cereal requires bytestring >= 0.10.0.0"-#endif--#if MIN_VERSION_bytestring(0,10,4) import qualified Data.ByteString.Short as BS-#endif  import qualified Control.Applicative as A import Data.Array.Unboxed import qualified Data.Monoid as M import qualified Data.Foldable as F import Data.Word+import Data.Int import qualified Data.ByteString        as S import qualified Data.ByteString.Lazy   as L import qualified Data.IntMap            as IntMap@@ -117,9 +116,17 @@ import Data.Monoid #endif +#if !(MIN_VERSION_bytestring(0,10,0))+import Foreign.ForeignPtr (withForeignPtr)+import Foreign.Marshal.Utils (copyBytes)+import Foreign.Ptr (plusPtr)+import qualified Data.ByteString.Internal as S+import qualified Data.ByteString.Lazy.Internal as L+#endif+ ------------------------------------------------------------------------ --- XXX Strict in builder only. +-- XXX Strict in builder only. data PairS a = PairS a !Builder  sndS :: PairS a -> Builder@@ -190,12 +197,12 @@  -- | Run the 'Put' monad with a serialiser runPut :: Put -> S.ByteString-runPut = L.toStrict . runPutLazy+runPut = lazyToStrictByteString . runPutLazy {-# INLINE runPut #-}  -- | Run the 'Put' monad with a serialiser and get its result runPutM :: PutM a -> (a, S.ByteString)-runPutM (Put (PairS f s)) = (f, L.toStrict (toLazyByteString s))+runPutM (Put (PairS f s)) = (f, lazyToStrictByteString (toLazyByteString s)) {-# INLINE runPutM #-}  -- | Run the 'Put' monad with a serialiser@@ -221,16 +228,19 @@ putWord8            = tell . B.word8 {-# INLINE putWord8 #-} +-- | Efficiently write an int into the output buffer+putInt8             :: Putter Int8+putInt8             = tell . B.int8+{-# INLINE putInt8 #-}+ -- | An efficient primitive to write a strict ByteString into the output buffer. -- It flushes the current buffer, and writes the argument into a new chunk. putByteString       :: Putter S.ByteString putByteString       = tell . B.byteString {-# INLINE putByteString #-} -#if MIN_VERSION_bytestring(0,10,4) putShortByteString  :: Putter BS.ShortByteString putShortByteString   = tell . B.shortByteString-#endif  -- | Write a lazy ByteString efficiently, simply appending the lazy -- ByteString chunks to the output buffer@@ -299,7 +309,68 @@ putWord64host       = tell . B.word64Host {-# INLINE putWord64host #-} +-- | Write a Int16 in big endian format+putInt16be         :: Putter Int16+putInt16be         = tell . B.int16BE+{-# INLINE putInt16be #-} +-- | Write a Int16 in little endian format+putInt16le         :: Putter Int16+putInt16le         = tell . B.int16LE+{-# INLINE putInt16le #-}++-- | Write a Int32 in big endian format+putInt32be         :: Putter Int32+putInt32be         = tell . B.int32BE+{-# INLINE putInt32be #-}++-- | Write a Int32 in little endian format+putInt32le         :: Putter Int32+putInt32le         = tell . B.int32LE+{-# INLINE putInt32le #-}++-- | Write a Int64 in big endian format+putInt64be         :: Putter Int64+putInt64be         = tell . B.int64BE+{-# INLINE putInt64be #-}++-- | Write a Int64 in little endian format+putInt64le         :: Putter Int64+putInt64le         = tell . B.int64LE+{-# INLINE putInt64le #-}++------------------------------------------------------------------------++-- | /O(1)./ Write a single native machine int. The int is+-- written in host order, host endian form, for the machine you're on.+-- On a 64 bit machine the Int is an 8 byte value, on a 32 bit machine,+-- 4 bytes. Values written this way are not portable to+-- different endian or int sized machines, without conversion.+--+putInthost         :: Putter Int+putInthost         = tell . B.intHost+{-# INLINE putInthost #-}++-- | /O(1)./ Write a Int16 in native host order and host endianness.+-- For portability issues see @putInthost@.+putInt16host       :: Putter Int16+putInt16host       = tell . B.int16Host+{-# INLINE putInt16host #-}++-- | /O(1)./ Write a Int32 in native host order and host endianness.+-- For portability issues see @putInthost@.+putInt32host       :: Putter Int32+putInt32host       = tell . B.int32Host+{-# INLINE putInt32host #-}++-- | /O(1)./ Write a Int64 in native host order+-- On a 32 bit machine we write two host order Int32s, in big endian form.+-- For portability issues see @putInthost@.+putInt64host       :: Putter Int64+putInt64host       = tell . B.int64Host+{-# INLINE putInt64host #-}++ -- Containers ------------------------------------------------------------------  encodeListOf :: (a -> Builder) -> [a] -> Builder@@ -326,12 +397,12 @@  putSeqOf :: Putter a -> Putter (Seq.Seq a) putSeqOf pa = \s -> do-    putWord64be (fromIntegral $ Seq.length s) +    putWord64be (fromIntegral $ Seq.length s)     F.mapM_ pa s {-# INLINE putSeqOf #-}  putTreeOf :: Putter a -> Putter (T.Tree a)-putTreeOf pa = +putTreeOf pa =     tell . go   where     go (T.Node x cs) = execPut (pa x) `M.mappend` encodeListOf go cs@@ -370,3 +441,27 @@     let bs = runPut putVal     putLen (S.length bs)     putByteString bs++-------------------------------------------------------------------------------+-- pre-bytestring-0.10 compatibility+-------------------------------------------------------------------------------++{-# INLINE lazyToStrictByteString #-}+lazyToStrictByteString :: L.ByteString -> S.ByteString+#if MIN_VERSION_bytestring(0,10,0)+lazyToStrictByteString = L.toStrict+#else+lazyToStrictByteString = packChunks++-- packChunks is taken from the blaze-builder package.++-- | Pack the chunks of a lazy bytestring into a single strict bytestring.+packChunks :: L.ByteString -> S.ByteString+packChunks lbs = S.unsafeCreate (fromIntegral $ L.length lbs) (copyChunks lbs)+  where+    copyChunks !L.Empty                         !_pf = return ()+    copyChunks !(L.Chunk (S.PS fpbuf o l) lbs') !pf  = do+        withForeignPtr fpbuf $ \pbuf ->+            copyBytes pf (pbuf `plusPtr` o) l+        copyChunks lbs' (pf `plusPtr` l)+#endif