{-# LANGUAGE ForeignFunctionInterface #-}
module Foreign.Libcdio.Logging
(
LogEntry ( .. )
, LogLevel ( .. )
, putLog
, readLog
, clearLog
, logCutoff
, setLogCutoff
, setupLogger
) where
import qualified Control.Monad as N
import qualified Data.Maybe as Y
import qualified Foreign.C.String as C
import qualified Foreign.C.Types as C
import qualified Foreign.Ptr as C
import qualified Foreign.Marshal.Array as M
import qualified Foreign.Marshal.Utils as M
import qualified Foreign.Storable as S
import Foreign.Libcdio.Marshal
import Foreign.Libcdio.Types.Enums
import Foreign.Libcdio.Types.Offsets
logCutoff :: IO LogLevel
logCutoff :: IO LogLevel
logCutoff = Int -> LogLevel
forall a. Enum a => Int -> a
toEnum (Int -> LogLevel) -> (CLogLevel -> Int) -> CLogLevel -> LogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CLogLevel -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CLogLevel -> LogLevel) -> IO CLogLevel -> IO LogLevel
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CLogLevel
logCutoff'
foreign import ccall safe "cdio/compat/logging.h get_cdio_log_level"
logCutoff' :: IO CLogLevel
setLogCutoff :: LogLevel -> IO ()
setLogCutoff :: LogLevel -> IO ()
setLogCutoff = CLogLevel -> IO ()
setLogCutoff' (CLogLevel -> IO ())
-> (LogLevel -> CLogLevel) -> LogLevel -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> CLogLevel
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CLogLevel) -> (LogLevel -> Int) -> LogLevel -> CLogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LogLevel -> Int
forall a. Enum a => a -> Int
fromEnum
foreign import ccall safe "cdio/compat/logging.h set_cdio_log_level"
setLogCutoff' :: CLogLevel -> IO ()
data LogEntry = LogEntry
{ LogEntry -> LogLevel
logLevel :: LogLevel
, LogEntry -> String
logMessage :: String
}
deriving ( LogEntry -> LogEntry -> Bool
(LogEntry -> LogEntry -> Bool)
-> (LogEntry -> LogEntry -> Bool) -> Eq LogEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LogEntry -> LogEntry -> Bool
$c/= :: LogEntry -> LogEntry -> Bool
== :: LogEntry -> LogEntry -> Bool
$c== :: LogEntry -> LogEntry -> Bool
Eq, Int -> LogEntry -> ShowS
[LogEntry] -> ShowS
LogEntry -> String
(Int -> LogEntry -> ShowS)
-> (LogEntry -> String) -> ([LogEntry] -> ShowS) -> Show LogEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LogEntry] -> ShowS
$cshowList :: [LogEntry] -> ShowS
show :: LogEntry -> String
$cshow :: LogEntry -> String
showsPrec :: Int -> LogEntry -> ShowS
$cshowsPrec :: Int -> LogEntry -> ShowS
Show, ReadPrec [LogEntry]
ReadPrec LogEntry
Int -> ReadS LogEntry
ReadS [LogEntry]
(Int -> ReadS LogEntry)
-> ReadS [LogEntry]
-> ReadPrec LogEntry
-> ReadPrec [LogEntry]
-> Read LogEntry
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LogEntry]
$creadListPrec :: ReadPrec [LogEntry]
readPrec :: ReadPrec LogEntry
$creadPrec :: ReadPrec LogEntry
readList :: ReadS [LogEntry]
$creadList :: ReadS [LogEntry]
readsPrec :: Int -> ReadS LogEntry
$creadsPrec :: Int -> ReadS LogEntry
Read )
instance S.Storable LogEntry where
sizeOf :: LogEntry -> Int
sizeOf LogEntry
_ = Int
leSizeOf
alignment :: LogEntry -> Int
alignment LogEntry
_ = Int
leAlign
peek :: Ptr LogEntry -> IO LogEntry
peek Ptr LogEntry
c = do
CLogLevel
l <- Ptr LogEntry -> Int -> IO CLogLevel
forall a b. Storable a => Ptr b -> Int -> IO a
S.peekByteOff Ptr LogEntry
c Int
leLevel :: IO CLogLevel
Ptr CChar
m' <- Ptr LogEntry -> Int -> IO (Ptr CChar)
forall a b. Storable a => Ptr b -> Int -> IO a
S.peekByteOff Ptr LogEntry
c Int
leMessage
String
m <- if Ptr CChar
m' Ptr CChar -> Ptr CChar -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr CChar
forall a. Ptr a
C.nullPtr
then String -> IO String
forall (m :: * -> *) a. Monad m => a -> m a
return String
""
else Ptr CChar -> IO String
C.peekCString Ptr CChar
m'
LogEntry -> IO LogEntry
forall (m :: * -> *) a. Monad m => a -> m a
return (LogEntry -> IO LogEntry) -> LogEntry -> IO LogEntry
forall a b. (a -> b) -> a -> b
$ LogEntry :: LogLevel -> String -> LogEntry
LogEntry
{ logLevel :: LogLevel
logLevel = Int -> LogLevel
forall a. Enum a => Int -> a
toEnum (Int -> LogLevel) -> Int -> LogLevel
forall a b. (a -> b) -> a -> b
$ CLogLevel -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral CLogLevel
l
, logMessage :: String
logMessage = String
m
}
poke :: Ptr LogEntry -> LogEntry -> IO ()
poke Ptr LogEntry
c LogEntry
hs = do
Ptr LogEntry -> Int -> CLogLevel -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
S.pokeByteOff Ptr LogEntry
c Int
leLevel (Int -> CLogLevel
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CLogLevel) -> (LogLevel -> Int) -> LogLevel -> CLogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LogLevel -> Int
forall a. Enum a => a -> Int
fromEnum (LogLevel -> CLogLevel) -> LogLevel -> CLogLevel
forall a b. (a -> b) -> a -> b
$ LogEntry -> LogLevel
logLevel LogEntry
hs :: CLogLevel)
Ptr CChar
m <- String -> IO (Ptr CChar)
C.newCString (String -> IO (Ptr CChar)) -> String -> IO (Ptr CChar)
forall a b. (a -> b) -> a -> b
$ LogEntry -> String
logMessage LogEntry
hs
Ptr LogEntry -> Int -> Ptr CChar -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
S.pokeByteOff Ptr LogEntry
c Int
leMessage Ptr CChar
m
Ptr LogEntry -> Int -> Ptr Any -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
S.pokeByteOff Ptr LogEntry
c Int
lePrevious Ptr Any
forall a. Ptr a
C.nullPtr
readLog :: IO [LogEntry]
readLog :: IO [LogEntry]
readLog = do
Ptr (Ptr LogEntry)
es' <- IO (Ptr (Ptr LogEntry))
readLog'
[Ptr LogEntry]
es <- [Ptr LogEntry] -> Maybe [Ptr LogEntry] -> [Ptr LogEntry]
forall a. a -> Maybe a -> a
Y.fromMaybe [] (Maybe [Ptr LogEntry] -> [Ptr LogEntry])
-> IO (Maybe [Ptr LogEntry]) -> IO [Ptr LogEntry]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr (Ptr LogEntry) -> IO [Ptr LogEntry])
-> Ptr (Ptr LogEntry) -> IO (Maybe [Ptr LogEntry])
forall a b. (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
M.maybePeek (Ptr LogEntry -> Ptr (Ptr LogEntry) -> IO [Ptr LogEntry]
forall a. (Storable a, Eq a) => a -> Ptr a -> IO [a]
M.peekArray0 Ptr LogEntry
forall a. Ptr a
C.nullPtr) Ptr (Ptr LogEntry)
es'
[Ptr LogEntry] -> (Ptr LogEntry -> IO LogEntry) -> IO [LogEntry]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
N.forM [Ptr LogEntry]
es Ptr LogEntry -> IO LogEntry
forall a. Storable a => Ptr a -> IO a
S.peek
foreign import ccall safe "cdio/compat/logging.h read_cdio_log"
readLog' :: IO (C.Ptr (C.Ptr LogEntry))
foreign import ccall safe "cdio/compat/logging.h free_cdio_log"
clearLog :: IO ()
putLog :: LogEntry -> IO ()
putLog :: LogEntry -> IO ()
putLog LogEntry
e = String -> (Ptr CChar -> IO ()) -> IO ()
forall a. String -> (Ptr CChar -> IO a) -> IO a
C.withCString (LogEntry -> String
logMessage LogEntry
e) ((Ptr CChar -> IO ()) -> IO ()) -> (Ptr CChar -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ CLogLevel -> Ptr CChar -> IO ()
putLog' (Int -> CLogLevel
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CLogLevel) -> (LogLevel -> Int) -> LogLevel -> CLogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LogLevel -> Int
forall a. Enum a => a -> Int
fromEnum (LogLevel -> CLogLevel) -> LogLevel -> CLogLevel
forall a b. (a -> b) -> a -> b
$ LogEntry -> LogLevel
logLevel LogEntry
e)
foreign import ccall safe "cdio/compat/logging.h cdio_log"
putLog' :: CLogLevel -> C.CString -> IO ()