Safe Haskell	None
Language	Haskell98

Data.Repa.Convert.Format

Contents

Packing single fields
Packable
- Unpackable

Description

This module provides the Format class definition, without exporting the pre-defined formats.

Synopsis

Packing single fields

class Format f where Source

Relates a storage format to the Haskell type of the value that is stored in that format.

Associated Types

type Value f Source

Get the type of a value with this format.

Methods

fieldCount :: f -> Int Source

Yield the number of separate fields in this format.

minSize :: f -> Int Source

Yield the minumum number of bytes that a value of this format will take up.

Packing a value into this format is guaranteed to use at least this many bytes. This is exact for fixed-size formats.

fixedSize :: f -> Maybe Int Source

For fixed size formats, yield their size (length) in bytes.

Yields Nothing if this is not a fixed size format.

packedSize :: f -> Value f -> Maybe Int Source

Yield the maximum packed size of the value in this format.

If fixedSize returns a size then packedSize returns the same size.

For variable length formats, packedSize is an over-approximation. We allow the actual packed value to use less space, as it may not be possible to determine how much space it needs without actually packing it.

Yields Nothing when a collection of values is to be packed into a fixed length format, but the size of the collection does not match the format.

Instances

Format Float64be Source
Format Float32be Source
Format Int64be Source
Format Word64be Source
Format Int32be Source
Format Word32be Source
Format Int16be Source
Format Word16be Source
Format Int8be Source
Format Word8be Source
Format VarBytes Source
Format DoubleFixedPack Source
Format DoubleAsc Source
Format IntAsc0 Source
Format IntAsc Source
Format DDsMMsYYYY Source
Format YYYYsMMsDD Source
Format ExactChars Source
Format VarCharString Source
Format VarChars Source
Format FixChars Source
Format VarTextString Source
Format VarText Source
Format UnitAsc Source
Format (App ()) Source
(Format f1, Format (App fs), (~) * (Value (App fs)) (Value fs)) => Format (App ((:*:) f1 fs)) Source
Format f => Format (MaybeBytes f) Source
Format f => Format (MaybeChars f) Source
Format (Sep ()) Source
(Format f1, Format (Sep fs), (~) * (Value (Sep fs)) (Value fs)) => Format (Sep ((:*:) f1 fs)) Source
(Format (ObjectFields fs), (~) * (Value (ObjectFields fs)) (Value fs)) => Format (Object fs) Source

Packable

class Format format => Packable format where Source

Class of storage formats that can have values packed and unpacked from foreign bufferes.

The methods are written using continuations to make it easier for GHC to optimise its core code when packing/unpacking many fields.

Minimal complete definition

packer

Methods

pack Source

Arguments

:: format	Storage format.
-> Value format	Value to pack.
-> Packer	Packer that can write the value.

Pack a value into a buffer using the given format.

packer Source

Arguments

