{-# LANGUAGE DeriveDataTypeable #-}

-- | Data types describing the execution environment
--    of virtual machine builds.
--    'ExecEnv', 'Resources' and 'SharedDirectory' describe how
--    "B9.LibVirtLXC" should configure and execute
--    build scripts, as defined in "B9.ShellScript" and "B9.Vm".
module B9.ExecEnv
  ( ExecEnv (..),
    Resources (..),
    noResources,
    SharedDirectory (..),
    CPUArch (..),
    RamSize (..),
  )
where

import B9.DiskImages
import Control.Parallel.Strategies
import Data.Binary
import Data.Data
import Data.Hashable
import Data.Semigroup as Sem
import GHC.Generics (Generic)

-- | The environment for the execution of 'Script's inside a 'Container'
data ExecEnv
  = ExecEnv
      { ExecEnv -> String
envName :: String,
        ExecEnv -> [Mounted Image]
envImageMounts :: [Mounted Image],
        ExecEnv -> [SharedDirectory]
envSharedDirectories :: [SharedDirectory],
        ExecEnv -> Resources
envResources :: Resources
      }
  deriving (ReadPrec [ExecEnv]
ReadPrec ExecEnv
Int -> ReadS ExecEnv
ReadS [ExecEnv]
(Int -> ReadS ExecEnv)
-> ReadS [ExecEnv]
-> ReadPrec ExecEnv
-> ReadPrec [ExecEnv]
-> Read ExecEnv
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExecEnv]
$creadListPrec :: ReadPrec [ExecEnv]
readPrec :: ReadPrec ExecEnv
$creadPrec :: ReadPrec ExecEnv
readList :: ReadS [ExecEnv]
$creadList :: ReadS [ExecEnv]
readsPrec :: Int -> ReadS ExecEnv
$creadsPrec :: Int -> ReadS ExecEnv
Read, Int -> ExecEnv -> ShowS
[ExecEnv] -> ShowS
ExecEnv -> String
(Int -> ExecEnv -> ShowS)
-> (ExecEnv -> String) -> ([ExecEnv] -> ShowS) -> Show ExecEnv
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecEnv] -> ShowS
$cshowList :: [ExecEnv] -> ShowS
show :: ExecEnv -> String
$cshow :: ExecEnv -> String
showsPrec :: Int -> ExecEnv -> ShowS
$cshowsPrec :: Int -> ExecEnv -> ShowS
Show, Typeable, Typeable ExecEnv
DataType
Constr
Typeable ExecEnv
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExecEnv -> c ExecEnv)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExecEnv)
-> (ExecEnv -> Constr)
-> (ExecEnv -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExecEnv))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExecEnv))
-> ((forall b. Data b => b -> b) -> ExecEnv -> ExecEnv)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExecEnv -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExecEnv -> r)
-> (forall u. (forall d. Data d => d -> u) -> ExecEnv -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ExecEnv -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv)
-> Data ExecEnv
ExecEnv -> DataType
ExecEnv -> Constr
(forall b. Data b => b -> b) -> ExecEnv -> ExecEnv
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecEnv -> c ExecEnv
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecEnv
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ExecEnv -> u
forall u. (forall d. Data d => d -> u) -> ExecEnv -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecEnv
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecEnv -> c ExecEnv
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExecEnv)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExecEnv)
$cExecEnv :: Constr
$tExecEnv :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
gmapMp :: (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
gmapM :: (forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExecEnv -> m ExecEnv
gmapQi :: Int -> (forall d. Data d => d -> u) -> ExecEnv -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExecEnv -> u
gmapQ :: (forall d. Data d => d -> u) -> ExecEnv -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExecEnv -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecEnv -> r
gmapT :: (forall b. Data b => b -> b) -> ExecEnv -> ExecEnv
$cgmapT :: (forall b. Data b => b -> b) -> ExecEnv -> ExecEnv
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExecEnv)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExecEnv)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ExecEnv)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExecEnv)
dataTypeOf :: ExecEnv -> DataType
$cdataTypeOf :: ExecEnv -> DataType
toConstr :: ExecEnv -> Constr
$ctoConstr :: ExecEnv -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecEnv
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecEnv
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecEnv -> c ExecEnv
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecEnv -> c ExecEnv
$cp1Data :: Typeable ExecEnv
Data, ExecEnv -> ExecEnv -> Bool
(ExecEnv -> ExecEnv -> Bool)
-> (ExecEnv -> ExecEnv -> Bool) -> Eq ExecEnv
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecEnv -> ExecEnv -> Bool
$c/= :: ExecEnv -> ExecEnv -> Bool
== :: ExecEnv -> ExecEnv -> Bool
$c== :: ExecEnv -> ExecEnv -> Bool
Eq, (forall x. ExecEnv -> Rep ExecEnv x)
-> (forall x. Rep ExecEnv x -> ExecEnv) -> Generic ExecEnv
forall x. Rep ExecEnv x -> ExecEnv
forall x. ExecEnv -> Rep ExecEnv x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExecEnv x -> ExecEnv
$cfrom :: forall x. ExecEnv -> Rep ExecEnv x
Generic)

