{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) Like 'GI.Gio.Objects.NetworkAddress.NetworkAddress' does with hostnames, 'GI.Gio.Objects.NetworkService.NetworkService' provides an easy way to resolve a SRV record, and then attempt to connect to one of the hosts that implements that service, handling service priority\/weighting, multiple IP addresses, and multiple address families. See 'GI.Gio.Structs.SrvTarget.SrvTarget' for more information about SRV records, and see 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' for an example of using the connectable interface. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.NetworkService ( -- * Exported types NetworkService(..) , IsNetworkService , toNetworkService , noNetworkService , -- * Methods -- ** getDomain #method:getDomain# #if ENABLE_OVERLOADING NetworkServiceGetDomainMethodInfo , #endif networkServiceGetDomain , -- ** getProtocol #method:getProtocol# #if ENABLE_OVERLOADING NetworkServiceGetProtocolMethodInfo , #endif networkServiceGetProtocol , -- ** getScheme #method:getScheme# #if ENABLE_OVERLOADING NetworkServiceGetSchemeMethodInfo , #endif networkServiceGetScheme , -- ** getService #method:getService# #if ENABLE_OVERLOADING NetworkServiceGetServiceMethodInfo , #endif networkServiceGetService , -- ** new #method:new# networkServiceNew , -- ** setScheme #method:setScheme# #if ENABLE_OVERLOADING NetworkServiceSetSchemeMethodInfo , #endif networkServiceSetScheme , -- * Properties -- ** domain #attr:domain# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING NetworkServiceDomainPropertyInfo , #endif constructNetworkServiceDomain , getNetworkServiceDomain , #if ENABLE_OVERLOADING networkServiceDomain , #endif -- ** protocol #attr:protocol# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING NetworkServiceProtocolPropertyInfo , #endif constructNetworkServiceProtocol , getNetworkServiceProtocol , #if ENABLE_OVERLOADING networkServiceProtocol , #endif -- ** scheme #attr:scheme# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING NetworkServiceSchemePropertyInfo , #endif constructNetworkServiceScheme , getNetworkServiceScheme , #if ENABLE_OVERLOADING networkServiceScheme , #endif setNetworkServiceScheme , -- ** service #attr:service# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING NetworkServiceServicePropertyInfo , #endif constructNetworkServiceService , getNetworkServiceService , #if ENABLE_OVERLOADING networkServiceService , #endif ) 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.GObject.Objects.Object as GObject.Object import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable -- | Memory-managed wrapper type. newtype NetworkService = NetworkService (ManagedPtr NetworkService) foreign import ccall "g_network_service_get_type" c_g_network_service_get_type :: IO GType instance GObject NetworkService where gobjectType = c_g_network_service_get_type -- | Type class for types which can be safely cast to `NetworkService`, for instance with `toNetworkService`. class (GObject o, O.IsDescendantOf NetworkService o) => IsNetworkService o instance (GObject o, O.IsDescendantOf NetworkService o) => IsNetworkService o instance O.HasParentTypes NetworkService type instance O.ParentTypes NetworkService = '[GObject.Object.Object, Gio.SocketConnectable.SocketConnectable] -- | Cast to `NetworkService`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toNetworkService :: (MonadIO m, IsNetworkService o) => o -> m NetworkService toNetworkService = liftIO . unsafeCastTo NetworkService -- | A convenience alias for `Nothing` :: `Maybe` `NetworkService`. noNetworkService :: Maybe NetworkService noNetworkService = Nothing #if ENABLE_OVERLOADING type family ResolveNetworkServiceMethod (t :: Symbol) (o :: *) :: * where ResolveNetworkServiceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveNetworkServiceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveNetworkServiceMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo ResolveNetworkServiceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveNetworkServiceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveNetworkServiceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveNetworkServiceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveNetworkServiceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveNetworkServiceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveNetworkServiceMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo ResolveNetworkServiceMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveNetworkServiceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveNetworkServiceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveNetworkServiceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveNetworkServiceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveNetworkServiceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveNetworkServiceMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo ResolveNetworkServiceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveNetworkServiceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveNetworkServiceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveNetworkServiceMethod "getDomain" o = NetworkServiceGetDomainMethodInfo ResolveNetworkServiceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveNetworkServiceMethod "getProtocol" o = NetworkServiceGetProtocolMethodInfo ResolveNetworkServiceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveNetworkServiceMethod "getScheme" o = NetworkServiceGetSchemeMethodInfo ResolveNetworkServiceMethod "getService" o = NetworkServiceGetServiceMethodInfo ResolveNetworkServiceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveNetworkServiceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveNetworkServiceMethod "setScheme" o = NetworkServiceSetSchemeMethodInfo ResolveNetworkServiceMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveNetworkServiceMethod t NetworkService, O.MethodInfo info NetworkService p) => OL.IsLabel t (NetworkService -> 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 "domain" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@domain@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' networkService #domain @ -} getNetworkServiceDomain :: (MonadIO m, IsNetworkService o) => o -> m T.Text getNetworkServiceDomain obj = liftIO $ checkUnexpectedNothing "getNetworkServiceDomain" $ B.Properties.getObjectPropertyString obj "domain" {- | Construct a `GValueConstruct` with valid value for the “@domain@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructNetworkServiceDomain :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o) constructNetworkServiceDomain val = B.Properties.constructObjectPropertyString "domain" (Just val) #if ENABLE_OVERLOADING data NetworkServiceDomainPropertyInfo instance AttrInfo NetworkServiceDomainPropertyInfo where type AttrAllowedOps NetworkServiceDomainPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint NetworkServiceDomainPropertyInfo = (~) T.Text type AttrBaseTypeConstraint NetworkServiceDomainPropertyInfo = IsNetworkService type AttrGetType NetworkServiceDomainPropertyInfo = T.Text type AttrLabel NetworkServiceDomainPropertyInfo = "domain" type AttrOrigin NetworkServiceDomainPropertyInfo = NetworkService attrGet _ = getNetworkServiceDomain attrSet _ = undefined attrConstruct _ = constructNetworkServiceDomain attrClear _ = undefined #endif -- VVV Prop "protocol" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@protocol@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' networkService #protocol @ -} getNetworkServiceProtocol :: (MonadIO m, IsNetworkService o) => o -> m T.Text getNetworkServiceProtocol obj = liftIO $ checkUnexpectedNothing "getNetworkServiceProtocol" $ 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`. -} constructNetworkServiceProtocol :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o) constructNetworkServiceProtocol val = B.Properties.constructObjectPropertyString "protocol" (Just val) #if ENABLE_OVERLOADING data NetworkServiceProtocolPropertyInfo instance AttrInfo NetworkServiceProtocolPropertyInfo where type AttrAllowedOps NetworkServiceProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint NetworkServiceProtocolPropertyInfo = (~) T.Text type AttrBaseTypeConstraint NetworkServiceProtocolPropertyInfo = IsNetworkService type AttrGetType NetworkServiceProtocolPropertyInfo = T.Text type AttrLabel NetworkServiceProtocolPropertyInfo = "protocol" type AttrOrigin NetworkServiceProtocolPropertyInfo = NetworkService attrGet _ = getNetworkServiceProtocol attrSet _ = undefined attrConstruct _ = constructNetworkServiceProtocol attrClear _ = undefined #endif -- VVV Prop "scheme" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@scheme@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' networkService #scheme @ -} getNetworkServiceScheme :: (MonadIO m, IsNetworkService o) => o -> m T.Text getNetworkServiceScheme obj = liftIO $ checkUnexpectedNothing "getNetworkServiceScheme" $ B.Properties.getObjectPropertyString obj "scheme" {- | Set the value of the “@scheme@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' networkService [ #scheme 'Data.GI.Base.Attributes.:=' value ] @ -} setNetworkServiceScheme :: (MonadIO m, IsNetworkService o) => o -> T.Text -> m () setNetworkServiceScheme obj val = liftIO $ B.Properties.setObjectPropertyString obj "scheme" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@scheme@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructNetworkServiceScheme :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o) constructNetworkServiceScheme val = B.Properties.constructObjectPropertyString "scheme" (Just val) #if ENABLE_OVERLOADING data NetworkServiceSchemePropertyInfo instance AttrInfo NetworkServiceSchemePropertyInfo where type AttrAllowedOps NetworkServiceSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint NetworkServiceSchemePropertyInfo = (~) T.Text type AttrBaseTypeConstraint NetworkServiceSchemePropertyInfo = IsNetworkService type AttrGetType NetworkServiceSchemePropertyInfo = T.Text type AttrLabel NetworkServiceSchemePropertyInfo = "scheme" type AttrOrigin NetworkServiceSchemePropertyInfo = NetworkService attrGet _ = getNetworkServiceScheme attrSet _ = setNetworkServiceScheme attrConstruct _ = constructNetworkServiceScheme attrClear _ = undefined #endif -- VVV Prop "service" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@service@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' networkService #service @ -} getNetworkServiceService :: (MonadIO m, IsNetworkService o) => o -> m T.Text getNetworkServiceService obj = liftIO $ checkUnexpectedNothing "getNetworkServiceService" $ B.Properties.getObjectPropertyString obj "service" {- | Construct a `GValueConstruct` with valid value for the “@service@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructNetworkServiceService :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o) constructNetworkServiceService val = B.Properties.constructObjectPropertyString "service" (Just val) #if ENABLE_OVERLOADING data NetworkServiceServicePropertyInfo instance AttrInfo NetworkServiceServicePropertyInfo where type AttrAllowedOps NetworkServiceServicePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint NetworkServiceServicePropertyInfo = (~) T.Text type AttrBaseTypeConstraint NetworkServiceServicePropertyInfo = IsNetworkService type AttrGetType NetworkServiceServicePropertyInfo = T.Text type AttrLabel NetworkServiceServicePropertyInfo = "service" type AttrOrigin NetworkServiceServicePropertyInfo = NetworkService attrGet _ = getNetworkServiceService attrSet _ = undefined attrConstruct _ = constructNetworkServiceService attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList NetworkService type instance O.AttributeList NetworkService = NetworkServiceAttributeList type NetworkServiceAttributeList = ('[ '("domain", NetworkServiceDomainPropertyInfo), '("protocol", NetworkServiceProtocolPropertyInfo), '("scheme", NetworkServiceSchemePropertyInfo), '("service", NetworkServiceServicePropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING networkServiceDomain :: AttrLabelProxy "domain" networkServiceDomain = AttrLabelProxy networkServiceProtocol :: AttrLabelProxy "protocol" networkServiceProtocol = AttrLabelProxy networkServiceScheme :: AttrLabelProxy "scheme" networkServiceScheme = AttrLabelProxy networkServiceService :: AttrLabelProxy "service" networkServiceService = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList NetworkService = NetworkServiceSignalList type NetworkServiceSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method NetworkService::new -- method type : Constructor -- Args : [Arg {argCName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the service type to look up (eg, \"ldap\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the networking protocol to use for @service (eg, \"tcp\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS domain to look up the service in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "NetworkService"})) -- throws : False -- Skip return : False foreign import ccall "g_network_service_new" g_network_service_new :: CString -> -- service : TBasicType TUTF8 CString -> -- protocol : TBasicType TUTF8 CString -> -- domain : TBasicType TUTF8 IO (Ptr NetworkService) {- | Creates a new 'GI.Gio.Objects.NetworkService.NetworkService' representing the given /@service@/, /@protocol@/, and /@domain@/. This will initially be unresolved; use the 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' interface to resolve it. /Since: 2.22/ -} networkServiceNew :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@service@/: the service type to look up (eg, \"ldap\") -} -> T.Text {- ^ /@protocol@/: the networking protocol to use for /@service@/ (eg, \"tcp\") -} -> T.Text {- ^ /@domain@/: the DNS domain to look up the service in -} -> m NetworkService {- ^ __Returns:__ a new 'GI.Gio.Objects.NetworkService.NetworkService' -} networkServiceNew service protocol domain = liftIO $ do service' <- textToCString service protocol' <- textToCString protocol domain' <- textToCString domain result <- g_network_service_new service' protocol' domain' checkUnexpectedReturnNULL "networkServiceNew" result result' <- (wrapObject NetworkService) result freeMem service' freeMem protocol' freeMem domain' return result' #if ENABLE_OVERLOADING #endif -- method NetworkService::get_domain -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", 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 "g_network_service_get_domain" g_network_service_get_domain :: Ptr NetworkService -> -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"}) IO CString {- | Gets the domain that /@srv@/ serves. This might be either UTF-8 or ASCII-encoded, depending on what /@srv@/ was created with. /Since: 2.22/ -} networkServiceGetDomain :: (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) => a {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -} -> m T.Text {- ^ __Returns:__ /@srv@/\'s domain name -} networkServiceGetDomain srv = liftIO $ do srv' <- unsafeManagedPtrCastPtr srv result <- g_network_service_get_domain srv' checkUnexpectedReturnNULL "networkServiceGetDomain" result result' <- cstringToText result touchManagedPtr srv return result' #if ENABLE_OVERLOADING data NetworkServiceGetDomainMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetDomainMethodInfo a signature where overloadedMethod _ = networkServiceGetDomain #endif -- method NetworkService::get_protocol -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", 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 "g_network_service_get_protocol" g_network_service_get_protocol :: Ptr NetworkService -> -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"}) IO CString {- | Gets /@srv@/\'s protocol name (eg, \"tcp\"). /Since: 2.22/ -} networkServiceGetProtocol :: (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) => a {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -} -> m T.Text {- ^ __Returns:__ /@srv@/\'s protocol name -} networkServiceGetProtocol srv = liftIO $ do srv' <- unsafeManagedPtrCastPtr srv result <- g_network_service_get_protocol srv' checkUnexpectedReturnNULL "networkServiceGetProtocol" result result' <- cstringToText result touchManagedPtr srv return result' #if ENABLE_OVERLOADING data NetworkServiceGetProtocolMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetProtocolMethodInfo a signature where overloadedMethod _ = networkServiceGetProtocol #endif -- method NetworkService::get_scheme -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", 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 "g_network_service_get_scheme" g_network_service_get_scheme :: Ptr NetworkService -> -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"}) IO CString {- | Get\'s the URI scheme used to resolve proxies. By default, the service name is used as scheme. /Since: 2.26/ -} networkServiceGetScheme :: (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) => a {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -} -> m T.Text {- ^ __Returns:__ /@srv@/\'s scheme name -} networkServiceGetScheme srv = liftIO $ do srv' <- unsafeManagedPtrCastPtr srv result <- g_network_service_get_scheme srv' checkUnexpectedReturnNULL "networkServiceGetScheme" result result' <- cstringToText result touchManagedPtr srv return result' #if ENABLE_OVERLOADING data NetworkServiceGetSchemeMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetSchemeMethodInfo a signature where overloadedMethod _ = networkServiceGetScheme #endif -- method NetworkService::get_service -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", 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 "g_network_service_get_service" g_network_service_get_service :: Ptr NetworkService -> -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"}) IO CString {- | Gets /@srv@/\'s service name (eg, \"ldap\"). /Since: 2.22/ -} networkServiceGetService :: (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) => a {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -} -> m T.Text {- ^ __Returns:__ /@srv@/\'s service name -} networkServiceGetService srv = liftIO $ do srv' <- unsafeManagedPtrCastPtr srv result <- g_network_service_get_service srv' checkUnexpectedReturnNULL "networkServiceGetService" result result' <- cstringToText result touchManagedPtr srv return result' #if ENABLE_OVERLOADING data NetworkServiceGetServiceMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetServiceMethodInfo a signature where overloadedMethod _ = networkServiceGetService #endif -- method NetworkService::set_scheme -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_network_service_set_scheme" g_network_service_set_scheme :: Ptr NetworkService -> -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"}) CString -> -- scheme : TBasicType TUTF8 IO () {- | Set\'s the URI scheme used to resolve proxies. By default, the service name is used as scheme. /Since: 2.26/ -} networkServiceSetScheme :: (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) => a {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -} -> T.Text {- ^ /@scheme@/: a URI scheme -} -> m () networkServiceSetScheme srv scheme = liftIO $ do srv' <- unsafeManagedPtrCastPtr srv scheme' <- textToCString scheme g_network_service_set_scheme srv' scheme' touchManagedPtr srv freeMem scheme' return () #if ENABLE_OVERLOADING data NetworkServiceSetSchemeMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceSetSchemeMethodInfo a signature where overloadedMethod _ = networkServiceSetScheme #endif