{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DeriveFunctor #-}

module Data.BList (BList(..)) where

import Data.Binary.Get
import Data.Binary

import Data.Endian

newtype BList a = BList { forall a. BList a -> [a]
fromBList :: [a] } deriving forall a b. a -> BList b -> BList a
forall a b. (a -> b) -> BList a -> BList b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> BList b -> BList a
$c<$ :: forall a b. a -> BList b -> BList a
fmap :: forall a b. (a -> b) -> BList a -> BList b
$cfmap :: forall a b. (a -> b) -> BList a -> BList b
Functor

instance Binary a => Binary (BList a) where
    put :: BList a -> Put
put (BList (a
a:[a]
as)) = forall t. Binary t => t -> Put
put a
a forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall t. Binary t => t -> Put
put (forall a. [a] -> BList a
BList [a]
as)
    put (BList []) = forall (m :: * -> *) a. Monad m => a -> m a
return ()
    get :: Get (BList a)
get = do
        Bool
e <- Get Bool
isEmpty
        if Bool
e then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. [a] -> BList a
BList [] else do
            a
a <- forall t. Binary t => Get t
get
            (BList [a]
as) <- forall t. Binary t => Get t
get
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. [a] -> BList a
BList forall a b. (a -> b) -> a -> b
$ a
a forall a. a -> [a] -> [a]
: [a]
as

instance Binary (Be a) => Binary (Be (BList a)) where
    put :: Be (BList a) -> Put
put (Be (BList [a]
l)) = forall t. Binary t => t -> Put
put forall a b. (a -> b) -> a -> b
$ forall a. [a] -> BList a
BList forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Be a
Be [a]
l
    get :: Get (Be (BList a))
get = forall a. a -> Be a
Be forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Be a -> a
fromBe forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t. Binary t => Get t
get

instance Binary (Le a) => Binary (Le (BList a)) where
    put :: Le (BList a) -> Put
put (Le (BList [a]
l)) = forall t. Binary t => t -> Put
put forall a b. (a -> b) -> a -> b
$ forall a. [a] -> BList a
BList forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Le a
Le [a]
l
    get :: Get (Le (BList a))
get = forall a. a -> Le a
Le forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Le a -> a
fromLe forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t. Binary t => Get t
get