dbus-0.10.13: A client library for the D-Bus IPC system.

Safe Haskell | None
Language | Haskell98

DBus.Internal.Types

Synopsis

- data Type
  - = TypeBoolean
  - | TypeWord8
  - | TypeWord16
  - | TypeWord32
  - | TypeWord64
  - | TypeInt16
  - | TypeInt32
  - | TypeInt64
  - | TypeDouble
  - | TypeUnixFd
  - | TypeString
  - | TypeSignature
  - | TypeObjectPath
  - | TypeVariant
  - | TypeArray Type
  - | TypeDictionary Type Type
  - | TypeStructure [Type]
- showType :: Bool -> Type -> String
- newtype Signature = Signature [Type]
- signatureTypes :: Signature -> [Type]
- formatSignature :: Signature -> String
- typeCode :: Type -> String
- signature :: [Type] -> Maybe Signature
- signature_ :: [Type] -> Signature
- parseSignature :: String -> Maybe Signature
- parseSignatureBytes :: ByteString -> Maybe Signature
- parseSigFast :: ByteString -> Maybe Signature
- parseAtom :: Int -> (Type -> a) -> a -> a
- data SigParseError = SigParseError
- peekWord8AsInt :: Ptr Word8 -> Int -> IO Int
- parseSigFull :: ByteString -> Maybe Signature
- class IsVariant a where
- class IsVariant a => IsValue a where
- class IsValue a => IsAtom a where
- newtype Variant = Variant Value
- data Value
  - = ValueAtom Atom
  - | ValueVariant Variant
  - | ValueBytes ByteString
  - | ValueVector Type (Vector Value)
  - | ValueMap Type Type (Map Atom Value)
  - | ValueStructure [Value]
- data Atom
  - = AtomBool Bool
  - | AtomWord8 Word8
  - | AtomWord16 Word16
  - | AtomWord32 Word32
  - | AtomWord64 Word64
  - | AtomInt16 Int16
  - | AtomInt32 Int32
  - | AtomInt64 Int64
  - | AtomDouble Double
  - | AtomUnixFd Fd
  - | AtomText Text
  - | AtomSignature Signature
  - | AtomObjectPath ObjectPath
- showAtom :: Bool -> Atom -> String
- showValue :: Bool -> Value -> String
- showThings :: String -> (a -> String) -> String -> [a] -> String
- vectorToBytes :: Vector Value -> ByteString
- variantType :: Variant -> Type
- valueType :: Value -> Type
- atomType :: Atom -> Type
- vectorItemType :: IsValue a => Vector a -> Type
- bimap :: Ord k' => (k -> v -> (k', v')) -> Map k v -> Map k' v'
- bimapM :: (Monad m, Ord k') => (k -> v -> m (k', v')) -> Map k v -> m (Map k' v')
- mapItemType :: (IsValue k, IsValue v) => Map k v -> (Type, Type)
- varToVal :: IsVariant a => a -> Value
- newtype ObjectPath = ObjectPath String
- formatObjectPath :: ObjectPath -> String
- parseObjectPath :: String -> Maybe ObjectPath
- objectPath_ :: String -> ObjectPath
- parserObjectPath :: Parser ()
- newtype InterfaceName = InterfaceName String
- formatInterfaceName :: InterfaceName -> String
- parseInterfaceName :: String -> Maybe InterfaceName
- interfaceName_ :: String -> InterfaceName
- parserInterfaceName :: Parser ()
- newtype MemberName = MemberName String
- formatMemberName :: MemberName -> String
- parseMemberName :: String -> Maybe MemberName
- memberName_ :: String -> MemberName
- parserMemberName :: Parser ()
- newtype ErrorName = ErrorName String
- formatErrorName :: ErrorName -> String
- parseErrorName :: String -> Maybe ErrorName
- errorName_ :: String -> ErrorName
- newtype BusName = BusName String
- formatBusName :: BusName -> String
- parseBusName :: String -> Maybe BusName
- busName_ :: String -> BusName
- parserBusName :: Parser ()
- newtype Structure = Structure [Value]
- structureItems :: Structure -> [Variant]
- data Array
  - = Array Type (Vector Value)
  - | ArrayBytes ByteString
- arrayItems :: Array -> [Variant]
- data Dictionary = Dictionary Type Type (Map Atom Value)
- dictionaryItems :: Dictionary -> [(Variant, Variant)]
- newtype Serial = Serial Word32
- serialValue :: Serial -> Word32
- firstSerial :: Serial
- nextSerial :: Serial -> Serial
- skipSepBy1 :: Parser a -> Parser b -> Parser ()
- forceParse :: String -> (String -> Maybe a) -> String -> a
- maybeParseString :: Parser a -> String -> Maybe a

# Documentation

data Type #

Constructors

TypeBoolean |
TypeWord8 |
TypeWord16 |
TypeWord32 |
TypeWord64 |
TypeInt16 |
TypeInt32 |
TypeInt64 |
TypeDouble |
TypeUnixFd |
TypeString |
TypeSignature |
TypeObjectPath |
TypeVariant |
TypeArray Type |
TypeDictionary Type Type |
TypeStructure [Type] |

Instances

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

showType :: Bool -> Type -> String #

newtype Signature #

A signature is a list of D-Bus types, obeying some basic rules of validity.

The rules of signature validity are complex: see http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-signatures for details.

Constructors

Signature [Type] |

Instances

Eq Signature # |
Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Ord Signature # |
Methods compare :: Signature -> Signature -> Ordering # (<) :: Signature -> Signature -> Bool # (<=) :: Signature -> Signature -> Bool # (>) :: Signature -> Signature -> Bool # (>=) :: Signature -> Signature -> Bool # max :: Signature -> Signature -> Signature # min :: Signature -> Signature -> Signature #
Show Signature # |
Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
IsString Signature # |
Methods fromString :: String -> Signature #
IsAtom Signature # |
Methods toAtom :: Signature -> Atom # fromAtom :: Atom -> Maybe Signature #
IsValue Signature # |
Methods typeOf :: Signature -> Type # toValue :: Signature -> Value # fromValue :: Value -> Maybe Signature #
IsVariant Signature # |
Methods toVariant :: Signature -> Variant # fromVariant :: Variant -> Maybe Signature #

signatureTypes :: Signature -> [Type] #

Get the list of types in a signature. The inverse of `signature`.

formatSignature :: Signature -> String #

Convert a signature into a signature string. The inverse of `parseSignature`.

typeCode :: Type -> String #

signature :: [Type] -> Maybe Signature #

Convert a list of types into a valid signature.

Returns `Nothing` if the given types are not a valid signature.

signature_ :: [Type] -> Signature #

Convert a list of types into a valid signature.

Throws an exception if the given types are not a valid signature.

parseSignature :: String -> Maybe Signature #

Parse a signature string into a valid signature.

Returns `Nothing` if the given string is not a valid signature.

parseSignatureBytes :: ByteString -> Maybe Signature #

parseSigFast :: ByteString -> Maybe Signature #

parseAtom :: Int -> (Type -> a) -> a -> a #

data SigParseError #

Constructors

SigParseError |

Instances

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

peekWord8AsInt :: Ptr Word8 -> Int -> IO Int #

parseSigFull :: ByteString -> Maybe Signature #

class IsVariant a where #

Minimal complete definition

toVariant, fromVariant

Methods

toVariant :: a -> Variant #

fromVariant :: Variant -> Maybe a #

Instances

IsVariant Bool # |
Methods toVariant :: Bool -> Variant # fromVariant :: Variant -> Maybe Bool #
IsVariant Double # |
Methods toVariant :: Double -> Variant # fromVariant :: Variant -> Maybe Double #
IsVariant Int16 # |
Methods toVariant :: Int16 -> Variant # fromVariant :: Variant -> Maybe Int16 #
IsVariant Int32 # |
Methods toVariant :: Int32 -> Variant # fromVariant :: Variant -> Maybe Int32 #
IsVariant Int64 # |
Methods toVariant :: Int64 -> Variant # fromVariant :: Variant -> Maybe Int64 #
IsVariant Word8 # |
Methods toVariant :: Word8 -> Variant # fromVariant :: Variant -> Maybe Word8 #
IsVariant Word16 # |
Methods toVariant :: Word16 -> Variant # fromVariant :: Variant -> Maybe Word16 #
IsVariant Word32 # |
Methods toVariant :: Word32 -> Variant # fromVariant :: Variant -> Maybe Word32 #
IsVariant Word64 # |
Methods toVariant :: Word64 -> Variant # fromVariant :: Variant -> Maybe Word64 #
IsVariant Fd # |
Methods toVariant :: Fd -> Variant # fromVariant :: Variant -> Maybe Fd #
IsVariant String # |
Methods toVariant :: String -> Variant # fromVariant :: Variant -> Maybe String #
IsVariant ByteString # |
Methods toVariant :: ByteString -> Variant # fromVariant :: Variant -> Maybe ByteString #
IsVariant ByteString # |
Methods toVariant :: ByteString -> Variant # fromVariant :: Variant -> Maybe ByteString #
IsVariant Text # |
Methods toVariant :: Text -> Variant # fromVariant :: Variant -> Maybe Text #
IsVariant Text # |
Methods toVariant :: Text -> Variant # fromVariant :: Variant -> Maybe Text #
IsVariant Serial # |
Methods toVariant :: Serial -> Variant # fromVariant :: Variant -> Maybe Serial #
IsVariant Dictionary # |
Methods toVariant :: Dictionary -> Variant # fromVariant :: Variant -> Maybe Dictionary #
IsVariant Array # |
Methods toVariant :: Array -> Variant # fromVariant :: Variant -> Maybe Array #
IsVariant Structure # |
Methods toVariant :: Structure -> Variant # fromVariant :: Variant -> Maybe Structure #
IsVariant BusName # |
Methods toVariant :: BusName -> Variant # fromVariant :: Variant -> Maybe BusName #
IsVariant ErrorName # |
Methods toVariant :: ErrorName -> Variant # fromVariant :: Variant -> Maybe ErrorName #
IsVariant MemberName # |
Methods toVariant :: MemberName -> Variant # fromVariant :: Variant -> Maybe MemberName #
IsVariant InterfaceName # |
Methods toVariant :: InterfaceName -> Variant # fromVariant :: Variant -> Maybe InterfaceName #
IsVariant ObjectPath # |
Methods toVariant :: ObjectPath -> Variant # fromVariant :: Variant -> Maybe ObjectPath #
IsVariant Variant # |
Methods toVariant :: Variant -> Variant # fromVariant :: Variant -> Maybe Variant #
IsVariant Signature # |
Methods toVariant :: Signature -> Variant # fromVariant :: Variant -> Maybe Signature #
IsValue a => IsVariant [a] # |
Methods toVariant :: [a] -> Variant # fromVariant :: Variant -> Maybe [a] #
IsValue a => IsVariant (Vector a) # |
Methods toVariant :: Vector a -> Variant # fromVariant :: Variant -> Maybe (Vector a) #
(IsVariant a1, IsVariant a2) => IsVariant (a1, a2) # |
Methods toVariant :: (a1, a2) -> Variant # fromVariant :: Variant -> Maybe (a1, a2) #
(Ord k, IsAtom k, IsValue v) => IsVariant (Map k v) # |
Methods toVariant :: Map k v -> Variant # fromVariant :: Variant -> Maybe (Map k v) #
(IsVariant a1, IsVariant a2, IsVariant a3) => IsVariant (a1, a2, a3) # |
Methods toVariant :: (a1, a2, a3) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4) => IsVariant (a1, a2, a3, a4) # |
Methods toVariant :: (a1, a2, a3, a4) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5) => IsVariant (a1, a2, a3, a4, a5) # |
Methods toVariant :: (a1, a2, a3, a4, a5) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6) => IsVariant (a1, a2, a3, a4, a5, a6) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7) => IsVariant (a1, a2, a3, a4, a5, a6, a7) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10, IsVariant a11) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10, IsVariant a11, IsVariant a12) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10, IsVariant a11, IsVariant a12, IsVariant a13) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10, IsVariant a11, IsVariant a12, IsVariant a13, IsVariant a14) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) #
(IsVariant a1, IsVariant a2, IsVariant a3, IsVariant a4, IsVariant a5, IsVariant a6, IsVariant a7, IsVariant a8, IsVariant a9, IsVariant a10, IsVariant a11, IsVariant a12, IsVariant a13, IsVariant a14, IsVariant a15) => IsVariant (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) # |
Methods toVariant :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Variant # fromVariant :: Variant -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) #

