OpenAFP.Types.Chunk

This module handles pre-parsed "chunks" in AFP files.

Documentation

type NStr = Buffer0

type AStr = NStr

type ChunkWriter c = WriterT (ChunkQueue c)

type WriterStateIO v a = forall c m. (Chunk c, MonadReader v m) => ChunkWriter c m a

nullForeignPtr :: ForeignPtr a

_NStr :: NStr

packAStr :: AStr -> ByteString

fromAStr :: AStr -> String

toAStr :: String -> AStr

packNStr :: NStr -> ByteString

fromNStr :: NStr -> [N1]

toNStr :: [N1] -> NStr

newtype ChunkType

Constructors

MkChunkType TypeRep

Instances

Eq ChunkType

Methods

(==) :: ChunkType -> ChunkType -> Bool

(/=) :: ChunkType -> ChunkType -> Bool

Ord ChunkType

Methods

compare :: ChunkType -> ChunkType -> Ordering

(<) :: ChunkType -> ChunkType -> Bool

(<=) :: ChunkType -> ChunkType -> Bool

(>) :: ChunkType -> ChunkType -> Bool

(>=) :: ChunkType -> ChunkType -> Bool

max :: ChunkType -> ChunkType -> ChunkType

min :: ChunkType -> ChunkType -> ChunkType

Show ChunkType

Methods

showsPrec :: Int -> ChunkType -> ShowS

show :: ChunkType -> String

showList :: [ChunkType] -> ShowS

mkChunkType :: TypeRep -> ChunkType

typeInt :: TypeRep -> Int

chunkTypeOf :: Typeable a => a -> ChunkType

class (Show c, Typeable c, Buf (BufOf c), Enum (N c), Num (N c)) => Chunk c where

The Chunk class represents non-parsed chunks, constructed from a (ChunkType, Buffer) tuple.

Minimal complete definition

chunkApply, chunkDecon, chunkTypeLookup

Associated Types

type N c

type BufOf c

Methods

chunkApply :: N c -> c -> (forall a. Rec a => a -> x) -> x

mkChunk :: N c -> BufOf c -> c

chunkCon :: (N c, BufOf c) -> c

chunkDecon :: c -> (N c, BufOf c)

chunkType :: c -> ChunkType

chunkTypeLookup :: c -> N c -> ChunkType

packChunk :: c -> PStringLen

chunkMapFiltersM_ :: Monad m => c -> [(ChunkType, c -> m [c])] -> m ()

chunkMapFiltersM :: Monad m => c -> [(ChunkType, c -> m [c])] -> m [c]

chunksMapFiltersM :: Monad m => [c] -> [(ChunkType, c -> m [c])] -> m [c]

chunksMapFiltersM_ :: Monad m => [c] -> [(ChunkType, c -> m [c])] -> m ()

decodeChunk :: Binary (Record r) => c -> r

encodeChunk :: (Binary r, Storable r, Rec r) => r -> c

class (Rec r, Chunk (ChunkOf r)) => RecChunk r where

The RecChunk class unifies a Rec (parent) with its contained chunk types (children).

Associated Types

type ChunkOf r

Methods

readChunks :: r -> [ChunkOf r]

writeChunks :: Monad m => r -> m [ChunkOf r] -> m r

class (Rec a, Rec b) => RecData a b where

The RecData class unifies a Rec (parent) with its contained Rec data type (children).

Associated Types

type DataOf a

type RecOf b

Methods

readData :: (DataOf a ~ b, RecOf b ~ a) => a -> [Record b]

writeData :: (DataOf a ~ b, RecOf b ~ a) => a -> [Record b] -> a

(~~) :: (Chunk c, Typeable t) => c -> t -> Bool infixl 4

(<~~) :: (Monad m, Chunk c, Typeable t, Rec r) => t -> [c] -> m r infixl 4

(~~>) :: (Monad m, Chunk c, Typeable t, Rec r) => [c] -> t -> m r infixl 4

(==>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m [c] infixl 4

(<==) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m [c] infixl 4

(..>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m () infixl 4

(<..) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m () infixl 4

(===) :: (Chunk c, Rec r, Monad m) => r -> (r -> ChunkWriter c m a) -> (ChunkType, c -> m [c]) infixr 4

processChunk :: (Monad m, Rec r, Chunk c) => r -> (r -> ChunkWriter c m a) -> c -> m [c]

(...) :: (Chunk c, Rec a, Monad m) => a -> (a -> m t) -> (ChunkType, c -> m [c]) infixr 4

(....) :: (Monad (t m), Monad m, MonadTrans t, Chunk c, Rec a) => a -> (a -> m t1) -> (ChunkType, c -> t m [c]) infixr 4

(.....) :: (Monad (t m), Monad (t1 (t m)), Monad m, MonadTrans t, MonadTrans t1, Chunk c, Rec a) => a -> (a -> m t2) -> (ChunkType, c -> t1 (t m) [c]) infixr 4

inspectChunk :: (Monad m, Rec a, Chunk c) => a -> (a -> m t) -> c -> m [c]

push :: (Chunk c, Monad m, Rec a) => a -> ChunkWriter c m ()

filterChunks :: (Monad m, RecChunk r, Chunk c) => r -> [(ChunkType, ChunkOf r -> ChunkWriter c m [ChunkOf r])] -> ChunkWriter c m ()

data ChunkQueue a

Constructors

ChunkQueue [a]

ChunkItem a

Instances

Show a => Show (ChunkQueue a)

Methods

showsPrec :: Int -> ChunkQueue a -> ShowS

show :: ChunkQueue a -> String

showList :: [ChunkQueue a] -> ShowS

Monoid (ChunkQueue a)

Methods

mempty :: ChunkQueue a

mappend :: ChunkQueue a -> ChunkQueue a -> ChunkQueue a

mconcat :: [ChunkQueue a] -> ChunkQueue a

Orphan instances

Storable NStr

Methods

sizeOf :: NStr -> Int

alignment :: NStr -> Int

peekElemOff :: Ptr NStr -> Int -> IO NStr

pokeElemOff :: Ptr NStr -> Int -> NStr -> IO ()

peekByteOff :: Ptr b -> Int -> IO NStr

pokeByteOff :: Ptr b -> Int -> NStr -> IO ()

peek :: Ptr NStr -> IO NStr

poke :: Ptr NStr -> NStr -> IO ()

(Rec a, Binary a) => Storable [a]

Methods

sizeOf :: [a] -> Int

alignment :: [a] -> Int

peekElemOff :: Ptr [a] -> Int -> IO [a]

pokeElemOff :: Ptr [a] -> Int -> [a] -> IO ()

peekByteOff :: Ptr b -> Int -> IO [a]

pokeByteOff :: Ptr b -> Int -> [a] -> IO ()

peek :: Ptr [a] -> IO [a]

poke :: Ptr [a] -> [a] -> IO ()