instance Hashable ExecEnv

instance Binary ExecEnv

instance NFData ExecEnv

data SharedDirectory
  = SharedDirectory
      FilePath
      MountPoint
  | SharedDirectoryRO
      FilePath
      MountPoint
  | SharedSources MountPoint
  deriving (ReadPrec [SharedDirectory]
ReadPrec SharedDirectory
Int -> ReadS SharedDirectory
ReadS [SharedDirectory]
(Int -> ReadS SharedDirectory)
-> ReadS [SharedDirectory]
-> ReadPrec SharedDirectory
-> ReadPrec [SharedDirectory]
-> Read SharedDirectory
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SharedDirectory]
$creadListPrec :: ReadPrec [SharedDirectory]
readPrec :: ReadPrec SharedDirectory
$creadPrec :: ReadPrec SharedDirectory
readList :: ReadS [SharedDirectory]
$creadList :: ReadS [SharedDirectory]
readsPrec :: Int -> ReadS SharedDirectory
$creadsPrec :: Int -> ReadS SharedDirectory
Read, Int -> SharedDirectory -> ShowS
[SharedDirectory] -> ShowS
SharedDirectory -> String
(Int -> SharedDirectory -> ShowS)
-> (SharedDirectory -> String)
-> ([SharedDirectory] -> ShowS)
-> Show SharedDirectory
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SharedDirectory] -> ShowS
$cshowList :: [SharedDirectory] -> ShowS
show :: SharedDirectory -> String
$cshow :: SharedDirectory -> String
showsPrec :: Int -> SharedDirectory -> ShowS
$cshowsPrec :: Int -> SharedDirectory -> ShowS
Show, Typeable, Typeable SharedDirectory
DataType
Constr
Typeable SharedDirectory
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SharedDirectory -> c SharedDirectory)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SharedDirectory)
-> (SharedDirectory -> Constr)
-> (SharedDirectory -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SharedDirectory))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SharedDirectory))
-> ((forall b. Data b => b -> b)
    -> SharedDirectory -> SharedDirectory)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SharedDirectory -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SharedDirectory -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SharedDirectory -> m SharedDirectory)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SharedDirectory -> m SharedDirectory)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SharedDirectory -> m SharedDirectory)
