module Sound.MED.Basic.Utility where

import qualified Data.List.Reverse.StrictSpine as ListRev
import qualified Data.Traversable as Trav
import Data.List.HT (sliceVertical)
import Data.Maybe.HT (toMaybe)

import Data.Word (Word8, Word16, Word32)
import Data.Int (Int8, Int16, Int32)


type PTR   = Word32
type LONG  = Int32
type ULONG = Word32
type WORD  = Int16
type UWORD = Word16
type BYTE  = Int8
type UBYTE = Word8

infixr 0 $?

($?) :: (Monad m) => (PTR -> m a) -> PTR -> m (Maybe a)
PTR -> m a
f $? :: forall (m :: * -> *) a.
Monad m =>
(PTR -> m a) -> PTR -> m (Maybe a)
$? PTR
ptr = forall (m :: * -> *) a. Monad m => Bool -> m a -> m (Maybe a)
skipIf (PTR
ptr forall a. Eq a => a -> a -> Bool
== PTR
0) (PTR -> m a
f PTR
ptr)

skipIf :: (Monad m) => Bool -> m a -> m (Maybe a)
skipIf :: forall (m :: * -> *) a. Monad m => Bool -> m a -> m (Maybe a)
skipIf Bool
cond m a
act = forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
Trav.sequence forall a b. (a -> b) -> a -> b
$ forall a. Bool -> a -> Maybe a
toMaybe (Bool -> Bool
not Bool
cond) m a
act


pointerRange :: PTR -> ULONG -> Int -> [PTR]
pointerRange :: PTR -> PTR -> Int -> [PTR]
pointerRange PTR
start PTR
step Int
len =
  forall a. Int -> [a] -> [a]
take Int
len forall a b. (a -> b) -> a -> b
$ forall a. (a -> a) -> a -> [a]
iterate (forall a b. (Integral a, Num b) => a -> b
fromIntegral PTR
step forall a. Num a => a -> a -> a
+) PTR
start

pointerRangeGen :: (Integral i) => PTR -> ULONG -> i -> [PTR]
pointerRangeGen :: forall i. Integral i => PTR -> PTR -> i -> [PTR]
pointerRangeGen PTR
start PTR
step i
len = PTR -> PTR -> Int -> [PTR]
pointerRange PTR
start PTR
step (forall a b. (Integral a, Num b) => a -> b
fromIntegral i
len)

{- |
Return empty list if start pointer is zero.
-}
pointerRangeGenCheck :: (Integral i) => PTR -> ULONG -> i -> [PTR]
pointerRangeGenCheck :: forall i. Integral i => PTR -> PTR -> i -> [PTR]
pointerRangeGenCheck PTR
start PTR
step i
len =
  if PTR
start forall a. Eq a => a -> a -> Bool
== PTR
0 then [] else forall i. Integral i => PTR -> PTR -> i -> [PTR]
pointerRangeGen PTR
start PTR
step i
len

pointerRangeGen2 :: (Integral i, Integral j) => PTR -> ULONG -> i -> j -> [PTR]
pointerRangeGen2 :: forall i j.
(Integral i, Integral j) =>
PTR -> PTR -> i -> j -> [PTR]
pointerRangeGen2 PTR
start PTR
step i
len0 j
len1 =
  PTR -> PTR -> Int -> [PTR]
pointerRange PTR
start PTR
step (forall a b. (Integral a, Num b) => a -> b
fromIntegral i
len0 forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral j
len1)


chunk :: (Integral i) => i -> [a] -> [[a]]
chunk :: forall i a. Integral i => i -> [a] -> [[a]]
chunk i
k = forall a. Int -> [a] -> [[a]]
sliceVertical (forall a b. (Integral a, Num b) => a -> b
fromIntegral i
k)

-- | Strings tend to be fixed width fields with trailing zeros.
stringFromBytes :: [UBYTE] -> String
stringFromBytes :: [UBYTE] -> String
stringFromBytes = forall a b. (a -> b) -> [a] -> [b]
map (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
ListRev.dropWhile (forall a. Eq a => a -> a -> Bool
==UBYTE
0)