class IsVariant a => IsValue a where #

Value types can be used as items in containers, such as lists or dictionaries.

Users may not provide new instances of `IsValue` because this could allow containers to be created with items of heterogenous types.

Minimal complete definition

typeOf, toValue, fromValue

Methods

typeOf :: a -> Type #

toValue :: a -> Value #

fromValue :: Value -> Maybe a #

Instances

IsValue Bool # |
Methods typeOf :: Bool -> Type # toValue :: Bool -> Value # fromValue :: Value -> Maybe Bool #
IsValue Double # |
Methods typeOf :: Double -> Type # toValue :: Double -> Value # fromValue :: Value -> Maybe Double #
IsValue Int16 # |
Methods typeOf :: Int16 -> Type # toValue :: Int16 -> Value # fromValue :: Value -> Maybe Int16 #
IsValue Int32 # |
Methods typeOf :: Int32 -> Type # toValue :: Int32 -> Value # fromValue :: Value -> Maybe Int32 #
IsValue Int64 # |
Methods typeOf :: Int64 -> Type # toValue :: Int64 -> Value # fromValue :: Value -> Maybe Int64 #
IsValue Word8 # |
Methods typeOf :: Word8 -> Type # toValue :: Word8 -> Value # fromValue :: Value -> Maybe Word8 #
IsValue Word16 # |
Methods typeOf :: Word16 -> Type # toValue :: Word16 -> Value # fromValue :: Value -> Maybe Word16 #
IsValue Word32 # |
Methods typeOf :: Word32 -> Type # toValue :: Word32 -> Value # fromValue :: Value -> Maybe Word32 #
IsValue Word64 # |
Methods typeOf :: Word64 -> Type # toValue :: Word64 -> Value # fromValue :: Value -> Maybe Word64 #
IsValue Fd # |
Methods typeOf :: Fd -> Type # toValue :: Fd -> Value # fromValue :: Value -> Maybe Fd #
IsValue String # |
Methods typeOf :: String -> Type # toValue :: String -> Value # fromValue :: Value -> Maybe String #
IsValue ByteString # |
Methods typeOf :: ByteString -> Type # toValue :: ByteString -> Value # fromValue :: Value -> Maybe ByteString #
IsValue ByteString # |
Methods typeOf :: ByteString -> Type # toValue :: ByteString -> Value # fromValue :: Value -> Maybe ByteString #
IsValue Text # |
Methods typeOf :: Text -> Type # toValue :: Text -> Value # fromValue :: Value -> Maybe Text #
IsValue Text # |
Methods typeOf :: Text -> Type # toValue :: Text -> Value # fromValue :: Value -> Maybe Text #
IsValue ObjectPath # |
Methods typeOf :: ObjectPath -> Type # toValue :: ObjectPath -> Value # fromValue :: Value -> Maybe ObjectPath #
IsValue Variant # |
Methods typeOf :: Variant -> Type # toValue :: Variant -> Value # fromValue :: Value -> Maybe Variant #
IsValue Signature # |
Methods typeOf :: Signature -> Type # toValue :: Signature -> Value # fromValue :: Value -> Maybe Signature #
IsValue a => IsValue [a] # |
Methods typeOf :: [a] -> Type # toValue :: [a] -> Value # fromValue :: Value -> Maybe [a] #
IsValue a => IsValue (Vector a) # |
Methods typeOf :: Vector a -> Type # toValue :: Vector a -> Value # fromValue :: Value -> Maybe (Vector a) #
(IsValue a1, IsValue a2) => IsValue (a1, a2) # |
Methods typeOf :: (a1, a2) -> Type # toValue :: (a1, a2) -> Value # fromValue :: Value -> Maybe (a1, a2) #
(Ord k, IsAtom k, IsValue v) => IsValue (Map k v) # |
Methods typeOf :: Map k v -> Type # toValue :: Map k v -> Value # fromValue :: Value -> Maybe (Map k v) #
(IsValue a1, IsValue a2, IsValue a3) => IsValue (a1, a2, a3) # |
Methods typeOf :: (a1, a2, a3) -> Type # toValue :: (a1, a2, a3) -> Value # fromValue :: Value -> Maybe (a1, a2, a3) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4) => IsValue (a1, a2, a3, a4) # |
Methods typeOf :: (a1, a2, a3, a4) -> Type # toValue :: (a1, a2, a3, a4) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5) => IsValue (a1, a2, a3, a4, a5) # |
Methods typeOf :: (a1, a2, a3, a4, a5) -> Type # toValue :: (a1, a2, a3, a4, a5) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6) => IsValue (a1, a2, a3, a4, a5, a6) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6) -> Type # toValue :: (a1, a2, a3, a4, a5, a6) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7) => IsValue (a1, a2, a3, a4, a5, a6, a7) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10, IsValue a11) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10, IsValue a11, IsValue a12) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10, IsValue a11, IsValue a12, IsValue a13) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10, IsValue a11, IsValue a12, IsValue a13, IsValue a14) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) #
(IsValue a1, IsValue a2, IsValue a3, IsValue a4, IsValue a5, IsValue a6, IsValue a7, IsValue a8, IsValue a9, IsValue a10, IsValue a11, IsValue a12, IsValue a13, IsValue a14, IsValue a15) => IsValue (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) # |
Methods typeOf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Type # toValue :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Value # fromValue :: Value -> Maybe (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) #

