-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Network byte order utilities
--   
--   Peek and poke functions for network byte order.
@package network-byte-order
@version 0.1.7

-- | Peek and poke functions for network byte order.
module Network.ByteOrder

-- | A pointer to Word8.
type Buffer = Ptr Word8

-- | Offset from the current pointer.
type Offset = Int

-- | Size of a buffer.
type BufferSize = Int

-- | Buffer overrun exception.
data BufferOverrun

-- | The buffer size is not enough
BufferOverrun :: BufferOverrun

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf (poke8 0)
--   
--   >>> unpack buf
--   [0,2,3,4]
--   
poke8 :: Word8 -> Buffer -> Offset -> IO ()

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf (poke16 (7*256 + 8))
--   
--   >>> unpack buf
--   [7,8,3,4]
--   
poke16 :: Word16 -> Buffer -> Offset -> IO ()

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf (poke24 (6*65536 + 7*256 + 8))
--   
--   >>> unpack buf
--   [6,7,8,4]
--   
poke24 :: Word32 -> Buffer -> Offset -> IO ()

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf (poke32 (6*65536 + 7*256 + 8))
--   
--   >>> unpack buf
--   [0,6,7,8]
--   
poke32 :: Word32 -> Buffer -> Offset -> IO ()

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> unsafeWithByteString buf (poke64 (6*65536 + 7*256 + 8))
--   
--   >>> unpack buf
--   [0,0,0,0,0,6,7,8]
--   
poke64 :: Word64 -> Buffer -> Offset -> IO ()

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf peek8
--   1
--   
peek8 :: Buffer -> Offset -> IO Word8

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf peek16
--   258
--   
peek16 :: Buffer -> Offset -> IO Word16

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf peek24
--   66051
--   
peek24 :: Buffer -> Offset -> IO Word32

-- | 
--   >>> let buf = pack [1,2,3,4]
--   
--   >>> unsafeWithByteString buf peek32
--   16909060
--   
peek32 :: Buffer -> Offset -> IO Word32

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> unsafeWithByteString buf peek64
--   72623859790382856
--   
peek64 :: Buffer -> Offset -> IO Word64
peekByteString :: Buffer -> Int -> IO ByteString

-- | 
--   >>> let w = 5 :: Word8
--   
--   >>> unpack $ bytestring8 w
--   [5]
--   
bytestring8 :: Word8 -> ByteString

-- | 
--   >>> let w = foldl' (\x y -> x * 256 + y) 0 [5,6] :: Word16
--   
--   >>> unpack $ bytestring16 w
--   [5,6]
--   
bytestring16 :: Word16 -> ByteString

-- | 
--   >>> let w = foldl' (\x y -> x * 256 + y) 0 [5,6,7,8] :: Word32
--   
--   >>> unpack $ bytestring32 w
--   [5,6,7,8]
--   
bytestring32 :: Word32 -> ByteString

-- | 
--   >>> let w = foldl' (\x y -> x * 256 + y) 0 [1,2,3,4,5,6,7,8] :: Word64
--   
--   >>> unpack $ bytestring64 w
--   [1,2,3,4,5,6,7,8]
--   
bytestring64 :: Word64 -> ByteString

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> word8 buf
--   1
--   
word8 :: ByteString -> Word8

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> word16 buf
--   258
--   
word16 :: ByteString -> Word16

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> word32 buf
--   16909060
--   
word32 :: ByteString -> Word32

-- | 
--   >>> let buf = pack [1,2,3,4,5,6,7,8]
--   
--   >>> word64 buf
--   72623859790382856
--   
word64 :: ByteString -> Word64

-- | Using ByteString as Buffer and call the IO action
--   of the second argument by passing the start point and the offset of
--   the ByteString. Note that if a ByteString is created
--   newly, its offset is 0.
unsafeWithByteString :: ByteString -> (Buffer -> Offset -> IO a) -> IO a

-- | Copying the bytestring to the buffer. This function returns the point
--   where the next copy should start.
--   
--   
--   >>> let buf = "abc" :: ByteString
--   
--   >>> unsafeWithByteString buf $ \ptr _ -> Network.ByteOrder.copy ptr "ABC" >> return buf
--   "ABC"
--   
copy :: Buffer -> ByteString -> IO Buffer

