:# Copyright (C) 2009-2011 John Millikin <jmillikin@gmail.com>
:# 
:# This program is free software: you can redistribute it and/or modify
:# it under the terms of the GNU General Public License as published by
:# the Free Software Foundation, either version 3 of the License, or
:# any later version.
:# 
:# This program is distributed in the hope that it will be useful,
:# but WITHOUT ANY WARRANTY; without even the implied warranty of
:# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
:# GNU General Public License for more details.
:# 
:# You should have received a copy of the GNU General Public License
:# along with this program.  If not, see <http://www.gnu.org/licenses/>.

\section{Module headers}

:f DBus/Types.hs
|copyright|
module DBus.Types
	( Type(..)
	
	, Signature
	, signature
	, signature_
	, signatureText
	, signatureTypes
	
	, IsValue
	, IsAtom
	, typeOf
	
	, Variant
	, IsVariant(..)
	, variantType
	
	, ObjectPath
	, objectPath
	, objectPath_
	, objectPathText
	
	, InterfaceName
	, interfaceName
	, interfaceName_
	, interfaceNameText
	
	, MemberName
	, memberName
	, memberName_
	, memberNameText
	
	, ErrorName
	, errorName
	, errorName_
	, errorNameText
	
	, BusName
	, busName
	, busName_
	, busNameText
	
	, Structure
	, Array
	, Dictionary
	, structureItems
	, arrayItems
	, dictionaryItems
	) where
import           DBus.Types.Internal hiding (typeOf)
import qualified DBus.Types.Internal

typeOf :: IsValue a => a -> Type
typeOf = DBus.Types.Internal.typeOf
:

:f DBus/Types/Internal.hs
{-# LANGUAGE CPP #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE IncoherentInstances #-}
|copyright|
module DBus.Types.Internal where
import           Control.Monad (liftM, when, (>=>))
import           Data.ByteString (ByteString)
import qualified Data.ByteString
import qualified Data.ByteString.Char8
import qualified Data.ByteString.Lazy
import qualified Data.ByteString.Unsafe
import           Data.Int
import           Data.List (intercalate)
import qualified Data.Map
import           Data.Map (Map)
import qualified Data.String
import qualified Data.Text
import           Data.Text (Text)
import qualified Data.Text.Encoding
import qualified Data.Text.Lazy
import qualified Data.Vector
import           Data.Vector (Vector)
import           Data.Word
import qualified Foreign
import           System.IO.Unsafe (unsafePerformIO)

|text validation imports|

import           DBus.Util (void)

|DBus.Types|
|text validation|
:

:f DBus/Message.hs
|copyright|
module DBus.Message
	( Message ( messageFlags
	          , messageBody
	          )
	, Flag (..)
	, Serial
	, serialValue
	, Unknown (..)
	, MethodCall (..)
	, MethodReturn (..)
	, Error (..)
	, errorMessage
	, Signal (..)
	, ReceivedMessage (..)
	, receivedSerial
	, receivedSender
	, receivedBody
	) where
import DBus.Message.Internal
:

:f DBus/Message/Internal.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Message.Internal where
import           Data.Maybe (fromMaybe)
import qualified Data.Set
import           Data.Set (Set)
import qualified Data.Text
import           Data.Text (Text)
import           Data.Word (Word8, Word32)

import           DBus.Types hiding (errorName)
import           DBus.Util (maybeIndex)

|DBus.Message|
:

:f DBus/Wire.hs
|copyright|
module DBus.Wire
	( Endianness (..)
	, MarshalError
	, UnmarshalError
	, marshalMessage
	, unmarshalMessage
	) where
import DBus.Wire.Internal
:

:f DBus/Wire/Internal.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Wire.Internal where
import Control.Monad (liftM, when, unless)

import qualified Data.Binary.Builder
import qualified Data.Binary.Get
import           Data.Binary.Put (runPut)
import           Data.Bits ((.&.), (.|.))
import qualified Data.ByteString
import           Data.ByteString (ByteString)
import qualified Data.ByteString.Char8
import qualified Data.ByteString.Lazy
import           Data.Int (Int16, Int32, Int64)
import qualified Data.Map
import           Data.Map (Map)
import           Data.Maybe (fromJust, listToMaybe, fromMaybe)
import qualified Data.Set
import           Data.Set (Set)
import qualified Data.Text
import           Data.Text (Text)
import qualified Data.Text.Encoding
import qualified Data.Vector
import           Data.Vector (Vector)
import           Data.Word (Word8, Word16, Word32, Word64)

import qualified Data.Binary.IEEE754

import           DBus.Message.Internal
import           DBus.Types.Internal
import           DBus.Util (void, untilM)
import qualified DBus.Util.MonadError as E

|DBus.Wire|
:

:f DBus/Address.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Address
	( Address
	, addressMethod
	, addressParameters
	, address
	, addresses
	, addressText
	
	-- * Environmental addresses
	, getSystem
	, getSession
	, getStarter
	) where
import qualified Control.Exception
import           Data.Char (ord, chr)
import qualified Data.Map
import           Data.Map (Map)
import qualified Data.Text
import           Data.Text (Text)
import qualified System.Environment
import           Text.Printf (printf)
import           Text.ParserCombinators.Parsec hiding (runParser)

import           DBus.Util (hexToInt, void)
import           DBus.Types.Internal (runParser)
|DBus.Address|
:

:f DBus/Connection.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Connection
	( Connection
	, ConnectionError
	, connect
	, disconnect
	, send
	, receive
	
	-- * Authentication
	, Mechanism
	, mechanism
	, external
	
	-- * Transports
	, Transport
	, Socket
	, transport
	, socket
	, socketPut
	, socketGet
	
	, unix
	, tcp
	) where
import           Control.Concurrent
import           Control.Monad (when)
import           Data.IORef

import           DBus.Address
import           DBus.Connection.Authentication
import           DBus.Connection.Error
import           DBus.Connection.Transport
import           DBus.Message.Internal
import           DBus.Wire
import           DBus.Wire.Internal (unmarshalMessageM)

|DBus.Connection|
:

:f DBus/Connection/Authentication.hs
|copyright|
module DBus.Connection.Authentication
	( Mechanism
	, mechanism
	, authenticate
	, external
	) where

import           Prelude hiding (getLine, head)
import           Control.Monad (liftM)
import qualified Data.ByteString
import qualified Data.ByteString.Char8
import           Data.Char (ord)
import qualified System.Posix.User
import           Text.Printf (printf)

import           DBus.Connection.Transport
import           DBus.Util (readUntil, dropEnd)

|DBus.Connection.Authentication|
:

:f DBus/Connection/Error.hs
{-# LANGUAGE DeriveDataTypeable #-}
|copyright|
module DBus.Connection.Error where
import           Control.Exception (Exception, throwIO)
import           Data.Typeable (Typeable)
|DBus.Connection.Error|
:

:f DBus/Connection/Transport.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Connection.Transport
	( Transport
	, transport
	, Socket
	, socket
	, socketPut
	, socketGet
	, socketClose
	, tcp
	, unix
	, connectTransport
	) where

import qualified Control.Exception
import           Control.Monad (unless)
import qualified Data.Binary.Get
import qualified Data.Binary.Put
import qualified Data.ByteString
import           Data.ByteString (ByteString)
import qualified Data.Map
import qualified Data.Text
import           Data.Text (Text)
import           Data.Word (Word32)
import qualified Network
import qualified Network.Socket
import qualified System.IO
import           Text.ParserCombinators.Parsec

import           DBus.Address
import           DBus.Connection.Error

|DBus.Connection.Transport|
:

:f DBus/Client.hs
|copyright|
module DBus.Client
	(
	-- * Clients
	  Client
	, connect
	, attach
	, disconnect
	, call
	, call_
	, emit
	
	-- * Listening for signals
	, MatchRule(..)
	, listen
	
	-- * Exporting objects
	, Method
	, Reply(..)
	, throwError
	, method
	, export
	
	-- * Other
	, setMessageProcessor
	) where
import           DBus.Client.Internal
:

:f DBus/Client/Internal.hs
{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveDataTypeable #-}
|copyright|
module DBus.Client.Internal where
import           Control.Concurrent
import           Control.Exception (SomeException)
import qualified Control.Exception
import           Control.Monad (forever, unless)
import           Data.IORef
import           Data.List (foldl')
import qualified Data.Map
import           Data.Map (Map)
import           Data.Maybe (isJust, catMaybes)
import           Data.Text (Text)
import qualified Data.Text
import           Data.Typeable (Typeable)
import qualified Data.Set

import           DBus.Address
import qualified DBus.Connection
import           DBus.Connection (Connection)
import           DBus.Connection.Authentication (external)
import           DBus.Connection.Transport (unix, tcp)
import           DBus.Connection.Error
import qualified DBus.Constants
import           DBus.Constants ( errorFailed, errorUnknownMethod
                                , errorInvalidParameters)
import           DBus.Message
import qualified DBus.Introspection
import           DBus.Types
import           DBus.Types.Internal (Signature(..))
import           DBus.Util (void)

|DBus.Client|
:

:f DBus/Client/Simple.hs
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverlappingInstances #-}
|copyright|
module DBus.Client.Simple
	(
	-- * Clients
	  Client
	, connectSystem
	, connectSession
	, connectStarter
	, disconnect
	, emit
	
	-- * Proxies
	, Proxy
	, proxy
	, call
	, DBus.Client.Simple.listen
	
	-- * Name reservation
	, RequestNameFlag(..)
	, RequestNameReply(..)
	, ReleaseNameReply(..)
	, requestName
	, releaseName
	
	-- * Exporting objects
	, Method
	, AutoSignature
	, AutoReply
	, method
	, export
	, throwError
	
	-- * Re-exported modules
	, module DBus.Types
	) where

import qualified Control.Exception
import           Data.Bits ((.|.))
import qualified Data.Text -- for haddock
import qualified Data.Set
import           Data.Word (Word32)

import           DBus.Address
import           DBus.Client hiding (call, method, emit, export)
import qualified DBus.Client
import           DBus.Connection.Error
import           DBus.Constants (errorInvalidParameters)
import           DBus.Message hiding (errorName)
import           DBus.Types
import           DBus.Types.Internal (checkSignature)
import           DBus.Util (maybeIndex)

|DBus.Client.Simple|
:

:f DBus/Introspection.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Introspection
	( Object (..)
	, Interface (..)
	, Method (..)
	, Signal (..)
	, Parameter (..)
	, Property (..)
	, PropertyAccess (..)
	, toXML
	, fromXML
	) where
import           Control.Monad ((>=>))
import           Control.Monad.ST (runST)
import           Data.Maybe (fromMaybe)
import qualified Data.STRef as ST
import qualified Data.Text
import           Data.Text (Text)
import qualified Data.Text.Encoding
import qualified Data.XML.Types as X
import qualified Text.XML.LibXML.SAX as SAX

import qualified DBus.Types as T

|DBus.Introspection|
:

:f DBus/Constants.hs
{-# LANGUAGE OverloadedStrings #-}
|copyright|
module DBus.Constants where
import           DBus.Types

|DBus.Constants|
: