Data.Packed

Classes

class Packable a where

Methods

write :: forall (r :: [Type]) (t :: [Type]). a -> NeedsWriter a r t

Instances

Packable FieldSize

Defined in Data.Packed.FieldSize

Methods

write :: forall (r :: [Type]) (t :: [Type]). FieldSize -> NeedsWriter FieldSize r t

Storable a => Packable a

Defined in Data.Packed.Packable

Methods

write :: forall (r :: [Type]) (t :: [Type]). a -> NeedsWriter a r t

Packable a => Packable (Maybe a)

Defined in Data.Packed.Instances

Methods

write :: forall (r :: [Type]) (t :: [Type]). Maybe a -> NeedsWriter (Maybe a) r t

Packable a => Packable [a]

Defined in Data.Packed.Instances

Methods

write :: forall (r :: [Type]) (t :: [Type]). [a] -> NeedsWriter [a] r t

(Packable a, Packable b) => Packable (Either a b)

Defined in Data.Packed.Instances

Methods

write :: forall (r :: [Type]) (t :: [Type]). Either a b -> NeedsWriter (Either a b) r t

pack :: Packable a => a -> Packed '[a]

class Unpackable a where

An Unpackable is a value that can be read (i.e. deserialised) from a Packed value

Methods

reader :: forall (r :: [Type]). PackedReader '[a] r a

The PackedReader to unpack a value of that type

Instances

Unpackable FieldSize

Defined in Data.Packed.FieldSize

Methods

reader :: forall (r :: [Type]). PackedReader '[FieldSize] r FieldSize

Storable a => Unpackable a

Defined in Data.Packed.Unpackable

Methods

reader :: forall (r :: [Type]). PackedReader '[a] r a

Unpackable a => Unpackable (Maybe a)

Defined in Data.Packed.Instances

Methods

reader :: forall (r :: [Type]). PackedReader '[Maybe a] r (Maybe a)

Unpackable a => Unpackable [a]

Defined in Data.Packed.Instances

Methods

reader :: forall (r :: [Type]). PackedReader '[[a]] r [a]

(Unpackable a, Unpackable b) => Unpackable (Either a b)

Defined in Data.Packed.Instances

Methods

reader :: forall (r :: [Type]). PackedReader '[Either a b] r (Either a b)

readerWithoutShift :: forall a (r :: [Type]). Unpackable a => PackedReader (a ': r) (a ': r) a

In a PackedReader, reads a value without moving the cursor

unpack :: forall a (r :: [Type]). Unpackable a => Packed (a ': r) -> (a, Packed r)

Deserialise a value from a Packed.

Returns the unconsumed Packed portion

unpack' :: forall a (r :: [Type]). Unpackable a => Packed (a ': r) -> a

Same as unpack, but throws away the unconsumed bytes

Needs

data Needs (p :: [Type]) (t :: [Type])

A buffer where packed values can be written The order to write these values is defined by the l type list

If p is an empty list, then a value of type t can be extracted from that buffer. (See finish)

withEmptyNeeds :: forall (a :: [Type]) (b :: [Type]) (x :: [Type]) (y :: [Type]). NeedsBuilder a b x y -> Needs x y

writeWithFieldSize :: forall a (r :: [Type]) (t :: [Type]). Packable a => a -> NeedsWriter' '[FieldSize, a] r t

Write a value into a Needs, along with its FieldSize

Note: Universal quantifier is nedded for GHC < 9.10, because of ScopedTypeVariables

finish :: forall (t :: [Type]). Needs ('[] :: [Type]) t -> Packed t

Turns a Needs value (that does not expect to be written to) to a Packed

unsafeCastNeeds :: forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (d :: [Type]). Needs a b -> Needs c d

Packed

data Packed (l :: [Type])

A buffer that contains one or more packed (i.e. serialised) values. The order of the values in the buffer is defined by the l type list

Instances

NFData (Packed a)

Defined in Data.Packed.Packed

Methods

rnf :: Packed a -> ()

skipWithFieldSize :: forall a (r :: [Type]). PackedReader '[FieldSize, a] r ()

Allows skipping over a field without having to unpack it

isolate :: forall a (r :: [Type]). PackedReader '[FieldSize, a] r (Packed '[a])

Splits the Packed value, and isolate the first encoded value.

fromPacked :: forall (a :: [Type]). Packed a -> ByteString

Extracts the raw buffer from a Packed value

unsafeToPacked :: forall (a :: [Type]). ByteString -> Packed a

UNSAFE: Casts a generic ByteString into a Needs