-- | Converting the part of buffer to ByteString and executing the
--   action with it.
--   
--   
--   >>> let buf = "abcdef" :: ByteString
--   
--   >>> unsafeWithByteString buf $ \ptr _-> bufferIO ptr 2 return
--   "ab"
--   
bufferIO :: Buffer -> Int -> (ByteString -> IO a) -> IO a
class Readable a

-- | Reading one byte as Word8 and ff one byte.
read8 :: Readable a => a -> IO Word8

-- | Reading one byte as Int and ff one byte. If buffer overrun
--   occurs, -1 is returned.
readInt8 :: Readable a => a -> IO Int

-- | Fast forward the offset pointer. The boundary is not checked.
ff :: Readable a => a -> Offset -> IO ()

-- | Returning the length of the remaining
remainingSize :: Readable a => a -> IO Int

-- | Executing an action on the current offset pointer.
position :: Readable a => a -> IO Int
withCurrentOffSet :: Readable a => a -> (Buffer -> IO b) -> IO b

-- | Memorizing the current offset pointer.
save :: Readable a => a -> IO ()

-- | Getting how many bytes from the saved offset pinter.
savingSize :: Readable a => a -> IO Int

-- | Moving the offset point to the saved point.
goBack :: Readable a => a -> IO ()

-- | Read only buffer. To ensure that the internal is not modified, this is
--   an abstract data type.
data ReadBuffer

-- | Creating a read buffer with the given buffer.
newReadBuffer :: Buffer -> BufferSize -> IO ReadBuffer

-- | Converting ByteString to ReadBuffer and run the action
--   with it.
withReadBuffer :: ByteString -> (ReadBuffer -> IO a) -> IO a

-- | Reading two bytes as Word16 and ff two bytes.
--   
--   
--   >>> withReadBuffer "\x0\x1\x2\x3" $ read16
--   1
--   
read16 :: Readable a => a -> IO Word16

-- | Reading three bytes as Word32 and ff three bytes.
--   
--   
--   >>> withReadBuffer "\x0\x1\x2\x3" $ read24
--   258
--   
read24 :: Readable a => a -> IO Word32

-- | Reading four bytes as Word32 and ff four bytes.
--   
--   
--   >>> withReadBuffer "\x0\x1\x2\x3" $ read32
--   66051
--   
read32 :: Readable a => a -> IO Word32

-- | Reading four bytes as Word64 and ff four bytes.
read64 :: Readable a => a -> IO Word64

-- | Extracting ByteString from the current offset. The contents is
--   copied, not shared. Its length is specified by the 2nd argument. If
--   the length is positive, the area after the current pointer is
--   extracted and FF the length finally. If the length is negative, the
--   area before the current pointer is extracted and does not FF.
--   
--   
--   >>> withReadBuffer "abcdefg" $ \rbuf -> ff rbuf 1 >> extractByteString rbuf 2
--   "bc"
--   
extractByteString :: Readable a => a -> Int -> IO ByteString

-- | Extracting ShortByteString from the current offset. The
--   contents is copied, not shared. Its length is specified by the 2nd
--   argument. If the length is positive, the area after the current
--   pointer is extracted and FF the length finally. If the length is
--   negative, the area before the current pointer is extracted and does
--   not FF.
--   
--   
--   >>> withReadBuffer "abcdefg" $ \rbuf -> ff rbuf 2 >> extractShortByteString rbuf 3
--   "cde"
--   
extractShortByteString :: Readable a => a -> Int -> IO ShortByteString

-- | Read and write buffer.
data WriteBuffer
WriteBuffer :: Buffer -> Buffer -> IORef Buffer -> IORef Buffer -> WriteBuffer
[start] :: WriteBuffer -> Buffer
[limit] :: WriteBuffer -> Buffer
[offset] :: WriteBuffer -> IORef Buffer
[oldoffset] :: WriteBuffer -> IORef Buffer

-- | Creating a write buffer with the given buffer.
newWriteBuffer :: Buffer -> BufferSize -> IO WriteBuffer

-- | Reseting a write buffer.
clearWriteBuffer :: WriteBuffer -> IO ()

-- | Allocate a temporary buffer and copy the result to ByteString.
withWriteBuffer :: BufferSize -> (WriteBuffer -> IO ()) -> IO ByteString