:: format	Data format.
-> Value format	Value to pack.
-> Addr#	Pointer to start of buffer.
-> IO ()	Signal failure.
-> (Addr# -> IO ())	Accept the address after the packed field.
-> IO ()

Low level packing function for the given format.

Instances

Packable Float64be Source
Packable Float32be Source
Packable Int64be Source
Packable Word64be Source
Packable Int32be Source
Packable Word32be Source
Packable Int16be Source
Packable Word16be Source
Packable Int8be Source
Packable Word8be Source
Packable VarBytes Source
Packable DoubleFixedPack Source
Packable DoubleAsc Source
Packable IntAsc0 Source
Packable IntAsc Source
Packable DDsMMsYYYY Source
Packable YYYYsMMsDD Source
Packable ExactChars Source
Packable VarCharString Source
Packable VarChars Source
Packable FixChars Source
Packable VarTextString Source
Packable VarText Source
Packable UnitAsc Source
Packable (App ()) Source
(Packable f1, Packable (App fs), (~) * (Value (App fs)) (Value fs)) => Packable (App ((:*:) f1 fs)) Source
Packable f => Packable (MaybeBytes f) Source
Packable f => Packable (MaybeChars f) Source
Packable (Sep ()) Source
(Packable f1, Packable (Sep ((::) f2 fs)), (~) (Value (Sep ((::) f2 fs))) (Value ((::) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Packable (Sep ((::) f1 ((::) f2 fs))) Source
(Packable f1, (~) * (Value (Sep ())) (Value ())) => Packable (Sep ((:*:) f1 ())) Source
(Format (Object f), (~) * (Value (ObjectFields f)) (Value f), Packable (ObjectFields f)) => Packable (Object f) Source

data Packer Source

Packer wraps a function that can write to a buffer.

Constructors

Packer
Fields fromPacker :: Addr# -> IO () -> (Addr# -> IO ()) -> IO () Takes start of buffer; failure action; and a continuation. We try to pack data into the given buffer. If packing succeeds then we call the continuation with a pointer to the next byte after the packed value, otherwise we call the failure action.

Instances

Monoid Packer Source

unsafeRunPacker Source

Arguments

:: Packer	Packer to run.
-> Ptr Word8	Start of buffer.
-> IO (Maybe (Ptr Word8))	Pointer to the byte after the last one written.

Pack data into the given buffer.

PRECONDITION: The buffer needs to be big enough to hold the packed data, otherwise you'll corrupt the heap (bad). Use packedSize to work out how big it needs to be.

Unpackable

class Format format => Unpackable format where Source

Minimal complete definition

unpacker

Methods

unpack Source

Arguments

:: format	Storage format.
-> Unpacker (Value format)	Unpacker for that format.

Unpack a value from a buffer using the given format.

unpacker Source

Arguments

:: format	Data format.
-> Addr#	Start of buffer.
-> Addr#	Pointer to first byte after end of buffer.
-> (Word8 -> Bool)	Detect a field terminator.
-> IO ()	Signal failure.
-> (Addr# -> Value format -> IO ())	Accept an unpacked value.
-> IO ()

Low level unpacking function for the given format.

Instances

Unpackable Float64be Source
Unpackable Float32be Source
Unpackable Int64be Source
Unpackable Word64be Source
Unpackable Int32be Source
Unpackable Word32be Source
Unpackable Int16be Source
Unpackable Word16be Source
Unpackable Int8be Source
Unpackable Word8be Source
Unpackable VarBytes Source
Unpackable DoubleFixedPack Source
Unpackable DoubleAsc Source
Unpackable IntAsc0 Source
Unpackable IntAsc Source
Unpackable DDsMMsYYYY Source
Unpackable YYYYsMMsDD Source
Unpackable ExactChars Source
Unpackable VarCharString Source
Unpackable VarChars Source
Unpackable FixChars Source
Unpackable VarTextString Source
Unpackable VarText Source
Unpackable UnitAsc Source
Unpackable (App ()) Source
(Unpackable f1, Unpackable (App fs), (~) * (Value (App fs)) (Value fs)) => Unpackable (App ((:*:) f1 fs)) Source
Unpackable f => Unpackable (MaybeBytes f) Source
Unpackable f => Unpackable (MaybeChars f) Source
Unpackable (Sep ()) Source
(Unpackable f1, Unpackable (Sep ((::) f2 fs)), (~) (Value (Sep ((::) f2 fs))) (Value ((::) f2 fs)), (~) * (Value (Sep fs)) (Value fs)) => Unpackable (Sep ((::) f1 ((::) f2 fs))) Source
(Unpackable f1, (~) * (Value (Sep ())) (Value ())) => Unpackable (Sep ((:*:) f1 ())) Source

data Unpacker a Source

Constructors

Unpacker

Fields

fromUnpacker :: Addr# -> Addr# -> (Word8 -> Bool) -> IO () -> (Addr# -> a -> IO ()) -> IO ()

Takes pointers to the first byte in the buffer; the first byte after the buffer; a predicate to detect a field terminator; a failure action; and a continuation.

The field terminator is used by variable length encodings where the length of the encoded data cannot be determined from the encoding itself.

We try to unpack a value from the buffer. If unpacking succeeds then call the continuation with a pointer to the next byte after the unpacked value, and the value itself, otherwise call the failure action.

Instances

Monad Unpacker Source
Functor Unpacker Source
Applicative Unpacker Source

unsafeRunUnpacker Source

Arguments

:: Unpacker a	Unpacker to run.
-> Ptr Word8	Source buffer.
-> Int	Length of source buffer.
-> (Word8 -> Bool)	Detect a field terminator.
-> IO (Maybe (a, Ptr Word8))	Unpacked result, and pointer to the byte after the last one read.

Unpack data from the given buffer.

PRECONDITION: The buffer must be at least the minimum size of the format (minSize). This allows us to avoid repeatedly checking for buffer overrun when unpacking fixed size format. If the buffer is not long enough then you'll get an indeterminate result (bad).