Safe Haskell	None
Language	Haskell2010

DBus.Types

Synopsis

Documentation

dbusLogger :: String Source #

logDebug :: String -> IO () Source #

logWarning :: String -> IO () Source #

logError :: String -> IO () Source #

data ObjectPath Source #

Constructors

ObjectPath
Fields opAbsolute :: Bool opParts :: [Text]

Instances

Eq ObjectPath Source #
Methods (==) :: ObjectPath -> ObjectPath -> Bool # (/=) :: ObjectPath -> ObjectPath -> Bool #
Data ObjectPath Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ObjectPath -> c ObjectPath # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ObjectPath # toConstr :: ObjectPath -> Constr # dataTypeOf :: ObjectPath -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ObjectPath) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjectPath) # gmapT :: (forall b. Data b => b -> b) -> ObjectPath -> ObjectPath # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ObjectPath -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ObjectPath -> r # gmapQ :: (forall d. Data d => d -> u) -> ObjectPath -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ObjectPath -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ObjectPath -> m ObjectPath # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjectPath -> m ObjectPath # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ObjectPath -> m ObjectPath #
Ord ObjectPath Source #
Methods compare :: ObjectPath -> ObjectPath -> Ordering # (<) :: ObjectPath -> ObjectPath -> Bool # (<=) :: ObjectPath -> ObjectPath -> Bool # (>) :: ObjectPath -> ObjectPath -> Bool # (>=) :: ObjectPath -> ObjectPath -> Bool # max :: ObjectPath -> ObjectPath -> ObjectPath # min :: ObjectPath -> ObjectPath -> ObjectPath #
Show ObjectPath Source #
Methods showsPrec :: Int -> ObjectPath -> ShowS # show :: ObjectPath -> String # showList :: [ObjectPath] -> ShowS #
IsString ObjectPath Source #
Methods fromString :: String -> ObjectPath #
type RepType ObjectPath Source #
type RepType ObjectPath = DBusSimpleType TypeObjectPath

type InterfaceName = Text Source #

type MemberName = Text Source #

opNode :: ObjectPath -> ObjectPath Source #

opPath :: ObjectPath -> ObjectPath Source #

newtype Signature Source #

Constructors

Signature
Fields fromSignature :: [DBusType]

Instances

Eq Signature Source #
Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Show Signature Source #
Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
type RepType Signature Source #
type RepType Signature = DBusSimpleType TypeSignature

objectPath :: Text -> ObjectPath Source #

Parse an object path. Contrary to the standard, empty path parts are ignored

objectPathToText :: ObjectPath -> Text Source #

stripObjectPrefix :: ObjectPath -> ObjectPath -> Maybe ObjectPath Source #

isPathPrefix :: ObjectPath -> ObjectPath -> Bool Source #

isRoot :: ObjectPath -> Bool Source #

isEmpty :: ObjectPath -> Bool Source #

data DBusSimpleType Source #

Types that are not composite. These can be the keys of a Dict. Most of them should be self-explanatory

Constructors

TypeByte
TypeBoolean
TypeInt16
TypeUInt16
TypeInt32
TypeUInt32
TypeInt64
TypeUInt64
TypeDouble
TypeUnixFD	Unix File descriptor
TypeString
TypeObjectPath	Name of an object instance
TypeSignature	A (DBus) type signature

Instances

Eq DBusSimpleType Source #
Methods (==) :: DBusSimpleType -> DBusSimpleType -> Bool # (/=) :: DBusSimpleType -> DBusSimpleType -> Bool #
Data DBusSimpleType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DBusSimpleType -> c DBusSimpleType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DBusSimpleType # toConstr :: DBusSimpleType -> Constr # dataTypeOf :: DBusSimpleType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DBusSimpleType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DBusSimpleType) # gmapT :: (forall b. Data b => b -> b) -> DBusSimpleType -> DBusSimpleType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DBusSimpleType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DBusSimpleType -> r # gmapQ :: (forall d. Data d => d -> u) -> DBusSimpleType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DBusSimpleType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DBusSimpleType -> m DBusSimpleType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DBusSimpleType -> m DBusSimpleType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DBusSimpleType -> m DBusSimpleType #
Read DBusSimpleType Source #
Methods readsPrec :: Int -> ReadS DBusSimpleType # readList :: ReadS [DBusSimpleType] # readPrec :: ReadPrec DBusSimpleType # readListPrec :: ReadPrec [DBusSimpleType] #
Show DBusSimpleType Source #
Methods showsPrec :: Int -> DBusSimpleType -> ShowS # show :: DBusSimpleType -> String # showList :: [DBusSimpleType] -> ShowS #
SEq DBusSimpleType Source #
Methods (%:==) :: Sing DBusSimpleType a -> Sing DBusSimpleType b -> Sing Bool ((DBusSimpleType :== a) b) # (%:/=) :: Sing DBusSimpleType a -> Sing DBusSimpleType b -> Sing Bool ((DBusSimpleType :/= a) b) #
SDecide DBusSimpleType Source #
Methods (%~) :: Sing DBusSimpleType a -> Sing DBusSimpleType b -> Decision ((DBusSimpleType :~: a) b) #
SingKind DBusSimpleType Source #
Associated Types type DemoteRep DBusSimpleType :: * # Methods fromSing :: Sing DBusSimpleType a -> DemoteRep DBusSimpleType # toSing :: DemoteRep DBusSimpleType -> SomeSing DBusSimpleType #
SingI DBusSimpleType TypeByte Source #
Methods sing :: Sing TypeByte a #
SingI DBusSimpleType TypeBoolean Source #
Methods sing :: Sing TypeBoolean a #
SingI DBusSimpleType TypeInt16 Source #
Methods sing :: Sing TypeInt16 a #
SingI DBusSimpleType TypeUInt16 Source #
Methods sing :: Sing TypeUInt16 a #
SingI DBusSimpleType TypeInt32 Source #
Methods sing :: Sing TypeInt32 a #
SingI DBusSimpleType TypeUInt32 Source #
Methods sing :: Sing TypeUInt32 a #
SingI DBusSimpleType TypeInt64 Source #
Methods sing :: Sing TypeInt64 a #
SingI DBusSimpleType TypeUInt64 Source #
Methods sing :: Sing TypeUInt64 a #
SingI DBusSimpleType TypeDouble Source #
Methods sing :: Sing TypeDouble a #
SingI DBusSimpleType TypeUnixFD Source #
Methods sing :: Sing TypeUnixFD a #
SingI DBusSimpleType TypeString Source #
Methods sing :: Sing TypeString a #
SingI DBusSimpleType TypeObjectPath Source #
Methods sing :: Sing TypeObjectPath a #
SingI DBusSimpleType TypeSignature Source #
Methods sing :: Sing TypeSignature a #
PEq DBusSimpleType (Proxy * DBusSimpleType) Source #
Associated Types type ((Proxy * DBusSimpleType) :== (x :: Proxy * DBusSimpleType)) (y :: Proxy * DBusSimpleType) :: Bool # type ((Proxy * DBusSimpleType) :/= (x :: Proxy * DBusSimpleType)) (y :: Proxy * DBusSimpleType) :: Bool #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictEntrySym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictSym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115098TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115088TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) DBusSimpleTypeSym0 Source #
Methods suppressUnusedWarnings :: Proxy DBusSimpleTypeSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) Let6989586621679115077TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115077TSym0 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictEntrySym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictSym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115098TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115088TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym1 t -> () #
data Sing DBusSimpleType Source #
data Sing DBusSimpleType where STypeByte :: Sing DBusSimpleType z STypeBoolean :: Sing DBusSimpleType z STypeInt16 :: Sing DBusSimpleType z STypeUInt16 :: Sing DBusSimpleType z STypeInt32 :: Sing DBusSimpleType z STypeUInt32 :: Sing DBusSimpleType z STypeInt64 :: Sing DBusSimpleType z STypeUInt64 :: Sing DBusSimpleType z STypeDouble :: Sing DBusSimpleType z STypeUnixFD :: Sing DBusSimpleType z STypeString :: Sing DBusSimpleType z STypeObjectPath :: Sing DBusSimpleType z STypeSignature :: Sing DBusSimpleType z
type DemoteRep DBusSimpleType Source #
type DemoteRep DBusSimpleType = DBusSimpleType
type (:/=) DBusSimpleType x y Source #
type (:/=) DBusSimpleType x y = Not ((:==) DBusSimpleType x y)
type (:==) DBusSimpleType a0 b0 Source #
type (:==) DBusSimpleType a0 b0 = Equals_6989586621679109107 a0 b0
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 Source #
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 = DBusSimpleTypeSym1 l0
type Apply DBusSimpleType DBusType Let6989586621679115077TSym0 l0 Source #
type Apply DBusSimpleType DBusType Let6989586621679115077TSym0 l0 = Let6989586621679115077TSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 = TypeDictEntrySym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 = TypeDictSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 = Let6989586621679115098TSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 = Let6989586621679115088TSym1 l0

