--------------------------------------------------------------------------------
-- |
-- Module      : System.Taffybar.Information.StreamInfo
-- Copyright   : (c) José A. Romero L.
-- License     : BSD3-style (see LICENSE)
--
-- Maintainer  : José A. Romero L. <escherdragon@gmail.com>
-- Stability   : unstable
-- Portability : unportable
--
-- Generic code to poll any of the many data files maintained by the kernel in
-- POSIX systems. Provides methods for applying a custom parsing function to the
-- contents of the file and to calculate differentials across one or more values
-- provided via the file.
--
--------------------------------------------------------------------------------

module System.Taffybar.Information.StreamInfo
    ( getParsedInfo
    , getLoad
    , getAccLoad
    , getTransfer
    ) where

import Control.Concurrent ( threadDelay )
import Data.IORef
import Data.Maybe ( fromMaybe )

-- | Apply the given parser function to the file under the given path to produce
-- a lookup map, then use the given selector as key to extract from it the
-- desired value.
getParsedInfo :: FilePath -> (String -> [(String, [a])]) -> String -> IO [a]
getParsedInfo :: forall a.
FilePath -> (FilePath -> [(FilePath, [a])]) -> FilePath -> IO [a]
getParsedInfo FilePath
path FilePath -> [(FilePath, [a])]
parser FilePath
selector = do
    file <- FilePath -> IO FilePath
readFile FilePath
path
    length file `seq` return ()
    return (fromMaybe [] $ lookup selector $ parser file)

truncVal :: (RealFloat a) => a -> a
truncVal :: forall a. RealFloat a => a -> a
truncVal a
v
  | a -> Bool
forall a. RealFloat a => a -> Bool
isNaN a
v Bool -> Bool -> Bool
|| a
v a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0.0 = a
0.0
  | Bool
otherwise = a
v

-- | Convert the given list of Integer to a list of the ratios of each of its
-- elements against their sum.
toRatioList :: (Integral a, RealFloat b) => [a] -> [b]
toRatioList :: forall a b. (Integral a, RealFloat b) => [a] -> [b]
toRatioList [a]
deltas = (b -> b) -> [b] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map b -> b
forall a. RealFloat a => a -> a
truncVal [b]
ratios
    where total :: b
total = a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ [a] -> a
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [a]
deltas
          ratios :: [b]
ratios = (a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map ((b -> b -> b
forall a. Fractional a => a -> a -> a
/b
total) (b -> b) -> (a -> b) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral) [a]
deltas

-- | Execute the given action twice with the given delay in-between and return
-- the difference between the two samples.
probe :: (Num a, RealFrac b) => IO [a] -> b -> IO [a]
probe :: forall a b. (Num a, RealFrac b) => IO [a] -> b -> IO [a]
probe IO [a]
action b
delay = do
    a <- IO [a]
action
    threadDelay $ round (delay * 1e6)
    b <- action
    return $ zipWith (-) b a

-- | Execute the given action once and return the difference between the
-- obtained sample and the one contained in the given IORef.
accProbe :: (Num a) => IO [a] -> IORef [a] -> IO [a]
accProbe :: forall a. Num a => IO [a] -> IORef [a] -> IO [a]
accProbe IO [a]
action IORef [a]
sample = do
    a <- IORef [a] -> IO [a]
forall a. IORef a -> IO a
readIORef IORef [a]
sample
    b <- action
    writeIORef sample b
    return $ zipWith (-) b a

-- | Probe the given action and, interpreting the result as a variation in time,
-- return the speed of change of its values.
getTransfer :: (Integral a, RealFloat b) => b -> IO [a] -> IO [b]
getTransfer :: forall a b. (Integral a, RealFloat b) => b -> IO [a] -> IO [b]
getTransfer b
interval IO [a]
action = do
    deltas <- IO [a] -> b -> IO [a]
forall a b. (Num a, RealFrac b) => IO [a] -> b -> IO [a]
probe IO [a]
action b
interval
    return $ map (truncVal . (/interval) . fromIntegral) deltas

-- | Probe the given action and return the relative variation of each of the
-- obtained values against the whole, where the whole is calculated as the sum
-- of all the values in the probe.
getLoad :: (Integral a, RealFloat b) => b -> IO [a] -> IO [b]
getLoad :: forall a b. (Integral a, RealFloat b) => b -> IO [a] -> IO [b]
getLoad b
interval IO [a]
action = [a] -> [b]
forall a b. (Integral a, RealFloat b) => [a] -> [b]
toRatioList ([a] -> [b]) -> IO [a] -> IO [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO [a] -> b -> IO [a]
forall a b. (Num a, RealFrac b) => IO [a] -> b -> IO [a]
probe IO [a]
action b
interval

-- | Similar to getLoad, but execute the given action only once and use the
-- given IORef to calculate the result and to save the current value, so it
-- can be reused in the next call.
getAccLoad :: (Integral a, RealFloat b) => IORef [a] -> IO [a] -> IO [b]
getAccLoad :: forall a b.
(Integral a, RealFloat b) =>
IORef [a] -> IO [a] -> IO [b]
getAccLoad IORef [a]
sample IO [a]
action = [a] -> [b]
forall a b. (Integral a, RealFloat b) => [a] -> [b]
toRatioList ([a] -> [b]) -> IO [a] -> IO [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO [a] -> IORef [a] -> IO [a]
forall a. Num a => IO [a] -> IORef [a] -> IO [a]
accProbe IO [a]
action IORef [a]
sample