class IsValue a => IsAtom a where #

Atomic types can be used as keys to dictionaries.

Users may not provide new instances of `IsAtom` because this could allow dictionaries to be created with invalid keys.

Minimal complete definition

toAtom, fromAtom

Methods

toAtom :: a -> Atom #

fromAtom :: Atom -> Maybe a #

Instances

IsAtom Bool # |
Methods toAtom :: Bool -> Atom # fromAtom :: Atom -> Maybe Bool #
IsAtom Double # |
Methods toAtom :: Double -> Atom # fromAtom :: Atom -> Maybe Double #
IsAtom Int16 # |
Methods toAtom :: Int16 -> Atom # fromAtom :: Atom -> Maybe Int16 #
IsAtom Int32 # |
Methods toAtom :: Int32 -> Atom # fromAtom :: Atom -> Maybe Int32 #
IsAtom Int64 # |
Methods toAtom :: Int64 -> Atom # fromAtom :: Atom -> Maybe Int64 #
IsAtom Word8 # |
Methods toAtom :: Word8 -> Atom # fromAtom :: Atom -> Maybe Word8 #
IsAtom Word16 # |
Methods toAtom :: Word16 -> Atom # fromAtom :: Atom -> Maybe Word16 #
IsAtom Word32 # |
Methods toAtom :: Word32 -> Atom # fromAtom :: Atom -> Maybe Word32 #
IsAtom Word64 # |
Methods toAtom :: Word64 -> Atom # fromAtom :: Atom -> Maybe Word64 #
IsAtom Fd # |
Methods toAtom :: Fd -> Atom # fromAtom :: Atom -> Maybe Fd #
IsAtom String # |
Methods toAtom :: String -> Atom # fromAtom :: Atom -> Maybe String #
IsAtom Text # |
Methods toAtom :: Text -> Atom # fromAtom :: Atom -> Maybe Text #
IsAtom Text # |
Methods toAtom :: Text -> Atom # fromAtom :: Atom -> Maybe Text #
IsAtom ObjectPath # |
Methods toAtom :: ObjectPath -> Atom # fromAtom :: Atom -> Maybe ObjectPath #
IsAtom Signature # |
Methods toAtom :: Signature -> Atom # fromAtom :: Atom -> Maybe Signature #

newtype Variant #

Variants may contain any other built-in D-Bus value. Besides representing native `VARIANT` values, they allow type-safe storage and inspection of D-Bus collections.

Constructors

Variant Value |

Instances

Eq Variant # |
Methods (==) :: Variant -> Variant -> Bool # (/=) :: Variant -> Variant -> Bool #
Show Variant # |
Methods showsPrec :: Int -> Variant -> ShowS # show :: Variant -> String # showList :: [Variant] -> ShowS #
IsValue Variant # |
Methods typeOf :: Variant -> Type # toValue :: Variant -> Value # fromValue :: Value -> Maybe Variant #
IsVariant Variant # |
Methods toVariant :: Variant -> Variant # fromVariant :: Variant -> Maybe Variant #

data Value #

Constructors

ValueAtom Atom |
ValueVariant Variant |
ValueBytes ByteString |
ValueVector Type (Vector Value) |
ValueMap Type Type (Map Atom Value) |
ValueStructure [Value] |

Instances

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

data Atom #

Constructors

AtomBool Bool |
AtomWord8 Word8 |
AtomWord16 Word16 |
AtomWord32 Word32 |
AtomWord64 Word64 |
AtomInt16 Int16 |
AtomInt32 Int32 |
AtomInt64 Int64 |
AtomDouble Double |
AtomUnixFd Fd |
AtomText Text |
AtomSignature Signature |
AtomObjectPath ObjectPath |

