gi-gio-2.0.20: GI/Gio/Objects/NetworkService.hs

{- |
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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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