-> Data SharedDirectory
SharedDirectory -> DataType
SharedDirectory -> Constr
(forall b. Data b => b -> b) -> SharedDirectory -> SharedDirectory
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedDirectory -> c SharedDirectory
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SharedDirectory
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SharedDirectory -> u
forall u. (forall d. Data d => d -> u) -> SharedDirectory -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SharedDirectory
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedDirectory -> c SharedDirectory
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SharedDirectory)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SharedDirectory)
$cSharedSources :: Constr
$cSharedDirectoryRO :: Constr
$cSharedDirectory :: Constr
$tSharedDirectory :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
gmapMp :: (forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
gmapM :: (forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SharedDirectory -> m SharedDirectory
gmapQi :: Int -> (forall d. Data d => d -> u) -> SharedDirectory -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SharedDirectory -> u
gmapQ :: (forall d. Data d => d -> u) -> SharedDirectory -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SharedDirectory -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedDirectory -> r
gmapT :: (forall b. Data b => b -> b) -> SharedDirectory -> SharedDirectory
$cgmapT :: (forall b. Data b => b -> b) -> SharedDirectory -> SharedDirectory
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SharedDirectory)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SharedDirectory)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SharedDirectory)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SharedDirectory)
dataTypeOf :: SharedDirectory -> DataType
$cdataTypeOf :: SharedDirectory -> DataType
toConstr :: SharedDirectory -> Constr
$ctoConstr :: SharedDirectory -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SharedDirectory
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SharedDirectory
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedDirectory -> c SharedDirectory
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedDirectory -> c SharedDirectory
$cp1Data :: Typeable SharedDirectory
Data, SharedDirectory -> SharedDirectory -> Bool
(SharedDirectory -> SharedDirectory -> Bool)
-> (SharedDirectory -> SharedDirectory -> Bool)
-> Eq SharedDirectory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SharedDirectory -> SharedDirectory -> Bool
$c/= :: SharedDirectory -> SharedDirectory -> Bool
== :: SharedDirectory -> SharedDirectory -> Bool
$c== :: SharedDirectory -> SharedDirectory -> Bool
Eq, (forall x. SharedDirectory -> Rep SharedDirectory x)
-> (forall x. Rep SharedDirectory x -> SharedDirectory)
-> Generic SharedDirectory
forall x. Rep SharedDirectory x -> SharedDirectory
forall x. SharedDirectory -> Rep SharedDirectory x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SharedDirectory x -> SharedDirectory
$cfrom :: forall x. SharedDirectory -> Rep SharedDirectory x
Generic)

instance Hashable SharedDirectory

instance Binary SharedDirectory

instance NFData SharedDirectory

data Resources
  = Resources
      { Resources -> RamSize
maxMemory :: RamSize,
        Resources -> Int
cpuCount :: Int,
        Resources -> CPUArch
cpuArch :: CPUArch
      }
  deriving (Resources -> Resources -> Bool
(Resources -> Resources -> Bool)
-> (Resources -> Resources -> Bool) -> Eq Resources
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Resources -> Resources -> Bool
$c/= :: Resources -> Resources -> Bool
== :: Resources -> Resources -> Bool
$c== :: Resources -> Resources -> Bool
Eq, ReadPrec [Resources]
ReadPrec Resources
Int -> ReadS Resources
ReadS [Resources]
(Int -> ReadS Resources)
-> ReadS [Resources]
-> ReadPrec Resources
-> ReadPrec [Resources]
-> Read Resources
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Resources]
$creadListPrec :: ReadPrec [Resources]
readPrec :: ReadPrec Resources
$creadPrec :: ReadPrec Resources
readList :: ReadS [Resources]
$creadList :: ReadS [Resources]
readsPrec :: Int -> ReadS Resources
$creadsPrec :: Int -> ReadS Resources
Read, Int -> Resources -> ShowS
[Resources] -> ShowS
Resources -> String
(Int -> Resources -> ShowS)
-> (Resources -> String)
-> ([Resources] -> ShowS)
-> Show Resources
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Resources] -> ShowS
$cshowList :: [Resources] -> ShowS
show :: Resources -> String
$cshow :: Resources -> String
showsPrec :: Int -> Resources -> ShowS
$cshowsPrec :: Int -> Resources -> ShowS
Show, Typeable, Typeable Resources
DataType
Constr
Typeable Resources
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Resources -> c Resources)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Resources)
-> (Resources -> Constr)
-> (Resources -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Resources))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resources))
-> ((forall b. Data b => b -> b) -> Resources -> Resources)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Resources -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Resources -> r)
-> (forall u. (forall d. Data d => d -> u) -> Resources -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Resources -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Resources -> m Resources)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resources -> m Resources)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resources -> m Resources)
-> Data Resources
Resources -> DataType
Resources -> Constr
(forall b. Data b => b -> b) -> Resources -> Resources
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resources -> c Resources
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Resources
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Resources -> u
forall u. (forall d. Data d => d -> u) -> Resources -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Resources -> m Resources
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resources -> m Resources
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Resources
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resources -> c Resources
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Resources)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resources)
$cResources :: Constr
$tResources :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Resources -> m Resources
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resources -> m Resources
gmapMp :: (forall d. Data d => d -> m d) -> Resources -> m Resources
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Resources -> m Resources
gmapM :: (forall d. Data d => d -> m d) -> Resources -> m Resources
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Resources -> m Resources
gmapQi :: Int -> (forall d. Data d => d -> u) -> Resources -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Resources -> u
gmapQ :: (forall d. Data d => d -> u) -> Resources -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Resources -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Resources -> r
gmapT :: (forall b. Data b => b -> b) -> Resources -> Resources
$cgmapT :: (forall b. Data b => b -> b) -> Resources -> Resources
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resources)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resources)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Resources)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Resources)
dataTypeOf :: Resources -> DataType
$cdataTypeOf :: Resources -> DataType
toConstr :: Resources -> Constr
$ctoConstr :: Resources -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Resources
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Resources
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resources -> c Resources
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Resources -> c Resources
$cp1Data :: Typeable Resources
Data, (forall x. Resources -> Rep Resources x)
-> (forall x. Rep Resources x -> Resources) -> Generic Resources
forall x. Rep Resources x -> Resources
forall x. Resources -> Rep Resources x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Resources x -> Resources
$cfrom :: forall x. Resources -> Rep Resources x
Generic)