ppSimpleType :: DBusSimpleType -> String Source #

Pretty-print a simple type (this is _not_ DBUs' type format)

data DBusType Source #

Composite Types

Constructors

DBusSimpleType DBusSimpleType	A simple type
TypeArray DBusType	Variable-length homogenous arrays
TypeStruct [DBusType]	Structs (Tuples) and a list of member types
TypeDict DBusSimpleType DBusType	Dictionary / Map
TypeVariant	Existentially types container. Carries it's own type information
TypeDictEntry DBusSimpleType DBusType	Internal helper type for Dicts. You shouldn't have to use this
TypeUnit	Unit isn't actually a DBus type. It is included to make it possible to use methods without a return value

Instances

Eq DBusType Source #
Methods (==) :: DBusType -> DBusType -> Bool # (/=) :: DBusType -> DBusType -> Bool #
Data DBusType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DBusType -> c DBusType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DBusType # toConstr :: DBusType -> Constr # dataTypeOf :: DBusType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DBusType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DBusType) # gmapT :: (forall b. Data b => b -> b) -> DBusType -> DBusType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DBusType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DBusType -> r # gmapQ :: (forall d. Data d => d -> u) -> DBusType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DBusType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DBusType -> m DBusType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DBusType -> m DBusType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DBusType -> m DBusType #
Read DBusType Source #
Methods readsPrec :: Int -> ReadS DBusType # readList :: ReadS [DBusType] # readPrec :: ReadPrec DBusType # readListPrec :: ReadPrec [DBusType] #
Show DBusType Source #
Methods showsPrec :: Int -> DBusType -> ShowS # show :: DBusType -> String # showList :: [DBusType] -> ShowS #
SEq DBusType Source #
Methods (%:==) :: Sing DBusType a -> Sing DBusType b -> Sing Bool ((DBusType :== a) b) # (%:/=) :: Sing DBusType a -> Sing DBusType b -> Sing Bool ((DBusType :/= a) b) #
SDecide DBusType Source #
Methods (%~) :: Sing DBusType a -> Sing DBusType b -> Decision ((DBusType :~: a) b) #
SingKind DBusType Source #
Associated Types type DemoteRep DBusType :: * # Methods fromSing :: Sing DBusType a -> DemoteRep DBusType # toSing :: DemoteRep DBusType -> SomeSing DBusType #
SingI DBusType TypeVariant Source #
Methods sing :: Sing TypeVariant a #
SingI DBusType TypeUnit Source #
Methods sing :: Sing TypeUnit a #
SingI DBusSimpleType n0 => SingI DBusType (DBusSimpleType n0) Source #
Methods sing :: Sing (DBusSimpleType n0) a #
SingI DBusType n0 => SingI DBusType (TypeArray n0) Source #
Methods sing :: Sing (TypeArray n0) a #
SingI [DBusType] n0 => SingI DBusType (TypeStruct n0) Source #
Methods sing :: Sing (TypeStruct n0) a #
PEq DBusType (Proxy * DBusType) Source #
Associated Types type ((Proxy * DBusType) :== (x :: Proxy * DBusType)) (y :: Proxy * DBusType) :: Bool # type ((Proxy * DBusType) :/= (x :: Proxy * DBusType)) (y :: Proxy * DBusType) :: Bool #
(SingI DBusSimpleType n0, SingI DBusType n1) => SingI DBusType (TypeDict n0 n1) Source #
Methods sing :: Sing (TypeDict n0 n1) a #
(SingI DBusSimpleType n0, SingI DBusType n1) => SingI DBusType (TypeDictEntry n0 n1) Source #
Methods sing :: Sing (TypeDictEntry n0 n1) a #
SuppressUnusedWarnings (TyFun [DBusType] DBusType -> *) TypeStructSym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeStructSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusType [DBusType] -> *) FlattenRepTypeSym0 Source #
Methods suppressUnusedWarnings :: Proxy FlattenRepTypeSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusType DBusType -> *) TypeArraySym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeArraySym0 t -> () #
SuppressUnusedWarnings (TyFun DBusType DBusType -> *) Let6989586621679115082TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115082TSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictEntrySym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictSym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115098TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115088TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) DBusSimpleTypeSym0 Source #
Methods suppressUnusedWarnings :: Proxy DBusSimpleTypeSym0 t -> () #
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) Let6989586621679115077TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115077TSym0 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictEntrySym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictSym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115098TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym1 t -> () #
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115088TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym1 t -> () #
data Sing DBusType Source #
data Sing DBusType where SDBusSimpleType :: Sing DBusType z STypeArray :: Sing DBusType z STypeStruct :: Sing DBusType z STypeDict :: Sing DBusType z STypeVariant :: Sing DBusType z STypeDictEntry :: Sing DBusType z STypeUnit :: Sing DBusType z
type DemoteRep DBusType Source #
type DemoteRep DBusType = DBusType
type (:/=) DBusType x y Source #
type (:/=) DBusType x y = Not ((:==) DBusType x y)
type (:==) DBusType a0 b0 Source #
type (:==) DBusType a0 b0 = Equals_6989586621679109114 a0 b0
type Apply DBusType DBusType TypeArraySym0 l0 Source #
type Apply DBusType DBusType TypeArraySym0 l0 = TypeArraySym1 l0
type Apply DBusType DBusType Let6989586621679115082TSym0 l0 Source #
type Apply DBusType DBusType Let6989586621679115082TSym0 l0 = Let6989586621679115082TSym1 l0
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 Source #
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 = DBusSimpleTypeSym1 l0
type Apply DBusSimpleType DBusType Let6989586621679115077TSym0 l0 Source #
type Apply DBusSimpleType DBusType Let6989586621679115077TSym0 l0 = Let6989586621679115077TSym1 l0
type Apply DBusType DBusType (TypeDictEntrySym1 l1) l0 Source #
type Apply DBusType DBusType (TypeDictEntrySym1 l1) l0 = TypeDictEntrySym2 l1 l0
type Apply DBusType DBusType (TypeDictSym1 l1) l0 Source #
type Apply DBusType DBusType (TypeDictSym1 l1) l0 = TypeDictSym2 l1 l0
type Apply DBusType DBusType (Let6989586621679115098TSym1 l1) l0 Source #
type Apply DBusType DBusType (Let6989586621679115098TSym1 l1) l0 = Let6989586621679115098TSym2 l1 l0
type Apply DBusType DBusType (Let6989586621679115088TSym1 l1) l0 Source #
type Apply DBusType DBusType (Let6989586621679115088TSym1 l1) l0 = Let6989586621679115088TSym2 l1 l0
type Apply DBusType [DBusType] FlattenRepTypeSym0 l0 Source #
type Apply DBusType [DBusType] FlattenRepTypeSym0 l0 = FlattenRepTypeSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 = TypeDictEntrySym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 = TypeDictSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 = Let6989586621679115098TSym1 l0
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 = Let6989586621679115088TSym1 l0
type Apply [DBusType] DBusType TypeStructSym0 l0 Source #
type Apply [DBusType] DBusType TypeStructSym0 l0 = TypeStructSym1 l0