unsafeCastPacked :: forall (a :: [Type]) (b :: [Type]). Packed a -> Packed b

UNSAFE: Casts a typed Packed value into another Packed value of another type

PackedReader

data PackedReader (p :: [Type]) (r :: [Type]) v

Basically a function that reads/desrialises a value from a Packed

p the types of the packed values to read

r the packed type after the encoded values to read

v the type of the value to unpack

Note: It is an indexed monad.

Instances

Functor (PackedReader p r)

Defined in Data.Packed.Reader

Methods

fmap :: (a -> b) -> PackedReader p r a -> PackedReader p r b

(<$) :: a -> PackedReader p r b -> PackedReader p r a

mkPackedReader :: forall (p :: [Type]) (r :: [Type]) v. (ReaderPtr (p :++: r) -> Int -> IO (v, ReaderPtr r, Int)) -> PackedReader p r v

Builds a PackedReader

runReader :: forall (p :: [Type]) (r :: [Type]) v. PackedReader p r v -> Packed (p :++: r) -> IO (v, Packed r)

Run the reading function using a ByteString.

readerWithFieldSize :: forall a (r :: [Type]). Unpackable a => PackedReader '[FieldSize, a] r a

Produces a reader for a value preceded by its FieldSize

Code generation

mkPacked

Arguments

:: Name

The name of the type to generate the functions for

-> [PackingFlag]

Generation customisation flags

-> Q [Dec]

Generate the following for the given type

• A 'case' function (see genCase)
• An instance of Packable (see genPackableInstance)
• An instance of Unpackable (see genUnpackableInstance)
• An instance of Skippable (see genSkippableInstance)

Example:

 $(mkPacked ''Tree [InsertFieldSize])

data PackingFlag

Options for the generation process.

Beware: these options alter the signature and behaviour of the generated functions.

Constructors

InsertFieldSize

When specified, each field in a packed data constructor will be preceded by a FieldSize, which indicates the size of the following packed value.

Example

As a consequence, for the following type, the caseTree function will have the following signature

caseTree ::
    (PackedReader (FieldSize ': a ': r) r b) ->
    (PackedReader (FieldSize ': Tree a ': FieldSize ': Tree a ': r) r b) ->
    PackedReader (Tree a ': r) r b

SkipLastFieldSize

This flag should be used in complement to InsertFieldSize

If set, no FieldSize will be inserted before the last parameter of the data constructor.

Example

If this flag is set (along with InsertFieldSize), for the following type, the caseTree function will have the following signature

caseTree ::
    (PackedReader (a ': r) r b) ->
    (PackedReader (FieldSize ': Tree a ': Tree a ': r) r b) ->
    PackedReader (Tree a ': r) r b

Instances

Eq PackingFlag

Defined in Data.Packed.TH.Flag

Methods

(==) :: PackingFlag -> PackingFlag -> Bool

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

Utils

data FieldSize

Type representation for the size of a packed data. The size is in bytes.

Note: Take a look at the PackingFlags to understand how to use it

Instances

Packable FieldSize

Defined in Data.Packed.FieldSize

Methods

write :: forall (r :: [Type]) (t :: [Type]). FieldSize -> NeedsWriter FieldSize r t

Skippable FieldSize

Defined in Data.Packed.FieldSize

Methods

skip :: forall (r :: [Type]). PackedReader '[FieldSize] r ()

Unpackable FieldSize

Defined in Data.Packed.FieldSize

Methods

reader :: forall (r :: [Type]). PackedReader '[FieldSize] r FieldSize

getFieldSizeFromPacked :: Packed '[a] -> FieldSize

Returns the size of the packed value.

Warning: For this to be accurate, there should only be one value packed in the binary strea.

class Skippable a where

Methods

skip :: forall (r :: [Type]). PackedReader '[a] r ()

Instances

Skippable FieldSize

Defined in Data.Packed.FieldSize

Methods

skip :: forall (r :: [Type]). PackedReader '[FieldSize] r ()

Storable a => Skippable a

Defined in Data.Packed.Skippable

Methods

skip :: forall (r :: [Type]). PackedReader '[a] r ()

Skippable a => Skippable (Maybe a)

Defined in Data.Packed.Instances

Methods

skip :: forall (r :: [Type]). PackedReader '[Maybe a] r ()

Skippable a => Skippable [a]

Defined in Data.Packed.Instances

Methods

skip :: forall (r :: [Type]). PackedReader '[[a]] r ()

(Skippable a, Skippable b) => Skippable (Either a b)

Defined in Data.Packed.Instances

Methods

skip :: forall (r :: [Type]). PackedReader '[Either a b] r ()