{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Soup.Objects.Address ( -- * Exported types Address(..) , IsAddress , toAddress , noAddress , -- * Methods -- ** equalByIp #method:equalByIp# #if ENABLE_OVERLOADING AddressEqualByIpMethodInfo , #endif addressEqualByIp , -- ** equalByName #method:equalByName# #if ENABLE_OVERLOADING AddressEqualByNameMethodInfo , #endif addressEqualByName , -- ** getGsockaddr #method:getGsockaddr# #if ENABLE_OVERLOADING AddressGetGsockaddrMethodInfo , #endif addressGetGsockaddr , -- ** getName #method:getName# #if ENABLE_OVERLOADING AddressGetNameMethodInfo , #endif addressGetName , -- ** getPhysical #method:getPhysical# #if ENABLE_OVERLOADING AddressGetPhysicalMethodInfo , #endif addressGetPhysical , -- ** getPort #method:getPort# #if ENABLE_OVERLOADING AddressGetPortMethodInfo , #endif addressGetPort , -- ** hashByIp #method:hashByIp# #if ENABLE_OVERLOADING AddressHashByIpMethodInfo , #endif addressHashByIp , -- ** hashByName #method:hashByName# #if ENABLE_OVERLOADING AddressHashByNameMethodInfo , #endif addressHashByName , -- ** isResolved #method:isResolved# #if ENABLE_OVERLOADING AddressIsResolvedMethodInfo , #endif addressIsResolved , -- ** new #method:new# addressNew , -- ** newAny #method:newAny# addressNewAny , -- ** newFromSockaddr #method:newFromSockaddr# addressNewFromSockaddr , -- ** resolveAsync #method:resolveAsync# #if ENABLE_OVERLOADING AddressResolveAsyncMethodInfo , #endif addressResolveAsync , -- ** resolveSync #method:resolveSync# #if ENABLE_OVERLOADING AddressResolveSyncMethodInfo , #endif addressResolveSync , -- * Properties -- ** family #attr:family# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressFamilyPropertyInfo , #endif #if ENABLE_OVERLOADING addressFamily , #endif constructAddressFamily , getAddressFamily , -- ** name #attr:name# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressNamePropertyInfo , #endif #if ENABLE_OVERLOADING addressName , #endif constructAddressName , getAddressName , -- ** physical #attr:physical# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressPhysicalPropertyInfo , #endif #if ENABLE_OVERLOADING addressPhysical , #endif getAddressPhysical , -- ** port #attr:port# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressPortPropertyInfo , #endif #if ENABLE_OVERLOADING addressPort , #endif constructAddressPort , getAddressPort , -- ** protocol #attr:protocol# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressProtocolPropertyInfo , #endif #if ENABLE_OVERLOADING addressProtocol , #endif constructAddressProtocol , getAddressProtocol , -- ** sockaddr #attr:sockaddr# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AddressSockaddrPropertyInfo , #endif #if ENABLE_OVERLOADING addressSockaddr , #endif constructAddressSockaddr , getAddressSockaddr , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GLib.Structs.MainContext as GLib.MainContext import qualified GI.GObject.Objects.Object as GObject.Object import qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable import qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress import qualified GI.Soup.Callbacks as Soup.Callbacks import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums -- | Memory-managed wrapper type. newtype Address = Address (ManagedPtr Address) foreign import ccall "soup_address_get_type" c_soup_address_get_type :: IO GType instance GObject Address where gobjectType = c_soup_address_get_type -- | Type class for types which can be safely cast to `Address`, for instance with `toAddress`. class (GObject o, O.IsDescendantOf Address o) => IsAddress o instance (GObject o, O.IsDescendantOf Address o) => IsAddress o instance O.HasParentTypes Address type instance O.ParentTypes Address = '[GObject.Object.Object, Gio.SocketConnectable.SocketConnectable] -- | Cast to `Address`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toAddress :: (MonadIO m, IsAddress o) => o -> m Address toAddress = liftIO . unsafeCastTo Address -- | A convenience alias for `Nothing` :: `Maybe` `Address`. noAddress :: Maybe Address noAddress = Nothing #if ENABLE_OVERLOADING type family ResolveAddressMethod (t :: Symbol) (o :: *) :: * where ResolveAddressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveAddressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveAddressMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo ResolveAddressMethod "equalByIp" o = AddressEqualByIpMethodInfo ResolveAddressMethod "equalByName" o = AddressEqualByNameMethodInfo ResolveAddressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveAddressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveAddressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveAddressMethod "hashByIp" o = AddressHashByIpMethodInfo ResolveAddressMethod "hashByName" o = AddressHashByNameMethodInfo ResolveAddressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveAddressMethod "isResolved" o = AddressIsResolvedMethodInfo ResolveAddressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveAddressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveAddressMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo ResolveAddressMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveAddressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveAddressMethod "resolveAsync" o = AddressResolveAsyncMethodInfo ResolveAddressMethod "resolveSync" o = AddressResolveSyncMethodInfo ResolveAddressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveAddressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveAddressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveAddressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveAddressMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo ResolveAddressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveAddressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveAddressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveAddressMethod "getGsockaddr" o = AddressGetGsockaddrMethodInfo ResolveAddressMethod "getName" o = AddressGetNameMethodInfo ResolveAddressMethod "getPhysical" o = AddressGetPhysicalMethodInfo ResolveAddressMethod "getPort" o = AddressGetPortMethodInfo ResolveAddressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveAddressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveAddressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveAddressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveAddressMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveAddressMethod t Address, O.MethodInfo info Address p) => OL.IsLabel t (Address -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- VVV Prop "family" -- Type: TInterface (Name {namespace = "Soup", name = "AddressFamily"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@family@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #family @ -} getAddressFamily :: (MonadIO m, IsAddress o) => o -> m Soup.Enums.AddressFamily getAddressFamily obj = liftIO $ B.Properties.getObjectPropertyEnum obj "family" {- | Construct a `GValueConstruct` with valid value for the “@family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAddressFamily :: (IsAddress o) => Soup.Enums.AddressFamily -> IO (GValueConstruct o) constructAddressFamily val = B.Properties.constructObjectPropertyEnum "family" val #if ENABLE_OVERLOADING data AddressFamilyPropertyInfo instance AttrInfo AddressFamilyPropertyInfo where type AttrAllowedOps AddressFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AddressFamilyPropertyInfo = (~) Soup.Enums.AddressFamily type AttrBaseTypeConstraint AddressFamilyPropertyInfo = IsAddress type AttrGetType AddressFamilyPropertyInfo = Soup.Enums.AddressFamily type AttrLabel AddressFamilyPropertyInfo = "family" type AttrOrigin AddressFamilyPropertyInfo = Address attrGet _ = getAddressFamily attrSet _ = undefined attrConstruct _ = constructAddressFamily attrClear _ = undefined #endif -- VVV Prop "name" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just True,Nothing) {- | Get the value of the “@name@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #name @ -} getAddressName :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text) getAddressName obj = liftIO $ B.Properties.getObjectPropertyString obj "name" {- | Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAddressName :: (IsAddress o) => T.Text -> IO (GValueConstruct o) constructAddressName val = B.Properties.constructObjectPropertyString "name" (Just val) #if ENABLE_OVERLOADING data AddressNamePropertyInfo instance AttrInfo AddressNamePropertyInfo where type AttrAllowedOps AddressNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AddressNamePropertyInfo = (~) T.Text type AttrBaseTypeConstraint AddressNamePropertyInfo = IsAddress type AttrGetType AddressNamePropertyInfo = (Maybe T.Text) type AttrLabel AddressNamePropertyInfo = "name" type AttrOrigin AddressNamePropertyInfo = Address attrGet _ = getAddressName attrSet _ = undefined attrConstruct _ = constructAddressName attrClear _ = undefined #endif -- VVV Prop "physical" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable] -- Nullable: (Just True,Nothing) {- | Get the value of the “@physical@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #physical @ -} getAddressPhysical :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text) getAddressPhysical obj = liftIO $ B.Properties.getObjectPropertyString obj "physical" #if ENABLE_OVERLOADING data AddressPhysicalPropertyInfo instance AttrInfo AddressPhysicalPropertyInfo where type AttrAllowedOps AddressPhysicalPropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AddressPhysicalPropertyInfo = (~) () type AttrBaseTypeConstraint AddressPhysicalPropertyInfo = IsAddress type AttrGetType AddressPhysicalPropertyInfo = (Maybe T.Text) type AttrLabel AddressPhysicalPropertyInfo = "physical" type AttrOrigin AddressPhysicalPropertyInfo = Address attrGet _ = getAddressPhysical attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "port" -- Type: TBasicType TInt -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@port@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #port @ -} getAddressPort :: (MonadIO m, IsAddress o) => o -> m Int32 getAddressPort obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "port" {- | Construct a `GValueConstruct` with valid value for the “@port@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAddressPort :: (IsAddress o) => Int32 -> IO (GValueConstruct o) constructAddressPort val = B.Properties.constructObjectPropertyInt32 "port" val #if ENABLE_OVERLOADING data AddressPortPropertyInfo instance AttrInfo AddressPortPropertyInfo where type AttrAllowedOps AddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AddressPortPropertyInfo = (~) Int32 type AttrBaseTypeConstraint AddressPortPropertyInfo = IsAddress type AttrGetType AddressPortPropertyInfo = Int32 type AttrLabel AddressPortPropertyInfo = "port" type AttrOrigin AddressPortPropertyInfo = Address attrGet _ = getAddressPort attrSet _ = undefined attrConstruct _ = constructAddressPort attrClear _ = undefined #endif -- VVV Prop "protocol" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@protocol@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #protocol @ -} getAddressProtocol :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text) getAddressProtocol obj = liftIO $ B.Properties.getObjectPropertyString obj "protocol" {- | Construct a `GValueConstruct` with valid value for the “@protocol@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAddressProtocol :: (IsAddress o) => T.Text -> IO (GValueConstruct o) constructAddressProtocol val = B.Properties.constructObjectPropertyString "protocol" (Just val) #if ENABLE_OVERLOADING data AddressProtocolPropertyInfo instance AttrInfo AddressProtocolPropertyInfo where type AttrAllowedOps AddressProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AddressProtocolPropertyInfo = (~) T.Text type AttrBaseTypeConstraint AddressProtocolPropertyInfo = IsAddress type AttrGetType AddressProtocolPropertyInfo = (Maybe T.Text) type AttrLabel AddressProtocolPropertyInfo = "protocol" type AttrOrigin AddressProtocolPropertyInfo = Address attrGet _ = getAddressProtocol attrSet _ = undefined attrConstruct _ = constructAddressProtocol attrClear _ = undefined #endif -- VVV Prop "sockaddr" -- Type: TBasicType TPtr -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@sockaddr@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' address #sockaddr @ -} getAddressSockaddr :: (MonadIO m, IsAddress o) => o -> m (Ptr ()) getAddressSockaddr obj = liftIO $ B.Properties.getObjectPropertyPtr obj "sockaddr" {- | Construct a `GValueConstruct` with valid value for the “@sockaddr@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAddressSockaddr :: (IsAddress o) => Ptr () -> IO (GValueConstruct o) constructAddressSockaddr val = B.Properties.constructObjectPropertyPtr "sockaddr" val #if ENABLE_OVERLOADING data AddressSockaddrPropertyInfo instance AttrInfo AddressSockaddrPropertyInfo where type AttrAllowedOps AddressSockaddrPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AddressSockaddrPropertyInfo = (~) (Ptr ()) type AttrBaseTypeConstraint AddressSockaddrPropertyInfo = IsAddress type AttrGetType AddressSockaddrPropertyInfo = (Ptr ()) type AttrLabel AddressSockaddrPropertyInfo = "sockaddr" type AttrOrigin AddressSockaddrPropertyInfo = Address attrGet _ = getAddressSockaddr attrSet _ = undefined attrConstruct _ = constructAddressSockaddr attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Address type instance O.AttributeList Address = AddressAttributeList type AddressAttributeList = ('[ '("family", AddressFamilyPropertyInfo), '("name", AddressNamePropertyInfo), '("physical", AddressPhysicalPropertyInfo), '("port", AddressPortPropertyInfo), '("protocol", AddressProtocolPropertyInfo), '("sockaddr", AddressSockaddrPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING addressFamily :: AttrLabelProxy "family" addressFamily = AttrLabelProxy addressName :: AttrLabelProxy "name" addressName = AttrLabelProxy addressPhysical :: AttrLabelProxy "physical" addressPhysical = AttrLabelProxy addressPort :: AttrLabelProxy "port" addressPort = AttrLabelProxy addressProtocol :: AttrLabelProxy "protocol" addressProtocol = AttrLabelProxy addressSockaddr :: AttrLabelProxy "sockaddr" addressSockaddr = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList Address = AddressSignalList type AddressSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method Address::new -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a hostname or physical address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a port number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"})) -- throws : False -- Skip return : False foreign import ccall "soup_address_new" soup_address_new :: CString -> -- name : TBasicType TUTF8 Word32 -> -- port : TBasicType TUInt IO (Ptr Address) {- | Creates a 'GI.Soup.Objects.Address.Address' from /@name@/ and /@port@/. The 'GI.Soup.Objects.Address.Address'\'s IP address may not be available right away; the caller can call 'GI.Soup.Objects.Address.addressResolveAsync' or 'GI.Soup.Objects.Address.addressResolveSync' to force a DNS resolution. -} addressNew :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@name@/: a hostname or physical address -} -> Word32 {- ^ /@port@/: a port number -} -> m Address {- ^ __Returns:__ a 'GI.Soup.Objects.Address.Address' -} addressNew name port = liftIO $ do name' <- textToCString name result <- soup_address_new name' port checkUnexpectedReturnNULL "addressNew" result result' <- (wrapObject Address) result freeMem name' return result' #if ENABLE_OVERLOADING #endif -- method Address::new_any -- method type : Constructor -- Args : [Arg {argCName = "family", argType = TInterface (Name {namespace = "Soup", name = "AddressFamily"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the address family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the port number (usually %SOUP_ADDRESS_ANY_PORT)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"})) -- throws : False -- Skip return : False foreign import ccall "soup_address_new_any" soup_address_new_any :: CInt -> -- family : TInterface (Name {namespace = "Soup", name = "AddressFamily"}) Word32 -> -- port : TBasicType TUInt IO (Ptr Address) {- | Returns a 'GI.Soup.Objects.Address.Address' corresponding to the \"any\" address for /@family@/ (or 'Nothing' if /@family@/ isn\'t supported), suitable for using as a listening 'GI.Soup.Objects.Socket.Socket'. -} addressNewAny :: (B.CallStack.HasCallStack, MonadIO m) => Soup.Enums.AddressFamily {- ^ /@family@/: the address family -} -> Word32 {- ^ /@port@/: the port number (usually 'GI.Soup.Constants.ADDRESS_ANY_PORT') -} -> m (Maybe Address) {- ^ __Returns:__ the new 'GI.Soup.Objects.Address.Address' -} addressNewAny family port = liftIO $ do let family' = (fromIntegral . fromEnum) family result <- soup_address_new_any family' port maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Address) result' return result'' return maybeResult #if ENABLE_OVERLOADING #endif -- method Address::new_from_sockaddr -- method type : Constructor -- Args : [Arg {argCName = "sa", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a pointer to a sockaddr", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of @sa", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"})) -- throws : False -- Skip return : False foreign import ccall "soup_address_new_from_sockaddr" soup_address_new_from_sockaddr :: Ptr () -> -- sa : TBasicType TPtr Int32 -> -- len : TBasicType TInt IO (Ptr Address) {- | Returns a 'GI.Soup.Objects.Address.Address' equivalent to /@sa@/ (or 'Nothing' if /@sa@/\'s address family isn\'t supported) -} addressNewFromSockaddr :: (B.CallStack.HasCallStack, MonadIO m) => Ptr () {- ^ /@sa@/: a pointer to a sockaddr -} -> Int32 {- ^ /@len@/: size of /@sa@/ -} -> m (Maybe Address) {- ^ __Returns:__ the new 'GI.Soup.Objects.Address.Address' -} addressNewFromSockaddr sa len = liftIO $ do result <- soup_address_new_from_sockaddr sa len maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Address) result' return result'' return maybeResult #if ENABLE_OVERLOADING #endif -- method Address::equal_by_ip -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr1", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress with a resolved IP\n address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "addr2", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #SoupAddress with a resolved\n IP address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_address_equal_by_ip" soup_address_equal_by_ip :: Ptr Address -> -- addr1 : TInterface (Name {namespace = "Soup", name = "Address"}) Ptr Address -> -- addr2 : TInterface (Name {namespace = "Soup", name = "Address"}) IO CInt {- | Tests if /@addr1@/ and /@addr2@/ have the same IP address. This method can be used with 'GI.Soup.Objects.Address.addressHashByIp' to create a 'GI.GLib.Structs.HashTable.HashTable' that hashes on IP address. This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered the same. Eg, if \"www.example.com\" and \"www.example.net\" have the same IP address, then a single connection can be used to talk to either of them. See also 'GI.Soup.Objects.Address.addressEqualByName', which compares by name rather than by IP address. /Since: 2.26/ -} addressEqualByIp :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) => a {- ^ /@addr1@/: a 'GI.Soup.Objects.Address.Address' with a resolved IP address -} -> b {- ^ /@addr2@/: another 'GI.Soup.Objects.Address.Address' with a resolved IP address -} -> m Bool {- ^ __Returns:__ whether or not /@addr1@/ and /@addr2@/ have the same IP address. -} addressEqualByIp addr1 addr2 = liftIO $ do addr1' <- unsafeManagedPtrCastPtr addr1 addr2' <- unsafeManagedPtrCastPtr addr2 result <- soup_address_equal_by_ip addr1' addr2' let result' = (/= 0) result touchManagedPtr addr1 touchManagedPtr addr2 return result' #if ENABLE_OVERLOADING data AddressEqualByIpMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => O.MethodInfo AddressEqualByIpMethodInfo a signature where overloadedMethod _ = addressEqualByIp #endif -- method Address::equal_by_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr1", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress with a resolved name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "addr2", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #SoupAddress with a resolved\n name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_address_equal_by_name" soup_address_equal_by_name :: Ptr Address -> -- addr1 : TInterface (Name {namespace = "Soup", name = "Address"}) Ptr Address -> -- addr2 : TInterface (Name {namespace = "Soup", name = "Address"}) IO CInt {- | Tests if /@addr1@/ and /@addr2@/ have the same \"name\". This method can be used with 'GI.Soup.Objects.Address.addressHashByName' to create a 'GI.GLib.Structs.HashTable.HashTable' that hashes on address \"names\". Comparing by name normally means comparing the addresses by their hostnames. But if the address was originally created using an IP address literal, then it will be compared by that instead. In particular, if \"www.example.com\" has the IP address 10.0.0.1, and /@addr1@/ was created with the name \"www.example.com\" and /@addr2@/ was created with the name \"10.0.0.1\", then they will compare as unequal for purposes of 'GI.Soup.Objects.Address.addressEqualByName'. This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered different. Eg, for purposes of HTTP authentication or cookies, two hosts with the same IP address but different names are considered to be different hosts. See also 'GI.Soup.Objects.Address.addressEqualByIp', which compares by IP address rather than by name. /Since: 2.26/ -} addressEqualByName :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) => a {- ^ /@addr1@/: a 'GI.Soup.Objects.Address.Address' with a resolved name -} -> b {- ^ /@addr2@/: another 'GI.Soup.Objects.Address.Address' with a resolved name -} -> m Bool {- ^ __Returns:__ whether or not /@addr1@/ and /@addr2@/ have the same name -} addressEqualByName addr1 addr2 = liftIO $ do addr1' <- unsafeManagedPtrCastPtr addr1 addr2' <- unsafeManagedPtrCastPtr addr2 result <- soup_address_equal_by_name addr1' addr2' let result' = (/= 0) result touchManagedPtr addr1 touchManagedPtr addr2 return result' #if ENABLE_OVERLOADING data AddressEqualByNameMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => O.MethodInfo AddressEqualByNameMethodInfo a signature where overloadedMethod _ = addressEqualByName #endif -- method Address::get_gsockaddr -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketAddress"})) -- throws : False -- Skip return : False foreign import ccall "soup_address_get_gsockaddr" soup_address_get_gsockaddr :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO (Ptr Gio.SocketAddress.SocketAddress) {- | Creates a new 'GI.Gio.Objects.SocketAddress.SocketAddress' corresponding to /@addr@/ (which is assumed to only have one socket address associated with it). /Since: 2.32/ -} addressGetGsockaddr :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m Gio.SocketAddress.SocketAddress {- ^ __Returns:__ a new 'GI.Gio.Objects.SocketAddress.SocketAddress' -} addressGetGsockaddr addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_get_gsockaddr addr' checkUnexpectedReturnNULL "addressGetGsockaddr" result result' <- (wrapObject Gio.SocketAddress.SocketAddress) result touchManagedPtr addr return result' #if ENABLE_OVERLOADING data AddressGetGsockaddrMethodInfo instance (signature ~ (m Gio.SocketAddress.SocketAddress), MonadIO m, IsAddress a) => O.MethodInfo AddressGetGsockaddrMethodInfo a signature where overloadedMethod _ = addressGetGsockaddr #endif -- method Address::get_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "soup_address_get_name" soup_address_get_name :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO CString {- | Returns the hostname associated with /@addr@/. This method is not thread-safe; if you call it while /@addr@/ is being resolved in another thread, it may return garbage. You can use 'GI.Soup.Objects.Address.addressIsResolved' to safely test whether or not an address is resolved before fetching its name or address. -} addressGetName :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m (Maybe T.Text) {- ^ __Returns:__ the hostname, or 'Nothing' if it is not known. -} addressGetName addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_get_name addr' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr addr return maybeResult #if ENABLE_OVERLOADING data AddressGetNameMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAddress a) => O.MethodInfo AddressGetNameMethodInfo a signature where overloadedMethod _ = addressGetName #endif -- method Address::get_physical -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "soup_address_get_physical" soup_address_get_physical :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO CString {- | Returns the physical address associated with /@addr@/ as a string. (Eg, \"127.0.0.1\"). If the address is not yet known, returns 'Nothing'. This method is not thread-safe; if you call it while /@addr@/ is being resolved in another thread, it may return garbage. You can use 'GI.Soup.Objects.Address.addressIsResolved' to safely test whether or not an address is resolved before fetching its name or address. -} addressGetPhysical :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m (Maybe T.Text) {- ^ __Returns:__ the physical address, or 'Nothing' -} addressGetPhysical addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_get_physical addr' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr addr return maybeResult #if ENABLE_OVERLOADING data AddressGetPhysicalMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAddress a) => O.MethodInfo AddressGetPhysicalMethodInfo a signature where overloadedMethod _ = addressGetPhysical #endif -- method Address::get_port -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "soup_address_get_port" soup_address_get_port :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO Word32 {- | Returns the port associated with /@addr@/. -} addressGetPort :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m Word32 {- ^ __Returns:__ the port -} addressGetPort addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_get_port addr' touchManagedPtr addr return result #if ENABLE_OVERLOADING data AddressGetPortMethodInfo instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressGetPortMethodInfo a signature where overloadedMethod _ = addressGetPort #endif -- method Address::hash_by_ip -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "soup_address_hash_by_ip" soup_address_hash_by_ip :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO Word32 {- | A hash function (for 'GI.GLib.Structs.HashTable.HashTable') that corresponds to 'GI.Soup.Objects.Address.addressEqualByIp', qv /Since: 2.26/ -} addressHashByIp :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m Word32 {- ^ __Returns:__ the IP-based hash value for /@addr@/. -} addressHashByIp addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_hash_by_ip addr' touchManagedPtr addr return result #if ENABLE_OVERLOADING data AddressHashByIpMethodInfo instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressHashByIpMethodInfo a signature where overloadedMethod _ = addressHashByIp #endif -- method Address::hash_by_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "soup_address_hash_by_name" soup_address_hash_by_name :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO Word32 {- | A hash function (for 'GI.GLib.Structs.HashTable.HashTable') that corresponds to 'GI.Soup.Objects.Address.addressEqualByName', qv /Since: 2.26/ -} addressHashByName :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m Word32 {- ^ __Returns:__ the named-based hash value for /@addr@/. -} addressHashByName addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_hash_by_name addr' touchManagedPtr addr return result #if ENABLE_OVERLOADING data AddressHashByNameMethodInfo instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressHashByNameMethodInfo a signature where overloadedMethod _ = addressHashByName #endif -- method Address::is_resolved -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_address_is_resolved" soup_address_is_resolved :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) IO CInt {- | Tests if /@addr@/ has already been resolved. Unlike the other 'GI.Soup.Objects.Address.Address' \"get\" methods, this is safe to call when /@addr@/ might be being resolved in another thread. -} addressIsResolved :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> m Bool {- ^ __Returns:__ 'True' if /@addr@/ has been resolved. -} addressIsResolved addr = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr result <- soup_address_is_resolved addr' let result' = (/= 0) result touchManagedPtr addr return result' #if ENABLE_OVERLOADING data AddressIsResolvedMethodInfo instance (signature ~ (m Bool), MonadIO m, IsAddress a) => O.MethodInfo AddressIsResolvedMethodInfo a signature where overloadedMethod _ = addressIsResolved #endif -- method Address::resolve_async -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "async_context", argType = TInterface (Name {namespace = "GLib", name = "MainContext"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GMainContext to call @callback from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Soup", name = "AddressCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "callback to call with the result", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_address_resolve_async" soup_address_resolve_async :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) Ptr GLib.MainContext.MainContext -> -- async_context : TInterface (Name {namespace = "GLib", name = "MainContext"}) Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) FunPtr Soup.Callbacks.C_AddressCallback -> -- callback : TInterface (Name {namespace = "Soup", name = "AddressCallback"}) Ptr () -> -- user_data : TBasicType TPtr IO () {- | Asynchronously resolves the missing half of /@addr@/ (its IP address if it was created with 'GI.Soup.Objects.Address.addressNew', or its hostname if it was created with 'GI.Soup.Objects.Address.addressNewFromSockaddr' or 'GI.Soup.Objects.Address.addressNewAny'.) If /@cancellable@/ is non-'Nothing', it can be used to cancel the resolution. /@callback@/ will still be invoked in this case, with a status of 'GI.Soup.Enums.StatusCancelled'. It is safe to call this more than once on a given address, from the same thread, with the same /@asyncContext@/ (and doing so will not result in redundant DNS queries being made). But it is not safe to call from multiple threads, or with different /@asyncContexts@/, or mixed with calls to 'GI.Soup.Objects.Address.addressResolveSync'. -} addressResolveAsync :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> Maybe (GLib.MainContext.MainContext) {- ^ /@asyncContext@/: the 'GI.GLib.Structs.MainContext.MainContext' to call /@callback@/ from -} -> Maybe (b) {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -} -> Soup.Callbacks.AddressCallback {- ^ /@callback@/: callback to call with the result -} -> m () addressResolveAsync addr asyncContext cancellable callback = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr maybeAsyncContext <- case asyncContext of Nothing -> return nullPtr Just jAsyncContext -> do jAsyncContext' <- unsafeManagedPtrGetPtr jAsyncContext return jAsyncContext' maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' ptrcallback <- callocMem :: IO (Ptr (FunPtr Soup.Callbacks.C_AddressCallback)) callback' <- Soup.Callbacks.mk_AddressCallback (Soup.Callbacks.wrap_AddressCallback (Just ptrcallback) (Soup.Callbacks.drop_closures_AddressCallback callback)) poke ptrcallback callback' let userData = nullPtr soup_address_resolve_async addr' maybeAsyncContext maybeCancellable callback' userData touchManagedPtr addr whenJust asyncContext touchManagedPtr whenJust cancellable touchManagedPtr return () #if ENABLE_OVERLOADING data AddressResolveAsyncMethodInfo instance (signature ~ (Maybe (GLib.MainContext.MainContext) -> Maybe (b) -> Soup.Callbacks.AddressCallback -> m ()), MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => O.MethodInfo AddressResolveAsyncMethodInfo a signature where overloadedMethod _ = addressResolveAsync #endif -- method Address::resolve_sync -- method type : OrdinaryMethod -- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "soup_address_resolve_sync" soup_address_resolve_sync :: Ptr Address -> -- addr : TInterface (Name {namespace = "Soup", name = "Address"}) Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) IO Word32 {- | Synchronously resolves the missing half of /@addr@/, as with 'GI.Soup.Objects.Address.addressResolveAsync'. If /@cancellable@/ is non-'Nothing', it can be used to cancel the resolution. 'GI.Soup.Objects.Address.addressResolveSync' will then return a status of 'GI.Soup.Enums.StatusCancelled'. It is safe to call this more than once, even from different threads, but it is not safe to mix calls to 'GI.Soup.Objects.Address.addressResolveSync' with calls to 'GI.Soup.Objects.Address.addressResolveAsync' on the same address. -} addressResolveSync :: (B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => a {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -} -> Maybe (b) {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -} -> m Word32 {- ^ __Returns:__ 'GI.Soup.Enums.StatusOk', 'GI.Soup.Enums.StatusCantResolve', or 'GI.Soup.Enums.StatusCancelled'. -} addressResolveSync addr cancellable = liftIO $ do addr' <- unsafeManagedPtrCastPtr addr maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' result <- soup_address_resolve_sync addr' maybeCancellable touchManagedPtr addr whenJust cancellable touchManagedPtr return result #if ENABLE_OVERLOADING data AddressResolveSyncMethodInfo instance (signature ~ (Maybe (b) -> m Word32), MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => O.MethodInfo AddressResolveSyncMethodInfo a signature where overloadedMethod _ = addressResolveSync #endif