ppType :: DBusType -> String Source #

Pretty-print a type (this is _not_ DBUs' type format)

data Parity Source #

Constructors

Null
Arg Parity

Instances

Eq Parity Source #
Methods (==) :: Parity -> Parity -> Bool # (/=) :: Parity -> Parity -> Bool #
Data Parity Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parity -> c Parity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Parity # toConstr :: Parity -> Constr # dataTypeOf :: Parity -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Parity) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parity) # gmapT :: (forall b. Data b => b -> b) -> Parity -> Parity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r # gmapQ :: (forall d. Data d => d -> u) -> Parity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Parity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parity -> m Parity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parity -> m Parity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parity -> m Parity #
Show Parity Source #
Methods showsPrec :: Int -> Parity -> ShowS # show :: Parity -> String # showList :: [Parity] -> ShowS #
SEq Parity Source #
Methods (%:==) :: Sing Parity a -> Sing Parity b -> Sing Bool ((Parity :== a) b) # (%:/=) :: Sing Parity a -> Sing Parity b -> Sing Bool ((Parity :/= a) b) #
SingKind Parity Source #
Associated Types type DemoteRep Parity :: * # Methods fromSing :: Sing Parity a -> DemoteRep Parity # toSing :: DemoteRep Parity -> SomeSing Parity #
SingI Parity Null Source #
Methods sing :: Sing Null a #
SingI Parity n0 => SingI Parity (Arg n0) Source #
Methods sing :: Sing (Arg n0) a #
PEq Parity (Proxy * Parity) Source #
Associated Types type ((Proxy * Parity) :== (x :: Proxy * Parity)) (y :: Proxy * Parity) :: Bool # type ((Proxy * Parity) :/= (x :: Proxy * Parity)) (y :: Proxy * Parity) :: Bool #
SuppressUnusedWarnings (TyFun Parity Parity -> *) ArgSym0 Source #
Methods suppressUnusedWarnings :: Proxy ArgSym0 t -> () #
data Sing Parity Source #
data Sing Parity where SNull :: Sing Parity z SArg :: Sing Parity z
type DemoteRep Parity Source #
type DemoteRep Parity = Parity
type (:/=) Parity x y Source #
type (:/=) Parity x y = Not ((:==) Parity x y)
type (:==) Parity a0 b0 Source #
type (:==) Parity a0 b0 = Equals_6989586621679109156 a0 b0
type Apply Parity Parity ArgSym0 l0 Source #
type Apply Parity Parity ArgSym0 l0 = ArgSym1 l0

type TypeByteSym0 = TypeByte Source #

type TypeBooleanSym0 = TypeBoolean Source #

type TypeInt16Sym0 = TypeInt16 Source #

type TypeUInt16Sym0 = TypeUInt16 Source #

type TypeInt32Sym0 = TypeInt32 Source #

type TypeUInt32Sym0 = TypeUInt32 Source #

type TypeInt64Sym0 = TypeInt64 Source #

type TypeUInt64Sym0 = TypeUInt64 Source #

type TypeDoubleSym0 = TypeDouble Source #

type TypeUnixFDSym0 = TypeUnixFD Source #

type TypeStringSym0 = TypeString Source #

type TypeObjectPathSym0 = TypeObjectPath Source #

type TypeSignatureSym0 = TypeSignature Source #

type SDBusSimpleType = (Sing :: DBusSimpleType -> Type) Source #

type DBusSimpleTypeSym1 t = DBusSimpleType t Source #

data DBusSimpleTypeSym0 l Source #

Constructors

(KindOf (Apply DBusSimpleTypeSym0 arg) ~ KindOf (DBusSimpleTypeSym1 arg)) => DBusSimpleTypeSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) DBusSimpleTypeSym0 Source #
Methods suppressUnusedWarnings :: Proxy DBusSimpleTypeSym0 t -> () #
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 Source #
type Apply DBusSimpleType DBusType DBusSimpleTypeSym0 l0 = DBusSimpleTypeSym1 l0

type TypeArraySym1 t = TypeArray t Source #

data TypeArraySym0 l Source #

Constructors

(KindOf (Apply TypeArraySym0 arg) ~ KindOf (TypeArraySym1 arg)) => TypeArraySym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusType DBusType -> *) TypeArraySym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeArraySym0 t -> () #
type Apply DBusType DBusType TypeArraySym0 l0 Source #
type Apply DBusType DBusType TypeArraySym0 l0 = TypeArraySym1 l0

type TypeStructSym1 t = TypeStruct t Source #

data TypeStructSym0 l Source #

Constructors

(KindOf (Apply TypeStructSym0 arg) ~ KindOf (TypeStructSym1 arg)) => TypeStructSym0KindInference

Instances

SuppressUnusedWarnings (TyFun [DBusType] DBusType -> *) TypeStructSym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeStructSym0 t -> () #
type Apply [DBusType] DBusType TypeStructSym0 l0 Source #
type Apply [DBusType] DBusType TypeStructSym0 l0 = TypeStructSym1 l0

type TypeDictSym2 t t = TypeDict t t Source #

data TypeDictSym1 l l Source #

Constructors

(KindOf (Apply (TypeDictSym1 l) arg) ~ KindOf (TypeDictSym2 l arg)) => TypeDictSym1KindInference

Instances

SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictSym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym1 t -> () #
type Apply DBusType DBusType (TypeDictSym1 l1) l0 Source #
type Apply DBusType DBusType (TypeDictSym1 l1) l0 = TypeDictSym2 l1 l0

data TypeDictSym0 l Source #

Constructors

(KindOf (Apply TypeDictSym0 arg) ~ KindOf (TypeDictSym1 arg)) => TypeDictSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictSym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictSym0 t -> () #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictSym0 l0 = TypeDictSym1 l0

type TypeVariantSym0 = TypeVariant Source #

type TypeDictEntrySym2 t t = TypeDictEntry t t Source #

data TypeDictEntrySym1 l l Source #

Constructors

(KindOf (Apply (TypeDictEntrySym1 l) arg) ~ KindOf (TypeDictEntrySym2 l arg)) => TypeDictEntrySym1KindInference

Instances

SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictEntrySym1 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym1 t -> () #
type Apply DBusType DBusType (TypeDictEntrySym1 l1) l0 Source #
type Apply DBusType DBusType (TypeDictEntrySym1 l1) l0 = TypeDictEntrySym2 l1 l0

data TypeDictEntrySym0 l Source #

Constructors

(KindOf (Apply TypeDictEntrySym0 arg) ~ KindOf (TypeDictEntrySym1 arg)) => TypeDictEntrySym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> Type) -> *) TypeDictEntrySym0 Source #
Methods suppressUnusedWarnings :: Proxy TypeDictEntrySym0 t -> () #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> Type) TypeDictEntrySym0 l0 = TypeDictEntrySym1 l0

type TypeUnitSym0 = TypeUnit Source #

type SDBusType = (Sing :: DBusType -> Type) Source #

type NullSym0 = Null Source #

type ArgSym1 t = Arg t Source #

data ArgSym0 l Source #

Constructors

(KindOf (Apply ArgSym0 arg) ~ KindOf (ArgSym1 arg)) => ArgSym0KindInference

Instances

SuppressUnusedWarnings (TyFun Parity Parity -> *) ArgSym0 Source #
Methods suppressUnusedWarnings :: Proxy ArgSym0 t -> () #
type Apply Parity Parity ArgSym0 l0 Source #
type Apply Parity Parity ArgSym0 l0 = ArgSym1 l0

type SParity = (Sing :: Parity -> Type) Source #

type family Equals_6989586621679109107 (a :: DBusSimpleType) (b :: DBusSimpleType) :: Bool where ... Source #

Equations

Equals_6989586621679109107 TypeByte TypeByte = TrueSym0
Equals_6989586621679109107 TypeBoolean TypeBoolean = TrueSym0
Equals_6989586621679109107 TypeInt16 TypeInt16 = TrueSym0
Equals_6989586621679109107 TypeUInt16 TypeUInt16 = TrueSym0
Equals_6989586621679109107 TypeInt32 TypeInt32 = TrueSym0
Equals_6989586621679109107 TypeUInt32 TypeUInt32 = TrueSym0
Equals_6989586621679109107 TypeInt64 TypeInt64 = TrueSym0
Equals_6989586621679109107 TypeUInt64 TypeUInt64 = TrueSym0
Equals_6989586621679109107 TypeDouble TypeDouble = TrueSym0
Equals_6989586621679109107 TypeUnixFD TypeUnixFD = TrueSym0
Equals_6989586621679109107 TypeString TypeString = TrueSym0
Equals_6989586621679109107 TypeObjectPath TypeObjectPath = TrueSym0
Equals_6989586621679109107 TypeSignature TypeSignature = TrueSym0
Equals_6989586621679109107 (a :: DBusSimpleType) (b :: DBusSimpleType) = FalseSym0

type family Equals_6989586621679109114 (a :: DBusType) (b :: DBusType) :: Bool where ... Source #

Equations

Equals_6989586621679109114 (DBusSimpleType a) (DBusSimpleType b) = (:==) a b
Equals_6989586621679109114 (TypeArray a) (TypeArray b) = (:==) a b
Equals_6989586621679109114 (TypeStruct a) (TypeStruct b) = (:==) a b
Equals_6989586621679109114 (TypeDict a a) (TypeDict b b) = (:&&) ((:==) a b) ((:==) a b)
Equals_6989586621679109114 TypeVariant TypeVariant = TrueSym0
Equals_6989586621679109114 (TypeDictEntry a a) (TypeDictEntry b b) = (:&&) ((:==) a b) ((:==) a b)
Equals_6989586621679109114 TypeUnit TypeUnit = TrueSym0
Equals_6989586621679109114 (a :: DBusType) (b :: DBusType) = FalseSym0

type family Equals_6989586621679109156 (a :: Parity) (b :: Parity) :: Bool where ... Source #

Equations

Equals_6989586621679109156 Null Null = TrueSym0
Equals_6989586621679109156 (Arg a) (Arg b) = (:==) a b
Equals_6989586621679109156 (a :: Parity) (b :: Parity) = FalseSym0

type family Let6989586621679115077T wild_6989586621679115069 where ... Source #

Equations

Let6989586621679115077T wild_6989586621679115069 = Apply DBusSimpleTypeSym0 wild_6989586621679115069

type Let6989586621679115077TSym1 t = Let6989586621679115077T t Source #

data Let6989586621679115077TSym0 l Source #

Constructors

(KindOf (Apply Let6989586621679115077TSym0 arg) ~ KindOf (Let6989586621679115077TSym1 arg)) => Let6989586621679115077TSym0KindInference

Instances

type family Let6989586621679115082T wild_6989586621679115067 where ... Source #

Equations

Let6989586621679115082T wild_6989586621679115067 = Apply TypeArraySym0 wild_6989586621679115067

type Let6989586621679115082TSym1 t = Let6989586621679115082T t Source #

data Let6989586621679115082TSym0 l Source #

Constructors

(KindOf (Apply Let6989586621679115082TSym0 arg) ~ KindOf (Let6989586621679115082TSym1 arg)) => Let6989586621679115082TSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusType DBusType -> *) Let6989586621679115082TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115082TSym0 t -> () #
type Apply DBusType DBusType Let6989586621679115082TSym0 l0 Source #
type Apply DBusType DBusType Let6989586621679115082TSym0 l0 = Let6989586621679115082TSym1 l0

type family Let6989586621679115088T wild_6989586621679115063 wild_6989586621679115065 where ... Source #

Equations

Let6989586621679115088T wild_6989586621679115063 wild_6989586621679115065 = Apply (Apply TypeDictSym0 wild_6989586621679115063) wild_6989586621679115065

type Let6989586621679115088TSym2 t t = Let6989586621679115088T t t Source #

data Let6989586621679115088TSym1 l l Source #

Constructors

(KindOf (Apply (Let6989586621679115088TSym1 l) arg) ~ KindOf (Let6989586621679115088TSym2 l arg)) => Let6989586621679115088TSym1KindInference

Instances

SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115088TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym1 t -> () #
type Apply DBusType DBusType (Let6989586621679115088TSym1 l1) l0 Source #
type Apply DBusType DBusType (Let6989586621679115088TSym1 l1) l0 = Let6989586621679115088TSym2 l1 l0

data Let6989586621679115088TSym0 l Source #

Constructors

(KindOf (Apply Let6989586621679115088TSym0 arg) ~ KindOf (Let6989586621679115088TSym1 arg)) => Let6989586621679115088TSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115088TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115088TSym0 t -> () #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115088TSym0 l0 = Let6989586621679115088TSym1 l0

type family Let6989586621679115098T wild_6989586621679115059 wild_6989586621679115061 where ... Source #

Equations

Let6989586621679115098T wild_6989586621679115059 wild_6989586621679115061 = Apply (Apply TypeDictEntrySym0 wild_6989586621679115059) wild_6989586621679115061

type Let6989586621679115098TSym2 t t = Let6989586621679115098T t t Source #

data Let6989586621679115098TSym1 l l Source #

Constructors

(KindOf (Apply (Let6989586621679115098TSym1 l) arg) ~ KindOf (Let6989586621679115098TSym2 l arg)) => Let6989586621679115098TSym1KindInference

Instances

SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let6989586621679115098TSym1 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym1 t -> () #
type Apply DBusType DBusType (Let6989586621679115098TSym1 l1) l0 Source #
type Apply DBusType DBusType (Let6989586621679115098TSym1 l1) l0 = Let6989586621679115098TSym2 l1 l0

data Let6989586621679115098TSym0 l Source #

Constructors

(KindOf (Apply Let6989586621679115098TSym0 arg) ~ KindOf (Let6989586621679115098TSym1 arg)) => Let6989586621679115098TSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let6989586621679115098TSym0 Source #
Methods suppressUnusedWarnings :: Proxy Let6989586621679115098TSym0 t -> () #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 Source #
type Apply DBusSimpleType (TyFun DBusType DBusType -> *) Let6989586621679115098TSym0 l0 = Let6989586621679115098TSym1 l0

type family Let6989586621679115106T where ... Source #

Equations

Let6989586621679115106T = TypeVariantSym0

type Let6989586621679115106TSym0 = Let6989586621679115106T Source #

type family FlattenRepType (a :: DBusType) :: [DBusType] where ... Source #

Equations

FlattenRepType TypeUnit = '[]
FlattenRepType (TypeStruct ts) = ts
FlattenRepType (DBusSimpleType wild_6989586621679115069) = Apply (Apply (:$) (Let6989586621679115077TSym1 wild_6989586621679115069)) '[]
FlattenRepType (TypeArray wild_6989586621679115067) = Apply (Apply (:$) (Let6989586621679115082TSym1 wild_6989586621679115067)) '[]
FlattenRepType (TypeDict wild_6989586621679115063 wild_6989586621679115065) = Apply (Apply (:$) (Let6989586621679115088TSym2 wild_6989586621679115063 wild_6989586621679115065)) '[]
FlattenRepType (TypeDictEntry wild_6989586621679115059 wild_6989586621679115061) = Apply (Apply (:$) (Let6989586621679115098TSym2 wild_6989586621679115059 wild_6989586621679115061)) '[]
FlattenRepType TypeVariant = Apply (Apply (:$) Let6989586621679115106TSym0) '[]

type FlattenRepTypeSym1 t = FlattenRepType t Source #

data FlattenRepTypeSym0 l Source #

Constructors

(KindOf (Apply FlattenRepTypeSym0 arg) ~ KindOf (FlattenRepTypeSym1 arg)) => FlattenRepTypeSym0KindInference

Instances

SuppressUnusedWarnings (TyFun DBusType [DBusType] -> *) FlattenRepTypeSym0 Source #
Methods suppressUnusedWarnings :: Proxy FlattenRepTypeSym0 t -> () #
type Apply DBusType [DBusType] FlattenRepTypeSym0 l0 Source #
type Apply DBusType [DBusType] FlattenRepTypeSym0 l0 = FlattenRepTypeSym1 l0

sFlattenRepType :: forall t. Sing t -> Sing (Apply FlattenRepTypeSym0 t :: [DBusType]) Source #

flattenRepType :: DBusType -> [DBusType] Source #

newtype MethodHandlerT m a Source #

A Transformer for (IO) actions that might want to send a signal.

Constructors

MHT
Fields unMHT :: ExceptT MsgError (WriterT [SomeSignal] m) a

Instances

MonadTrans MethodHandlerT Source #
Methods lift :: Monad m => m a -> MethodHandlerT m a #
Monad m => Monad (MethodHandlerT m) Source #
Methods (>>=) :: MethodHandlerT m a -> (a -> MethodHandlerT m b) -> MethodHandlerT m b # (>>) :: MethodHandlerT m a -> MethodHandlerT m b -> MethodHandlerT m b # return :: a -> MethodHandlerT m a # fail :: String -> MethodHandlerT m a #
Functor m => Functor (MethodHandlerT m) Source #
Methods fmap :: (a -> b) -> MethodHandlerT m a -> MethodHandlerT m b # (<$) :: a -> MethodHandlerT m b -> MethodHandlerT m a #
Monad m => Applicative (MethodHandlerT m) Source #
Methods pure :: a -> MethodHandlerT m a # (<>) :: MethodHandlerT m (a -> b) -> MethodHandlerT m a -> MethodHandlerT m b # (>) :: MethodHandlerT m a -> MethodHandlerT m b -> MethodHandlerT m b # (<*) :: MethodHandlerT m a -> MethodHandlerT m b -> MethodHandlerT m a #
(Functor m, Monad m) => Alternative (MethodHandlerT m) Source #
Methods empty :: MethodHandlerT m a # (<\|>) :: MethodHandlerT m a -> MethodHandlerT m a -> MethodHandlerT m a # some :: MethodHandlerT m a -> MethodHandlerT m [a] # many :: MethodHandlerT m a -> MethodHandlerT m [a] #
Monad m => MonadPlus (MethodHandlerT m) Source #
Methods mzero :: MethodHandlerT m a # mplus :: MethodHandlerT m a -> MethodHandlerT m a -> MethodHandlerT m a #
MonadIO m => MonadIO (MethodHandlerT m) Source #
Methods liftIO :: IO a -> MethodHandlerT m a #
MonadThrow m => MonadThrow (MethodHandlerT m) Source #
Methods throwM :: Exception e => e -> MethodHandlerT m a #
MonadCatch m => MonadCatch (MethodHandlerT m) Source #
Methods catch :: Exception e => MethodHandlerT m a -> (e -> MethodHandlerT m a) -> MethodHandlerT m a #
Representable t => RepMethod (MethodHandlerT IO t) Source #
Associated Types type RepMethodArgs (MethodHandlerT IO t) :: [DBusType] Source # type RepMethodValue (MethodHandlerT IO t) :: [DBusType] Source # Methods repMethod :: MethodHandlerT IO t -> MethodWrapper (RepMethodArgs (MethodHandlerT IO t)) (RepMethodValue (MethodHandlerT IO t)) Source #
SingI [DBusType] ts => IsMethod (MethodHandlerT IO (DBusArguments ts)) Source #
Associated Types type ArgTypes (MethodHandlerT IO (DBusArguments ts)) :: [DBusType] Source # type ResultType (MethodHandlerT IO (DBusArguments ts)) :: [DBusType] Source # Methods toMethod :: MethodHandlerT IO (DBusArguments ts) -> MethodWrapper (ArgTypes (MethodHandlerT IO (DBusArguments ts))) (ResultType (MethodHandlerT IO (DBusArguments ts))) Source #
type RepMethodArgs (MethodHandlerT IO t) Source #
type RepMethodArgs (MethodHandlerT IO t) = [] DBusType
type RepMethodValue (MethodHandlerT IO t) Source #
type RepMethodValue (MethodHandlerT IO t) = FlattenRepType (RepType t)
type ArgTypes (MethodHandlerT IO (DBusArguments ts)) Source #
type ArgTypes (MethodHandlerT IO (DBusArguments ts)) = [] DBusType
type ResultType (MethodHandlerT IO (DBusArguments ts)) Source #
type ResultType (MethodHandlerT IO (DBusArguments ts)) = ts

methodError :: Monad m => MsgError -> MethodHandlerT m a Source #

catchMethodError :: Monad m => MethodHandlerT m a -> (MsgError -> MethodHandlerT m a) -> MethodHandlerT m a Source #

runMethodHandlerT :: MethodHandlerT m a -> m (Either MsgError a, [SomeSignal]) Source #

data Signal a Source #

Constructors

Signal
Fields signalPath :: ObjectPath signalInterface :: InterfaceName signalMember :: MemberName signalBody :: DBusArguments a

Instances

SingI [DBusType] a => Show (Signal a) Source #
Methods showsPrec :: Int -> Signal a -> ShowS # show :: Signal a -> String # showList :: [Signal a] -> ShowS #

data SomeSignal where Source #

Constructors

SomeSignal :: SingI a => Signal a -> SomeSignal

Instances

Show SomeSignal Source #
Methods showsPrec :: Int -> SomeSignal -> ShowS # show :: SomeSignal -> String # showList :: [SomeSignal] -> ShowS #

data SignalDescription a Source #

Constructors

SignalDescription
Fields signalDPath :: ObjectPath signalDInterface :: InterfaceName signalDMember :: MemberName signalDArguments :: ArgumentDescription (ArgParity a)

Instances

Eq (SignalDescription a) Source #
Methods (==) :: SignalDescription a -> SignalDescription a -> Bool # (/=) :: SignalDescription a -> SignalDescription a -> Bool #
SingI [DBusType] a => Show (SignalDescription a) Source #
Methods showsPrec :: Int -> SignalDescription a -> ShowS # show :: SignalDescription a -> String # showList :: [SignalDescription a] -> ShowS #

signalDArgumentTypes :: SingI ts => SignalDescription ts -> [DBusType] Source #

data SomeSignalDescription where Source #

Constructors

SSD :: forall a. SingI a => SignalDescription a -> SomeSignalDescription

Instances

Eq SomeSignalDescription Source #
Methods (==) :: SomeSignalDescription -> SomeSignalDescription -> Bool # (/=) :: SomeSignalDescription -> SomeSignalDescription -> Bool #
Show SomeSignalDescription Source #
Methods showsPrec :: Int -> SomeSignalDescription -> ShowS # show :: SomeSignalDescription -> String # showList :: [SomeSignalDescription] -> ShowS #

type family ArgsOf x :: Parity where ... Source #

Equations

ArgsOf (IO x) = Null
ArgsOf (MethodHandlerT IO x) = Null
ArgsOf (a -> b) = Arg (ArgsOf b)

type family ArgParity (x :: [DBusType]) :: Parity where ... Source #

Equations