-- | Allocate a temporary buffer and copy the result to ByteString
--   with an additional value.
--   
--   
--   >>> withWriteBuffer' 1 $ \wbuf -> write8 wbuf 65 >> return 'a'
--   ("A",'a')
--   
withWriteBuffer' :: BufferSize -> (WriteBuffer -> IO a) -> IO (ByteString, a)

-- | Write one byte and ff one byte. If buffer overrun occurs,
--   BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 1 $ \wbuf -> write8 wbuf 65
--   "A"
--   
write8 :: WriteBuffer -> Word8 -> IO ()

-- | Write two bytes and ff one byte. If buffer overrun occurs,
--   BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 2 $ \wbuf -> write16 wbuf (65 * 256 + 66)
--   "AB"
--   
write16 :: WriteBuffer -> Word16 -> IO ()

-- | Write three bytes and ff one byte. If buffer overrun occurs,
--   BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 3 $ \wbuf -> write24 wbuf (65 * 256^(2 :: Int) + 66 * 256 + 67)
--   "ABC"
--   
write24 :: WriteBuffer -> Word32 -> IO ()

-- | Write four bytes and ff one byte. If buffer overrun occurs,
--   BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 4 $ \wbuf -> write32 wbuf (65 * 256^(3 :: Int) + 66 * 256^(2 :: Int) + 67 * 256 + 68)
--   "ABCD"
--   
write32 :: WriteBuffer -> Word32 -> IO ()

-- | Write four bytes and ff one byte. If buffer overrun occurs,
--   BufferOverrun is thrown.
write64 :: WriteBuffer -> Word64 -> IO ()

-- | Copy the content of ByteString and ff its length. If buffer
--   overrun occurs, BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 3 $ \wbuf -> copyByteString wbuf "ABC"
--   "ABC"
--   
copyByteString :: WriteBuffer -> ByteString -> IO ()

-- | Copy the content of ShortByteString and ff its length. If
--   buffer overrun occurs, BufferOverrun is thrown.
--   
--   
--   >>> withWriteBuffer 5 $ \wbuf -> copyShortByteString wbuf "ABCEF"
--   "ABCEF"
--   
copyShortByteString :: WriteBuffer -> ShortByteString -> IO ()

-- | Shifting the N-bytes area just before the current pointer (the 3rd
--   argument). If the second argument is positive, shift it to right. If
--   it is negative, shift it to left. offset moves as if it is
--   sticky to the area.
--   
--   
--   >>> withWriteBuffer 16 $ \wbuf -> copyByteString wbuf "ABCD" >> shiftLastN wbuf 1 3
--   "ABBCD"
--   
--   >>> withWriteBuffer 16 $ \wbuf -> copyByteString wbuf "ABCD" >> shiftLastN wbuf 2 3
--   "ABCBCD"
--   
--   >>> withWriteBuffer 16 $ \wbuf -> copyByteString wbuf "ABCDE" >> shiftLastN wbuf (-2) 3 >> ff wbuf 2
--   "CDEDE"
--   
shiftLastN :: WriteBuffer -> Int -> Int -> IO ()

-- | Copy the area from start to the current pointer to
--   ByteString.
toByteString :: WriteBuffer -> IO ByteString

-- | Copy the area from start to the current pointer to
--   ShortByteString.
toShortByteString :: WriteBuffer -> IO ShortByteString

-- | Getting the offset pointer.
currentOffset :: WriteBuffer -> IO Buffer

-- | 8-bit unsigned integer type
data Word8

-- | 16-bit unsigned integer type
data Word16

-- | 32-bit unsigned integer type
data Word32

-- | 64-bit unsigned integer type
data Word64

-- | A space-efficient representation of a Word8 vector, supporting
--   many efficient operations.
--   
--   A ByteString contains 8-bit bytes, or by using the operations
--   from Data.ByteString.Char8 it can be interpreted as containing
--   8-bit characters.
data ByteString
instance GHC.Classes.Eq Network.ByteOrder.BufferOverrun
instance GHC.Internal.Exception.Type.Exception Network.ByteOrder.BufferOverrun
instance Network.ByteOrder.Readable Network.ByteOrder.ReadBuffer
instance Network.ByteOrder.Readable Network.ByteOrder.WriteBuffer
instance GHC.Internal.Show.Show Network.ByteOrder.BufferOverrun