instance Hashable Resources

instance Binary Resources

instance NFData Resources

instance Sem.Semigroup Resources where
  <> :: Resources -> Resources -> Resources
(<>) (Resources RamSize
m Int
c CPUArch
a) (Resources RamSize
m' Int
c' CPUArch
a') =
    RamSize -> Int -> CPUArch -> Resources
Resources (RamSize
m RamSize -> RamSize -> RamSize
forall a. Semigroup a => a -> a -> a
<> RamSize
m') (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
c Int
c') (CPUArch
a CPUArch -> CPUArch -> CPUArch
forall a. Semigroup a => a -> a -> a
<> CPUArch
a')

instance Monoid Resources where
  mempty :: Resources
mempty = RamSize -> Int -> CPUArch -> Resources
Resources RamSize
forall a. Monoid a => a
mempty Int
1 CPUArch
forall a. Monoid a => a
mempty
  mappend :: Resources -> Resources -> Resources
mappend = Resources -> Resources -> Resources
forall a. Semigroup a => a -> a -> a
(Sem.<>)

noResources :: Resources
noResources :: Resources
noResources = Resources
forall a. Monoid a => a
mempty

data CPUArch
  = X86_64
  | I386
  deriving (ReadPrec [CPUArch]
ReadPrec CPUArch
Int -> ReadS CPUArch
ReadS [CPUArch]
(Int -> ReadS CPUArch)
-> ReadS [CPUArch]
-> ReadPrec CPUArch
-> ReadPrec [CPUArch]
-> Read CPUArch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CPUArch]
$creadListPrec :: ReadPrec [CPUArch]
readPrec :: ReadPrec CPUArch
$creadPrec :: ReadPrec CPUArch
readList :: ReadS [CPUArch]
$creadList :: ReadS [CPUArch]
readsPrec :: Int -> ReadS CPUArch
$creadsPrec :: Int -> ReadS CPUArch
Read, Int -> CPUArch -> ShowS
[CPUArch] -> ShowS
CPUArch -> String
(Int -> CPUArch -> ShowS)
-> (CPUArch -> String) -> ([CPUArch] -> ShowS) -> Show CPUArch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CPUArch] -> ShowS
$cshowList :: [CPUArch] -> ShowS
show :: CPUArch -> String
$cshow :: CPUArch -> String
showsPrec :: Int -> CPUArch -> ShowS
$cshowsPrec :: Int -> CPUArch -> ShowS
Show, Typeable, Typeable CPUArch
DataType
Constr
Typeable CPUArch
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CPUArch -> c CPUArch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CPUArch)
-> (CPUArch -> Constr)
-> (CPUArch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CPUArch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CPUArch))
-> ((forall b. Data b => b -> b) -> CPUArch -> CPUArch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CPUArch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CPUArch -> r)
-> (forall u. (forall d. Data d => d -> u) -> CPUArch -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CPUArch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch)
-> Data CPUArch
CPUArch -> DataType
CPUArch -> Constr
(forall b. Data b => b -> b) -> CPUArch -> CPUArch
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CPUArch -> c CPUArch
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CPUArch
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CPUArch -> u
forall u. (forall d. Data d => d -> u) -> CPUArch -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CPUArch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CPUArch -> c CPUArch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CPUArch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CPUArch)
$cI386 :: Constr
$cX86_64 :: Constr
$tCPUArch :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
gmapMp :: (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
gmapM :: (forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CPUArch -> m CPUArch
gmapQi :: Int -> (forall d. Data d => d -> u) -> CPUArch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CPUArch -> u
gmapQ :: (forall d. Data d => d -> u) -> CPUArch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CPUArch -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CPUArch -> r
gmapT :: (forall b. Data b => b -> b) -> CPUArch -> CPUArch
$cgmapT :: (forall b. Data b => b -> b) -> CPUArch -> CPUArch
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CPUArch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CPUArch)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CPUArch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CPUArch)
dataTypeOf :: CPUArch -> DataType
$cdataTypeOf :: CPUArch -> DataType
toConstr :: CPUArch -> Constr
$ctoConstr :: CPUArch -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CPUArch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CPUArch
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CPUArch -> c CPUArch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CPUArch -> c CPUArch
$cp1Data :: Typeable CPUArch
Data, CPUArch -> CPUArch -> Bool
(CPUArch -> CPUArch -> Bool)
-> (CPUArch -> CPUArch -> Bool) -> Eq CPUArch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CPUArch -> CPUArch -> Bool
$c/= :: CPUArch -> CPUArch -> Bool
== :: CPUArch -> CPUArch -> Bool
$c== :: CPUArch -> CPUArch -> Bool
Eq, (forall x. CPUArch -> Rep CPUArch x)
-> (forall x. Rep CPUArch x -> CPUArch) -> Generic CPUArch
forall x. Rep CPUArch x -> CPUArch
forall x. CPUArch -> Rep CPUArch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CPUArch x -> CPUArch
$cfrom :: forall x. CPUArch -> Rep CPUArch x
Generic)

