module Media.Streaming.GStreamer.Core.Iterator (
Iterator,
Iterable,
IteratorFilter,
IteratorFoldFunction,
IteratorResult(..),
iteratorNext,
iteratorResync,
iteratorFilter,
iteratorFold,
iteratorForeach,
iteratorFind
) where
import Media.Streaming.GStreamer.Core.Types
import Data.Maybe (fromJust)
import System.Glib.FFI
import System.Glib.GValue
import Data.IORef
iteratorNext :: Iterable a
=> Iterator a
-> IO (IteratorResult, Maybe a)
iteratorNext (Iterator iterator) =
alloca $ \elemPtr ->
do result <- (\(PtrIterator arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_iterator_next argPtr1 arg2) iterator elemPtr
obj <- peek elemPtr >>= maybePeek peekIterable
return (toEnum $ fromIntegral result, obj)
iteratorResync :: Iterator a
-> IO ()
iteratorResync (Iterator iterator) =
(\(PtrIterator arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_iterator_resync argPtr1) iterator
type CIteratorFilter = ((Ptr ()))
-> ((Ptr ()))
-> IO (CInt)
marshalIteratorFilter :: Iterable a
=> IteratorFilter a
-> IO ((FunPtr ((Ptr ()) -> ((Ptr ()) -> (IO CInt)))))
marshalIteratorFilter iteratorFilter =
makeIteratorFilter cIteratorFilter
where cIteratorFilter elementPtr _ =
do include <- peekIterable elementPtr >>= iteratorFilter
return $ if include then 1 else 0
foreign import ccall "wrapper"
makeIteratorFilter :: CIteratorFilter
-> IO ((FunPtr ((Ptr ()) -> ((Ptr ()) -> (IO CInt)))))
iteratorFilter :: Iterable a
=> Iterator a
-> IteratorFilter a
-> IO (Iterator a)
iteratorFilter (Iterator iterator) filter =
do cFilter <- marshalIteratorFilter filter
(\(PtrIterator arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gst_iterator_filter argPtr1 arg2 arg3) iterator cFilter nullPtr >>=
takeIterator
type CIteratorFoldFunction = ((Ptr ()))
-> GValue
-> ((Ptr ()))
-> IO (CInt)
marshalIteratorFoldFunction :: Iterable itemT
=> IteratorFoldFunction itemT accumT
-> IORef accumT
-> IO ((FunPtr ((Ptr ()) -> ((Ptr GValue) -> ((Ptr ()) -> (IO CInt))))))
marshalIteratorFoldFunction iteratorFoldFunction accumRef =
makeIteratorFoldFunction cIteratorFoldFunction
where cIteratorFoldFunction :: CIteratorFoldFunction
cIteratorFoldFunction itemPtr _ _ =
do item <- peekIterable itemPtr
accum <- readIORef accumRef
(continue, accum') <- iteratorFoldFunction item accum
writeIORef accumRef accum'
return $ fromBool continue
foreign import ccall "wrapper"
makeIteratorFoldFunction :: CIteratorFoldFunction
-> IO ((FunPtr ((Ptr ()) -> ((Ptr GValue) -> ((Ptr ()) -> (IO CInt))))))
iteratorFold :: Iterable itemT
=> Iterator itemT
-> accumT
-> IteratorFoldFunction itemT accumT
-> IO (IteratorResult, accumT)
iteratorFold (Iterator iterator) init func =
do accumRef <- newIORef init
func' <- marshalIteratorFoldFunction func accumRef
result <- (\(PtrIterator arg1) arg2 (GValue arg3) arg4 -> withForeignPtr arg1 $ \argPtr1 ->gst_iterator_fold argPtr1 arg2 arg3 arg4) iterator
func'
(GValue nullPtr)
nullPtr
freeHaskellFunPtr func'
accum <- readIORef accumRef
return (toEnum $ fromIntegral result, accum)
iteratorForeach :: Iterable itemT
=> Iterator itemT
-> (itemT -> IO ())
-> IO IteratorResult
iteratorForeach iterator func =
do (result, _) <- iteratorFold iterator () $ \item _ ->
func item >> return (True, ())
return result
iteratorFind :: Iterable itemT
=> Iterator itemT
-> (itemT -> IO Bool)
-> IO (IteratorResult, Maybe itemT)
iteratorFind iterator pred =
iteratorFold iterator Nothing $ \item accum ->
do found <- pred item
if found
then return (False, Just item)
else return (True, accum)
foreign import ccall safe "gst_iterator_next"
gst_iterator_next :: ((Ptr PtrIterator) -> ((Ptr (Ptr ())) -> (IO CInt)))
foreign import ccall safe "gst_iterator_resync"
gst_iterator_resync :: ((Ptr PtrIterator) -> (IO ()))
foreign import ccall safe "gst_iterator_filter"
gst_iterator_filter :: ((Ptr PtrIterator) -> ((FunPtr ((Ptr ()) -> ((Ptr ()) -> (IO CInt)))) -> ((Ptr ()) -> (IO (Ptr PtrIterator)))))
foreign import ccall safe "gst_iterator_fold"
gst_iterator_fold :: ((Ptr PtrIterator) -> ((FunPtr ((Ptr ()) -> ((Ptr GValue) -> ((Ptr ()) -> (IO CInt))))) -> ((Ptr GValue) -> ((Ptr ()) -> (IO CInt)))))