Instances

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

showAtom :: Bool -> Atom -> String #

showValue :: Bool -> Value -> String #

showThings :: String -> (a -> String) -> String -> [a] -> String #

vectorToBytes :: Vector Value -> ByteString #

variantType :: Variant -> Type #

Every variant is strongly-typed; that is, the type of its contained value is known at all times. This function retrieves that type, so that the correct cast can be used to retrieve the value.

valueType :: Value -> Type #

atomType :: Atom -> Type #

vectorItemType :: IsValue a => Vector a -> Type #

bimap :: Ord k' => (k -> v -> (k', v')) -> Map k v -> Map k' v' #

bimapM :: (Monad m, Ord k') => (k -> v -> m (k', v')) -> Map k v -> m (Map k' v') #

mapItemType :: (IsValue k, IsValue v) => Map k v -> (Type, Type) #

varToVal :: IsVariant a => a -> Value #

newtype ObjectPath #

Object paths are special strings, used to identify a particular object exported from a D-Bus application.

Object paths must begin with a slash, and consist of alphanumeric characters separated by slashes.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-marshaling-object-path for details.

Constructors

ObjectPath String |

Instances

Eq ObjectPath # |
Methods (==) :: ObjectPath -> ObjectPath -> Bool # (/=) :: ObjectPath -> ObjectPath -> Bool #
Ord ObjectPath # |
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 # |
Methods showsPrec :: Int -> ObjectPath -> ShowS # show :: ObjectPath -> String # showList :: [ObjectPath] -> ShowS #
IsString ObjectPath # |
Methods fromString :: String -> ObjectPath #
IsAtom ObjectPath # |
Methods toAtom :: ObjectPath -> Atom # fromAtom :: Atom -> Maybe ObjectPath #
IsValue ObjectPath # |
Methods typeOf :: ObjectPath -> Type # toValue :: ObjectPath -> Value # fromValue :: Value -> Maybe ObjectPath #
IsVariant ObjectPath # |
Methods toVariant :: ObjectPath -> Variant # fromVariant :: Variant -> Maybe ObjectPath #

formatObjectPath :: ObjectPath -> String #

parseObjectPath :: String -> Maybe ObjectPath #

objectPath_ :: String -> ObjectPath #

parserObjectPath :: Parser () #

newtype InterfaceName #

Interfaces are used to group a set of methods and signals within an exported object. Interface names consist of alphanumeric characters separated by periods.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface for details.

Constructors

InterfaceName String |

Instances

Eq InterfaceName # |
Methods (==) :: InterfaceName -> InterfaceName -> Bool # (/=) :: InterfaceName -> InterfaceName -> Bool #
Ord InterfaceName # |
Methods compare :: InterfaceName -> InterfaceName -> Ordering # (<) :: InterfaceName -> InterfaceName -> Bool # (<=) :: InterfaceName -> InterfaceName -> Bool # (>) :: InterfaceName -> InterfaceName -> Bool # (>=) :: InterfaceName -> InterfaceName -> Bool # max :: InterfaceName -> InterfaceName -> InterfaceName # min :: InterfaceName -> InterfaceName -> InterfaceName #
Show InterfaceName # |
Methods showsPrec :: Int -> InterfaceName -> ShowS # show :: InterfaceName -> String # showList :: [InterfaceName] -> ShowS #
IsString InterfaceName # |
Methods fromString :: String -> InterfaceName #
IsVariant InterfaceName # |
Methods toVariant :: InterfaceName -> Variant # fromVariant :: Variant -> Maybe InterfaceName #

formatInterfaceName :: InterfaceName -> String #

parseInterfaceName :: String -> Maybe InterfaceName #

interfaceName_ :: String -> InterfaceName #

parserInterfaceName :: Parser () #

newtype MemberName #

Member names are used to identify a single method or signal within an interface. Method names consist of alphanumeric characters.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-member for details.

Constructors

MemberName String |

Instances

Eq MemberName # |
Methods (==) :: MemberName -> MemberName -> Bool # (/=) :: MemberName -> MemberName -> Bool #
Ord MemberName # |
Methods compare :: MemberName -> MemberName -> Ordering # (<) :: MemberName -> MemberName -> Bool # (<=) :: MemberName -> MemberName -> Bool # (>) :: MemberName -> MemberName -> Bool # (>=) :: MemberName -> MemberName -> Bool # max :: MemberName -> MemberName -> MemberName # min :: MemberName -> MemberName -> MemberName #
Show MemberName # |
Methods showsPrec :: Int -> MemberName -> ShowS # show :: MemberName -> String # showList :: [MemberName] -> ShowS #
IsString MemberName # |
Methods fromString :: String -> MemberName #
IsVariant MemberName # |
Methods toVariant :: MemberName -> Variant # fromVariant :: Variant -> Maybe MemberName #

formatMemberName :: MemberName -> String #

parseMemberName :: String -> Maybe MemberName #

memberName_ :: String -> MemberName #

parserMemberName :: Parser () #

newtype ErrorName #

Error names are used to identify which type of error was returned from a method call. Error names consist of alphanumeric characters separated by periods.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-error for details.

Constructors

ErrorName String |

Instances

Eq ErrorName # |
Methods (==) :: ErrorName -> ErrorName -> Bool # (/=) :: ErrorName -> ErrorName -> Bool #
Ord ErrorName # |
Methods compare :: ErrorName -> ErrorName -> Ordering # (<) :: ErrorName -> ErrorName -> Bool # (<=) :: ErrorName -> ErrorName -> Bool # (>) :: ErrorName -> ErrorName -> Bool # (>=) :: ErrorName -> ErrorName -> Bool # max :: ErrorName -> ErrorName -> ErrorName # min :: ErrorName -> ErrorName -> ErrorName #
Show ErrorName # |
Methods showsPrec :: Int -> ErrorName -> ShowS # show :: ErrorName -> String # showList :: [ErrorName] -> ShowS #
IsString ErrorName # |
Methods fromString :: String -> ErrorName #
IsVariant ErrorName # |
Methods toVariant :: ErrorName -> Variant # fromVariant :: Variant -> Maybe ErrorName #

formatErrorName :: ErrorName -> String #

parseErrorName :: String -> Maybe ErrorName #

errorName_ :: String -> ErrorName #

newtype BusName #

Bus names are used to identify particular clients on the message bus. A bus name may be either unique or well-known, where unique names start with a colon. Bus names consist of alphanumeric characters separated by periods.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus for details.

Constructors

BusName String |

Instances

Eq BusName # |
Methods (==) :: BusName -> BusName -> Bool # (/=) :: BusName -> BusName -> Bool #
Ord BusName # |
Methods compare :: BusName -> BusName -> Ordering # (<) :: BusName -> BusName -> Bool # (<=) :: BusName -> BusName -> Bool # (>) :: BusName -> BusName -> Bool # (>=) :: BusName -> BusName -> Bool # max :: BusName -> BusName -> BusName # min :: BusName -> BusName -> BusName #
Show BusName # |
Methods showsPrec :: Int -> BusName -> ShowS # show :: BusName -> String # showList :: [BusName] -> ShowS #
IsString BusName # |
Methods fromString :: String -> BusName #
IsVariant BusName # |
Methods toVariant :: BusName -> Variant # fromVariant :: Variant -> Maybe BusName #

formatBusName :: BusName -> String #

parseBusName :: String -> Maybe BusName #

busName_ :: String -> BusName #

parserBusName :: Parser () #

newtype Structure #

A D-Bus Structure is a container type similar to Haskell tuples, storing values of any type that is convertable to `IsVariant`. A Structure may contain up to 255 values.

Most users can use the `IsVariant` instance for tuples to extract the values of a structure. This type is for very large structures, which may be awkward to work with as tuples.

Constructors

Structure [Value] |

Instances

Eq Structure # |
Methods (==) :: Structure -> Structure -> Bool # (/=) :: Structure -> Structure -> Bool #
Show Structure # |
Methods showsPrec :: Int -> Structure -> ShowS # show :: Structure -> String # showList :: [Structure] -> ShowS #
IsVariant Structure # |
Methods toVariant :: Structure -> Variant # fromVariant :: Variant -> Maybe Structure #

structureItems :: Structure -> [Variant] #

data Array #

A D-Bus Array is a container type similar to Haskell lists, storing zero or more values of a single D-Bus type.

Most users can use the `IsVariant` instance for lists or vectors to extract the values of an array. This type is for advanced use cases, where the user wants to convert array values to Haskell types that are not instances of `IsValue`.

Constructors

Array Type (Vector Value) |
ArrayBytes ByteString |

Instances

Eq Array # |
Methods (==) :: Array -> Array -> Bool # (/=) :: Array -> Array -> Bool #
Show Array # |
Methods showsPrec :: Int -> Array -> ShowS # show :: Array -> String # showList :: [Array] -> ShowS #
IsVariant Array # |
Methods toVariant :: Array -> Variant # fromVariant :: Variant -> Maybe Array #

arrayItems :: Array -> [Variant] #

data Dictionary #

A D-Bus Dictionary is a container type similar to Haskell maps, storing zero or more associations between keys and values.

Most users can use the `IsVariant` instance for maps to extract the values of a dictionary. This type is for advanced use cases, where the user wants to convert dictionary items to Haskell types that are not instances of `IsValue`.

Constructors

Dictionary Type Type (Map Atom Value) |

Instances

Eq Dictionary # |
Methods (==) :: Dictionary -> Dictionary -> Bool # (/=) :: Dictionary -> Dictionary -> Bool #
Show Dictionary # |
Methods showsPrec :: Int -> Dictionary -> ShowS # show :: Dictionary -> String # showList :: [Dictionary] -> ShowS #
IsVariant Dictionary # |
Methods toVariant :: Dictionary -> Variant # fromVariant :: Variant -> Maybe Dictionary #

dictionaryItems :: Dictionary -> [(Variant, Variant)] #

newtype Serial #

A value used to uniquely identify a particular message within a session. Serials are 32-bit unsigned integers, and eventually wrap.

Constructors

Serial Word32 |

Instances

Eq Serial # |
Methods (==) :: Serial -> Serial -> Bool # (/=) :: Serial -> Serial -> Bool #
Ord Serial # |
Methods compare :: Serial -> Serial -> Ordering # (<) :: Serial -> Serial -> Bool # (<=) :: Serial -> Serial -> Bool # (>) :: Serial -> Serial -> Bool # (>=) :: Serial -> Serial -> Bool # max :: Serial -> Serial -> Serial # min :: Serial -> Serial -> Serial #
Show Serial # |
Methods showsPrec :: Int -> Serial -> ShowS # show :: Serial -> String # showList :: [Serial] -> ShowS #
IsVariant Serial # |
Methods toVariant :: Serial -> Variant # fromVariant :: Variant -> Maybe Serial #

serialValue :: Serial -> Word32 #

firstSerial :: Serial #

Get the first serial in the sequence.

nextSerial :: Serial -> Serial #

Get the next serial in the sequence. This may wrap around to `firstSerial`.

skipSepBy1 :: Parser a -> Parser b -> Parser () #

forceParse :: String -> (String -> Maybe a) -> String -> a #

maybeParseString :: Parser a -> String -> Maybe a #