instance Hashable CPUArch

instance Binary CPUArch

instance NFData CPUArch

instance Sem.Semigroup CPUArch where
  CPUArch
I386 <> :: CPUArch -> CPUArch -> CPUArch
<> CPUArch
x = CPUArch
x
  CPUArch
X86_64 <> CPUArch
_ = CPUArch
X86_64

instance Monoid CPUArch where
  mempty :: CPUArch
mempty = CPUArch
I386
  mappend :: CPUArch -> CPUArch -> CPUArch
mappend = CPUArch -> CPUArch -> CPUArch
forall a. Semigroup a => a -> a -> a
(Sem.<>)

data RamSize
  = RamSize
      Int
      SizeUnit
  | AutomaticRamSize
  deriving (RamSize -> RamSize -> Bool
(RamSize -> RamSize -> Bool)
-> (RamSize -> RamSize -> Bool) -> Eq RamSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RamSize -> RamSize -> Bool
$c/= :: RamSize -> RamSize -> Bool
== :: RamSize -> RamSize -> Bool
$c== :: RamSize -> RamSize -> Bool
Eq, ReadPrec [RamSize]
ReadPrec RamSize
Int -> ReadS RamSize
ReadS [RamSize]
(Int -> ReadS RamSize)
-> ReadS [RamSize]
-> ReadPrec RamSize
-> ReadPrec [RamSize]
-> Read RamSize
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RamSize]
$creadListPrec :: ReadPrec [RamSize]
readPrec :: ReadPrec RamSize
$creadPrec :: ReadPrec RamSize
readList :: ReadS [RamSize]
$creadList :: ReadS [RamSize]
readsPrec :: Int -> ReadS RamSize
$creadsPrec :: Int -> ReadS RamSize
Read, Int -> RamSize -> ShowS
[RamSize] -> ShowS
RamSize -> String
(Int -> RamSize -> ShowS)
-> (RamSize -> String) -> ([RamSize] -> ShowS) -> Show RamSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RamSize] -> ShowS
$cshowList :: [RamSize] -> ShowS
show :: RamSize -> String
$cshow :: RamSize -> String
showsPrec :: Int -> RamSize -> ShowS
$cshowsPrec :: Int -> RamSize -> ShowS
Show, Eq RamSize
Eq RamSize
-> (RamSize -> RamSize -> Ordering)
-> (RamSize -> RamSize -> Bool)
-> (RamSize -> RamSize -> Bool)
-> (RamSize -> RamSize -> Bool)
-> (RamSize -> RamSize -> Bool)
-> (RamSize -> RamSize -> RamSize)
-> (RamSize -> RamSize -> RamSize)
-> Ord RamSize
RamSize -> RamSize -> Bool
RamSize -> RamSize -> Ordering
RamSize -> RamSize -> RamSize
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RamSize -> RamSize -> RamSize
$cmin :: RamSize -> RamSize -> RamSize
max :: RamSize -> RamSize -> RamSize
$cmax :: RamSize -> RamSize -> RamSize
>= :: RamSize -> RamSize -> Bool
$c>= :: RamSize -> RamSize -> Bool
> :: RamSize -> RamSize -> Bool
$c> :: RamSize -> RamSize -> Bool
<= :: RamSize -> RamSize -> Bool
$c<= :: RamSize -> RamSize -> Bool
< :: RamSize -> RamSize -> Bool
$c< :: RamSize -> RamSize -> Bool
compare :: RamSize -> RamSize -> Ordering
$ccompare :: RamSize -> RamSize -> Ordering
$cp1Ord :: Eq RamSize
Ord, Typeable, Typeable RamSize
DataType
Constr
Typeable RamSize
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RamSize -> c RamSize)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RamSize)
-> (RamSize -> Constr)
-> (RamSize -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RamSize))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RamSize))
-> ((forall b. Data b => b -> b) -> RamSize -> RamSize)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RamSize -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RamSize -> r)
-> (forall u. (forall d. Data d => d -> u) -> RamSize -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RamSize -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RamSize -> m RamSize)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RamSize -> m RamSize)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RamSize -> m RamSize)
-> Data RamSize
RamSize -> DataType
RamSize -> Constr
(forall b. Data b => b -> b) -> RamSize -> RamSize
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RamSize -> c RamSize
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RamSize
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RamSize -> u
forall u. (forall d. Data d => d -> u) -> RamSize -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RamSize -> m RamSize
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RamSize -> m RamSize
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RamSize
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RamSize -> c RamSize
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RamSize)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RamSize)
$cAutomaticRamSize :: Constr
$cRamSize :: Constr
$tRamSize :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RamSize -> m RamSize
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RamSize -> m RamSize
gmapMp :: (forall d. Data d => d -> m d) -> RamSize -> m RamSize
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RamSize -> m RamSize
gmapM :: (forall d. Data d => d -> m d) -> RamSize -> m RamSize
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RamSize -> m RamSize
gmapQi :: Int -> (forall d. Data d => d -> u) -> RamSize -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RamSize -> u
gmapQ :: (forall d. Data d => d -> u) -> RamSize -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RamSize -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RamSize -> r
gmapT :: (forall b. Data b => b -> b) -> RamSize -> RamSize
$cgmapT :: (forall b. Data b => b -> b) -> RamSize -> RamSize
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RamSize)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RamSize)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RamSize)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RamSize)
dataTypeOf :: RamSize -> DataType
$cdataTypeOf :: RamSize -> DataType
toConstr :: RamSize -> Constr
$ctoConstr :: RamSize -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RamSize
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RamSize
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RamSize -> c RamSize
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RamSize -> c RamSize
$cp1Data :: Typeable RamSize
Data, (forall x. RamSize -> Rep RamSize x)
-> (forall x. Rep RamSize x -> RamSize) -> Generic RamSize
forall x. Rep RamSize x -> RamSize
forall x. RamSize -> Rep RamSize x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RamSize x -> RamSize
$cfrom :: forall x. RamSize -> Rep RamSize x
Generic)

instance Hashable RamSize

instance Binary RamSize

instance NFData RamSize

instance Sem.Semigroup RamSize where
  RamSize
AutomaticRamSize <> :: RamSize -> RamSize -> RamSize
<> RamSize
x = RamSize
x
  RamSize
x <> RamSize
AutomaticRamSize = RamSize
x
  RamSize
r <> RamSize
r' = RamSize -> RamSize -> RamSize
forall a. Ord a => a -> a -> a
max RamSize
r RamSize
r'

instance Monoid RamSize where
  mempty :: RamSize
mempty = RamSize
AutomaticRamSize
  mappend :: RamSize -> RamSize -> RamSize
mappend = RamSize -> RamSize -> RamSize
forall a. Semigroup a => a -> a -> a
(Sem.<>)