ArgParity '[] = Null
ArgParity (x ': xs) = Arg (ArgParity xs)

data ArgumentDescription parity where Source #

Constructors

(:>) :: Text -> ArgumentDescription n -> ArgumentDescription (Arg n) infixr 0
Done :: ArgumentDescription Null

Instances

Show (ArgumentDescription n) Source #
Methods showsPrec :: Int -> ArgumentDescription n -> ShowS # show :: ArgumentDescription n -> String # showList :: [ArgumentDescription n] -> ShowS #

adToList :: ArgumentDescription n -> [Text] Source #

data DBusArguments :: [DBusType] -> * where Source #

Constructors

ArgsNil :: DBusArguments '[]
ArgsCons :: DBusValue a -> DBusArguments as -> DBusArguments (a ': as)

Instances

Eq (DBusArguments t) Source #
Methods (==) :: DBusArguments t -> DBusArguments t -> Bool # (/=) :: DBusArguments t -> DBusArguments t -> Bool #
SingI [DBusType] a => Show (DBusArguments a) Source #
Methods showsPrec :: Int -> DBusArguments a -> ShowS # show :: DBusArguments a -> String # showList :: [DBusArguments a] -> ShowS #
SingI [DBusType] ts => IsMethod (IO (DBusArguments ts)) Source #
Associated Types type ArgTypes (IO (DBusArguments ts)) :: [DBusType] Source # type ResultType (IO (DBusArguments ts)) :: [DBusType] Source # Methods toMethod :: IO (DBusArguments ts) -> MethodWrapper (ArgTypes (IO (DBusArguments ts))) (ResultType (IO (DBusArguments ts))) Source #
SingI [DBusType] ts => IsMethod (MethodHandlerT IO (DBusArguments ts)) Source #
Associated Types type ArgTypes (MethodHandlerT IO (DBusArguments ts)) :: [DBusType] Source # type ResultType (MethodHandlerT IO (DBusArguments ts)) :: [DBusType] Source # Methods toMethod :: MethodHandlerT IO (DBusArguments ts) -> MethodWrapper (ArgTypes (MethodHandlerT IO (DBusArguments ts))) (ResultType (MethodHandlerT IO (DBusArguments ts))) Source #
type ArgTypes (IO (DBusArguments ts)) Source #
type ArgTypes (IO (DBusArguments ts)) = [] DBusType
type ResultType (IO (DBusArguments ts)) Source #
type ResultType (IO (DBusArguments ts)) = ts
type ArgTypes (MethodHandlerT IO (DBusArguments ts)) Source #
type ArgTypes (MethodHandlerT IO (DBusArguments ts)) = [] DBusType
type ResultType (MethodHandlerT IO (DBusArguments ts)) Source #
type ResultType (MethodHandlerT IO (DBusArguments ts)) = ts

data SomeDBusArguments where Source #

Constructors

SDBA :: SingI ts => DBusArguments ts -> SomeDBusArguments

Instances

Show SomeDBusArguments Source #
Methods showsPrec :: Int -> SomeDBusArguments -> ShowS # show :: SomeDBusArguments -> String # showList :: [SomeDBusArguments] -> ShowS #

listToSomeArguments :: [SomeDBusValue] -> SomeDBusArguments Source #

argsToValues :: SomeDBusArguments -> [SomeDBusValue] Source #

argsToStruct :: DBusArguments (t ': ts) -> DBusStruct (t ': ts) Source #

structToArgs :: DBusStruct ts -> DBusArguments ts Source #

maybeArgsToStruct :: (SingI ts, SingI ss) => DBusArguments ts -> Maybe (DBusStruct ss) Source #

singletonArg :: DBusValue a -> DBusArguments '[a] Source #

showArgs :: Sing a -> DBusArguments a -> String Source #

data DBusStruct :: [DBusType] -> * where Source #

Constructors

StructSingleton :: DBusValue a -> DBusStruct '[a]
StructCons :: DBusValue a -> DBusStruct as -> DBusStruct (a ': as)

Instances

Eq (DBusStruct t) Source #
Methods (==) :: DBusStruct t -> DBusStruct t -> Bool # (/=) :: DBusStruct t -> DBusStruct t -> Bool #
SingI [DBusType] a => Show (DBusStruct a) Source #
Methods showsPrec :: Int -> DBusStruct a -> ShowS # show :: DBusStruct a -> String # showList :: [DBusStruct a] -> ShowS #

data SomeDBusStruct where Source #

Constructors

SDBS :: SingI ts => DBusStruct ts -> SomeDBusStruct

showStruct :: Sing a -> DBusStruct a -> String Source #

data DBusValue :: DBusType -> * where Source #

Constructors

DBVByte :: Word8 -> DBusValue (DBusSimpleType TypeByte)
DBVBool :: Bool -> DBusValue (DBusSimpleType TypeBoolean)
DBVInt16 :: Int16 -> DBusValue (DBusSimpleType TypeInt16)
DBVUInt16 :: Word16 -> DBusValue (DBusSimpleType TypeUInt16)
DBVInt32 :: Int32 -> DBusValue (DBusSimpleType TypeInt32)
DBVUInt32 :: Word32 -> DBusValue (DBusSimpleType TypeUInt32)
DBVInt64 :: Int64 -> DBusValue (DBusSimpleType TypeInt64)
DBVUInt64 :: Word64 -> DBusValue (DBusSimpleType TypeUInt64)
DBVDouble :: Double -> DBusValue (DBusSimpleType TypeDouble)
DBVUnixFD :: Word32 -> DBusValue (DBusSimpleType TypeUnixFD)
DBVString :: Text -> DBusValue (DBusSimpleType TypeString)
DBVObjectPath :: ObjectPath -> DBusValue (DBusSimpleType TypeObjectPath)
DBVSignature :: [DBusType] -> DBusValue (DBusSimpleType TypeSignature)
DBVVariant :: SingI t => DBusValue t -> DBusValue TypeVariant
DBVArray :: [DBusValue a] -> DBusValue (TypeArray a)
DBVByteArray :: ByteString -> DBusValue (TypeArray (DBusSimpleType TypeByte))
DBVStruct :: DBusStruct ts -> DBusValue (TypeStruct ts)
DBVDict :: [(DBusValue (DBusSimpleType k), DBusValue v)] -> DBusValue (TypeDict k v)
DBVUnit :: DBusValue TypeUnit

Instances

Eq (DBusValue t) Source #
Methods (==) :: DBusValue t -> DBusValue t -> Bool # (/=) :: DBusValue t -> DBusValue t -> Bool #
SingI DBusType t => Show (DBusValue t) Source #
Methods showsPrec :: Int -> DBusValue t -> ShowS # show :: DBusValue t -> String # showList :: [DBusValue t] -> ShowS #
(IsMethod f, SingI DBusType t) => IsMethod (DBusValue t -> f) Source #
Associated Types type ArgTypes (DBusValue t -> f) :: [DBusType] Source # type ResultType (DBusValue t -> f) :: [DBusType] Source # Methods toMethod :: (DBusValue t -> f) -> MethodWrapper (ArgTypes (DBusValue t -> f)) (ResultType (DBusValue t -> f)) Source #
type RepType (DBusValue t) Source #
type RepType (DBusValue t) = t
type ArgTypes (DBusValue t -> f) Source #
type ArgTypes (DBusValue t -> f) = (:) DBusType t (ArgTypes f)
type ResultType (DBusValue t -> f) Source #
type ResultType (DBusValue t -> f) = ResultType f

castDBV :: (SingI s, SingI t) => DBusValue s -> Maybe (DBusValue t) Source #

data SomeDBusValue where Source #

Constructors

DBV :: SingI t => DBusValue t -> SomeDBusValue

Instances

Show SomeDBusValue Source #
Methods showsPrec :: Int -> SomeDBusValue -> ShowS # show :: SomeDBusValue -> String # showList :: [SomeDBusValue] -> ShowS #

dbusValue :: SingI t => SomeDBusValue -> Maybe (DBusValue t) Source #

dbusSValue :: SingI t => SomeDBusValue -> Maybe (DBusValue (DBusSimpleType t)) Source #

fromVariant :: SingI t => DBusValue TypeVariant -> Maybe (DBusValue t) Source #

Extract a DBusValue from a Variant iff the type matches or return nothing

typeOf :: SingI t => DBusValue t -> DBusType Source #

class SingI (RepType a) => Representable a where Source #

Class of types that can be represented in the D-Bus type system.

The toRep and fromRep functions form a Prism and should follow the "obvious" laws:

```
fromRep (toRep x) == Just x
```
```
fmap toRep (fromRep x) =<= Just x
```

(where x =<= y iff x is Nothing or x == y)

All DBusValues represent themselves and instances for the following "canonical" pairs are provided

Haskell type => D-Bus type

WordX and IntX => UIntX and IntX respectively (for X in {16, 32, 64})
Bool => Boolean
Word8 => Byte
Double => Double
Text => String
ObjectPath => ObjectPath
DBusType => Signature
[a] => Array of a (for Representable a)
ByteString => Array of Byte
Tuples up to length 20 => Structs of equal length where each of the members is itself Representable
Map => Dict where the keys can be represented by a DBusSimpleType

An instance for String is impossible because it conflicts with the instance for lists (use Text instead)

Also note that no Representable instances are provided for Int, Integer and Float.

You can automatically derive an instance for your own Types with makeRepresentable

Minimal complete definition

toRep, fromRep

Associated Types

type RepType a :: DBusType Source #

The DBusType that represents this type

Methods

toRep :: a -> DBusValue (RepType a) Source #

Conversion from Haskell to D-Bus types

fromRep :: DBusValue (RepType a) -> Maybe a Source #

Conversion from D-Bus to Haskell types.

Instances

Representable HeaderField Source #
Associated Types type RepType HeaderField :: DBusType Source # Methods toRep :: HeaderField -> DBusValue (RepType HeaderField) Source # fromRep :: DBusValue (RepType HeaderField) -> Maybe HeaderField Source #
Representable HeaderFields Source #
Associated Types type RepType HeaderFields :: DBusType Source # Methods toRep :: HeaderFields -> DBusValue (RepType HeaderFields) Source # fromRep :: DBusValue (RepType HeaderFields) -> Maybe HeaderFields Source #
Representable Flags Source #
Associated Types type RepType Flags :: DBusType Source # Methods toRep :: Flags -> DBusValue (RepType Flags) Source # fromRep :: DBusValue (RepType Flags) -> Maybe Flags Source #
Representable MessageType Source #
Associated Types type RepType MessageType :: DBusType Source # Methods toRep :: MessageType -> DBusValue (RepType MessageType) Source # fromRep :: DBusValue (RepType MessageType) -> Maybe MessageType Source #
Representable MessageHeader Source #
Associated Types type RepType MessageHeader :: DBusType Source # Methods toRep :: MessageHeader -> DBusValue (RepType MessageHeader) Source # fromRep :: DBusValue (RepType MessageHeader) -> Maybe MessageHeader Source #

type family FromTypeList t where ... Source #

Equations

FromTypeList '[] = TypeUnit
FromTypeList '[t] = t
FromTypeList ts = TypeStruct ts

data MethodWrapper av rv where Source #

Constructors

MReturn :: SingI ts => MethodHandlerT IO (DBusArguments ts) -> MethodWrapper '[] ts
MAsk :: SingI t => (DBusValue t -> MethodWrapper avs rv) -> MethodWrapper (t ': avs) rv

data Method where Source #

Constructors

Method :: (SingI avs, SingI ts) => MethodWrapper avs ts -> Text -> ArgumentDescription (ArgParity avs) -> ArgumentDescription (ArgParity ts) -> Method

data PropertyAccess Source #

Constructors

Read
Write
ReadWrite

Instances

Eq PropertyAccess Source #
Methods (==) :: PropertyAccess -> PropertyAccess -> Bool # (/=) :: PropertyAccess -> PropertyAccess -> Bool #
Data PropertyAccess Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PropertyAccess -> c PropertyAccess # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PropertyAccess # toConstr :: PropertyAccess -> Constr # dataTypeOf :: PropertyAccess -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PropertyAccess) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PropertyAccess) # gmapT :: (forall b. Data b => b -> b) -> PropertyAccess -> PropertyAccess # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PropertyAccess -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PropertyAccess -> r # gmapQ :: (forall d. Data d => d -> u) -> PropertyAccess -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PropertyAccess -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PropertyAccess -> m PropertyAccess # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PropertyAccess -> m PropertyAccess # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PropertyAccess -> m PropertyAccess #
Show PropertyAccess Source #
Methods showsPrec :: Int -> PropertyAccess -> ShowS # show :: PropertyAccess -> String # showList :: [PropertyAccess] -> ShowS #

data PropertyEmitsChangedSignal Source #

Constructors

PECSTrue
PECSInvalidates
PECSFalse

data Property t where Source #

Constructors

Property :: forall t. SingI t => {..} -> Property t
Fields propertyPath :: ObjectPath propertyInterface :: Text propertyName :: Text propertyGet :: Maybe (MethodHandlerT IO (DBusValue t)) propertySet :: Maybe (DBusValue t -> MethodHandlerT IO Bool) propertyEmitsChangedSignal :: PropertyEmitsChangedSignal

data SomeProperty where Source #

Constructors

SomeProperty :: forall t. SingI t => {..} -> SomeProperty
Fields fromSomeProperty :: Property t

propertyType :: SingI t => Property t -> DBusType Source #

data RemoteProperty a Source #

Constructors

RP
Fields rpEntity :: Text rpObject :: ObjectPath rpInterface :: Text rpName :: Text

Instances

Eq (RemoteProperty k a) Source #
Methods (==) :: RemoteProperty k a -> RemoteProperty k a -> Bool # (/=) :: RemoteProperty k a -> RemoteProperty k a -> Bool #
Show (RemoteProperty k a) Source #
Methods showsPrec :: Int -> RemoteProperty k a -> ShowS # show :: RemoteProperty k a -> String # showList :: [RemoteProperty k a] -> ShowS #

data Annotation Source #

Constructors

Annotation
Fields annotationName :: Text annotationValue :: Text

Instances

Eq Annotation Source #
Methods (==) :: Annotation -> Annotation -> Bool # (/=) :: Annotation -> Annotation -> Bool #
Data Annotation Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Annotation -> c Annotation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Annotation # toConstr :: Annotation -> Constr # dataTypeOf :: Annotation -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Annotation) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Annotation) # gmapT :: (forall b. Data b => b -> b) -> Annotation -> Annotation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Annotation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Annotation -> r # gmapQ :: (forall d. Data d => d -> u) -> Annotation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Annotation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation #
Show Annotation Source #
Methods showsPrec :: Int -> Annotation -> ShowS # show :: Annotation -> String # showList :: [Annotation] -> ShowS #

data SignalArgument Source #

Constructors

SignalArgument
Fields signalArgumentName :: Text signalArgumentType :: DBusType

data Interface Source #

Constructors

Interface
Fields interfaceMethods :: [Method] interfaceAnnotations :: [Annotation] interfaceSignals :: [SomeSignalDescription] interfaceProperties :: [SomeProperty]

Instances

Monoid Interface Source #
Methods mempty :: Interface # mappend :: Interface -> Interface -> Interface # mconcat :: [Interface] -> Interface #

newtype Object Source #

Constructors

Object
Fields interfaces :: Map Text Interface

Instances

Monoid Object Source #
Methods mempty :: Object # mappend :: Object -> Object -> Object # mconcat :: [Object] -> Object #

object :: Text -> Interface -> Object Source #

newtype Objects Source #

Constructors

Objects
Fields unObjects :: Map ObjectPath Object

Instances

Monoid Objects Source #
Methods mempty :: Objects # mappend :: Objects -> Objects -> Objects # mconcat :: [Objects] -> Objects #

root :: ObjectPath -> Object -> Objects Source #

data MsgError Source #

Constructors

MsgError
Fields errorName :: Text errorText :: Maybe Text errorBody :: [SomeDBusValue]

Instances

Show MsgError Source #
Methods showsPrec :: Int -> MsgError -> ShowS # show :: MsgError -> String # showList :: [MsgError] -> ShowS #
Exception MsgError Source #
Methods toException :: MsgError -> SomeException # fromException :: SomeException -> Maybe MsgError # displayException :: MsgError -> String #

data MethodError Source #

Constructors

MethodErrorMessage [SomeDBusValue]
MethodSignatureMissmatch [SomeDBusValue]

Instances

Show MethodError Source #
Methods showsPrec :: Int -> MethodError -> ShowS # show :: MethodError -> String # showList :: [MethodError] -> ShowS #
Exception MethodError Source #
Methods toException :: MethodError -> SomeException # fromException :: SomeException -> Maybe MethodError # displayException :: MethodError -> String #

type Serial = Word32 Source #

type Slot = Either [SomeDBusValue] [SomeDBusValue] -> STM () Source #

type AnswerSlots = Map Serial Slot Source #

data Match a Source #

Constructors

Match a
MatchAny

Instances

Show a => Show (Match a) Source #
Methods showsPrec :: Int -> Match a -> ShowS # show :: Match a -> String # showList :: [Match a] -> ShowS #

checkMatch :: Eq a => Match a -> Match a -> Bool Source #

maybeToMatch :: Maybe a -> Match a Source #

data MatchSignal Source #

Constructors

MatchSignal
Fields matchInterface :: Maybe Text matchMember :: Maybe Text matchPath :: Maybe ObjectPath matchSender :: Maybe Text

Instances

Eq MatchSignal Source #
Methods (==) :: MatchSignal -> MatchSignal -> Bool # (/=) :: MatchSignal -> MatchSignal -> Bool #
Ord MatchSignal Source #
Methods compare :: MatchSignal -> MatchSignal -> Ordering # (<) :: MatchSignal -> MatchSignal -> Bool # (<=) :: MatchSignal -> MatchSignal -> Bool # (>) :: MatchSignal -> MatchSignal -> Bool # (>=) :: MatchSignal -> MatchSignal -> Bool # max :: MatchSignal -> MatchSignal -> MatchSignal # min :: MatchSignal -> MatchSignal -> MatchSignal #
Show MatchSignal Source #
Methods showsPrec :: Int -> MatchSignal -> ShowS # show :: MatchSignal -> String # showList :: [MatchSignal] -> ShowS #

anySignal :: MatchSignal Source #

type SignalSlots = [((Match Text, Match Text, Match ObjectPath, Match Text), SomeSignal -> IO ())] Source #

type PropertySlots = Map (ObjectPath, Text, Text) [Maybe SomeDBusValue -> IO ()] Source #

data DBusConnection Source #

A value representing a connection to a DBus bus. Use connectBus or makeServer to Create

Constructors

DBusConnection

Fields

dBusCreateSerial :: STM Serial
dBusAnswerSlots :: TVar AnswerSlots
dBusSignalSlots :: TVar SignalSlots
dBusPropertySlots :: TVar PropertySlots
dBusWriteLock :: TMVar (Builder -> IO ())
dBusConnectionName :: Text
dBusConnectionAliveRef :: TVar Bool
dBusGcRef :: !(TVar ())
A dummy TVar to which we attach a finalizer. When this TVar is garbage-collected, the connection is closed.
dBusKillConnection :: IO ()
Killing the handlerThread closes the connection and all handlers

data MethodDescription args rets where Source #

Constructors

MD :: {..} -> MethodDescription args rets
Fields methodObjectPath :: ObjectPath methodInterface :: Text methodMember :: Text methodArgs :: ArgumentDescription (ArgParity args) methodResult :: ArgumentDescription (ArgParity rets)

Instances

Show (MethodDescription args rets) Source #
Methods showsPrec :: Int -> MethodDescription args rets -> ShowS # show :: MethodDescription args rets -> String # showList :: [MethodDescription args rets] -> ShowS #

data SomeMethodDescription where Source #

Constructors

SMD :: (SingI args, SingI rets) => MethodDescription args rets -> SomeMethodDescription