module Data.MessagePack(
module Data.MessagePack.Object,
module Data.MessagePack.Put,
module Data.MessagePack.Parser,
module Data.MessagePack.Iteratee,
pack,
unpack,
packToString,
packToHandle,
packToHandle',
packToFile,
unpackFromString,
unpackFromHandle,
unpackFromFile,
unpackFromStringI,
unpackFromHandleI,
unpackFromFileI,
) where
import qualified Control.Monad.CatchIO as CIO
import Control.Monad.IO.Class
import qualified Data.Attoparsec as A
import Data.Binary.Put
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L
import Data.Functor.Identity
import qualified Data.Iteratee as I
import System.IO
import Data.MessagePack.Object
import Data.MessagePack.Put
import Data.MessagePack.Parser
import Data.MessagePack.Iteratee
bufferSize :: Int
bufferSize = 4 * 1024
class IsByteString s where
toBS :: s -> B.ByteString
instance IsByteString B.ByteString where
toBS = id
instance IsByteString L.ByteString where
toBS = B.concat . L.toChunks
pack :: ObjectPut a => a -> L.ByteString
pack = packToString . put
unpack :: (ObjectGet a, IsByteString s) => s -> a
unpack bs =
runIdentity $ I.run $ I.joinIM $ I.enumPure1Chunk (toBS bs) getI
packToString :: Put -> L.ByteString
packToString = runPut
packToHandle :: Handle -> Put -> IO ()
packToHandle h = L.hPutStr h . packToString
packToHandle' :: Handle -> Put -> IO ()
packToHandle' h p = packToHandle h p >> hFlush h
packToFile :: FilePath -> Put -> IO ()
packToFile path = L.writeFile path . packToString
unpackFromString :: (Monad m, IsByteString s) => s -> A.Parser a -> m a
unpackFromString bs =
unpackFromStringI bs . parserToIteratee
unpackFromHandle :: CIO.MonadCatchIO m => Handle -> A.Parser a -> m a
unpackFromHandle h =
unpackFromHandleI h .parserToIteratee
unpackFromFile :: CIO.MonadCatchIO m => FilePath -> A.Parser a -> m a
unpackFromFile path =
unpackFromFileI path . parserToIteratee
unpackFromStringI :: (Monad m, IsByteString s) => s -> I.Iteratee B.ByteString m a -> m a
unpackFromStringI bs =
I.run . I.joinIM . I.enumPure1Chunk (toBS bs)
unpackFromHandleI :: CIO.MonadCatchIO m => Handle -> I.Iteratee B.ByteString m a -> m a
unpackFromHandleI h =
I.run . I.joinIM . enumHandleNonBlocking bufferSize h
unpackFromFileI :: CIO.MonadCatchIO m => FilePath -> I.Iteratee B.ByteString m a -> m a
unpackFromFileI path p =
CIO.bracket
(liftIO $ openBinaryFile path ReadMode)
(liftIO . hClose)
(flip unpackFromHandleI p)