{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Interfaces.SocketConnectable
(
SocketConnectable(..) ,
IsSocketConnectable ,
toSocketConnectable ,
#if defined(ENABLE_OVERLOADING)
ResolveSocketConnectableMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SocketConnectableEnumerateMethodInfo ,
#endif
socketConnectableEnumerate ,
#if defined(ENABLE_OVERLOADING)
SocketConnectableProxyEnumerateMethodInfo,
#endif
socketConnectableProxyEnumerate ,
#if defined(ENABLE_OVERLOADING)
SocketConnectableToStringMethodInfo ,
#endif
socketConnectableToString ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddressEnumerator as Gio.SocketAddressEnumerator
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddressEnumerator as Gio.SocketAddressEnumerator
#endif
newtype SocketConnectable = SocketConnectable (SP.ManagedPtr SocketConnectable)
deriving (SocketConnectable -> SocketConnectable -> Bool
(SocketConnectable -> SocketConnectable -> Bool)
-> (SocketConnectable -> SocketConnectable -> Bool)
-> Eq SocketConnectable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SocketConnectable -> SocketConnectable -> Bool
== :: SocketConnectable -> SocketConnectable -> Bool
$c/= :: SocketConnectable -> SocketConnectable -> Bool
/= :: SocketConnectable -> SocketConnectable -> Bool
Eq)
instance SP.ManagedPtrNewtype SocketConnectable where
toManagedPtr :: SocketConnectable -> ManagedPtr SocketConnectable
toManagedPtr (SocketConnectable ManagedPtr SocketConnectable
p) = ManagedPtr SocketConnectable
p
foreign import ccall "g_socket_connectable_get_type"
c_g_socket_connectable_get_type :: IO B.Types.GType
instance B.Types.TypedObject SocketConnectable where
glibType :: IO GType
glibType = IO GType
c_g_socket_connectable_get_type
instance B.Types.GObject SocketConnectable
class (SP.GObject o, O.IsDescendantOf SocketConnectable o) => IsSocketConnectable o
instance (SP.GObject o, O.IsDescendantOf SocketConnectable o) => IsSocketConnectable o
instance O.HasParentTypes SocketConnectable
type instance O.ParentTypes SocketConnectable = '[GObject.Object.Object]
toSocketConnectable :: (MIO.MonadIO m, IsSocketConnectable o) => o -> m SocketConnectable
toSocketConnectable :: forall (m :: * -> *) o.
(MonadIO m, IsSocketConnectable o) =>
o -> m SocketConnectable
toSocketConnectable = IO SocketConnectable -> m SocketConnectable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SocketConnectable -> m SocketConnectable)
-> (o -> IO SocketConnectable) -> o -> m SocketConnectable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SocketConnectable -> SocketConnectable)
-> o -> IO SocketConnectable
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr SocketConnectable -> SocketConnectable
SocketConnectable
instance B.GValue.IsGValue (Maybe SocketConnectable) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_socket_connectable_get_type
gvalueSet_ :: Ptr GValue -> Maybe SocketConnectable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SocketConnectable
P.Nothing = Ptr GValue -> Ptr SocketConnectable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SocketConnectable
forall a. Ptr a
FP.nullPtr :: FP.Ptr SocketConnectable)
gvalueSet_ Ptr GValue
gv (P.Just SocketConnectable
obj) = SocketConnectable -> (Ptr SocketConnectable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SocketConnectable
obj (Ptr GValue -> Ptr SocketConnectable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe SocketConnectable)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr SocketConnectable)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SocketConnectable)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject SocketConnectable ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SocketConnectable
type instance O.AttributeList SocketConnectable = SocketConnectableAttributeList
type SocketConnectableAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSocketConnectableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveSocketConnectableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSocketConnectableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSocketConnectableMethod "enumerate" o = SocketConnectableEnumerateMethodInfo
ResolveSocketConnectableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSocketConnectableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSocketConnectableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSocketConnectableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSocketConnectableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSocketConnectableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSocketConnectableMethod "proxyEnumerate" o = SocketConnectableProxyEnumerateMethodInfo
ResolveSocketConnectableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSocketConnectableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSocketConnectableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSocketConnectableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSocketConnectableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSocketConnectableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSocketConnectableMethod "toString" o = SocketConnectableToStringMethodInfo
ResolveSocketConnectableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSocketConnectableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSocketConnectableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSocketConnectableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSocketConnectableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSocketConnectableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSocketConnectableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveSocketConnectableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSocketConnectableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSocketConnectableMethod t SocketConnectable, O.OverloadedMethod info SocketConnectable p) => OL.IsLabel t (SocketConnectable -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveSocketConnectableMethod t SocketConnectable, O.OverloadedMethod info SocketConnectable p, R.HasField t SocketConnectable p) => R.HasField t SocketConnectable p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSocketConnectableMethod t SocketConnectable, O.OverloadedMethodInfo info SocketConnectable) => OL.IsLabel t (O.MethodProxy info SocketConnectable) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "g_socket_connectable_enumerate" g_socket_connectable_enumerate ::
Ptr SocketConnectable ->
IO (Ptr Gio.SocketAddressEnumerator.SocketAddressEnumerator)
socketConnectableEnumerate ::
(B.CallStack.HasCallStack, MonadIO m, IsSocketConnectable a) =>
a
-> m Gio.SocketAddressEnumerator.SocketAddressEnumerator
socketConnectableEnumerate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSocketConnectable a) =>
a -> m SocketAddressEnumerator
socketConnectableEnumerate a
connectable = IO SocketAddressEnumerator -> m SocketAddressEnumerator
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketAddressEnumerator -> m SocketAddressEnumerator)
-> IO SocketAddressEnumerator -> m SocketAddressEnumerator
forall a b. (a -> b) -> a -> b
$ do
connectable' <- a -> IO (Ptr SocketConnectable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connectable
result <- g_socket_connectable_enumerate connectable'
checkUnexpectedReturnNULL "socketConnectableEnumerate" result
result' <- (wrapObject Gio.SocketAddressEnumerator.SocketAddressEnumerator) result
touchManagedPtr connectable
return result'
#if defined(ENABLE_OVERLOADING)
data SocketConnectableEnumerateMethodInfo
instance (signature ~ (m Gio.SocketAddressEnumerator.SocketAddressEnumerator), MonadIO m, IsSocketConnectable a) => O.OverloadedMethod SocketConnectableEnumerateMethodInfo a signature where
overloadedMethod = socketConnectableEnumerate
instance O.OverloadedMethodInfo SocketConnectableEnumerateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.SocketConnectable.socketConnectableEnumerate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Interfaces-SocketConnectable.html#v:socketConnectableEnumerate"
})
#endif
foreign import ccall "g_socket_connectable_proxy_enumerate" g_socket_connectable_proxy_enumerate ::
Ptr SocketConnectable ->
IO (Ptr Gio.SocketAddressEnumerator.SocketAddressEnumerator)
socketConnectableProxyEnumerate ::
(B.CallStack.HasCallStack, MonadIO m, IsSocketConnectable a) =>
a
-> m Gio.SocketAddressEnumerator.SocketAddressEnumerator
socketConnectableProxyEnumerate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSocketConnectable a) =>
a -> m SocketAddressEnumerator
socketConnectableProxyEnumerate a
connectable = IO SocketAddressEnumerator -> m SocketAddressEnumerator
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketAddressEnumerator -> m SocketAddressEnumerator)
-> IO SocketAddressEnumerator -> m SocketAddressEnumerator
forall a b. (a -> b) -> a -> b
$ do
connectable' <- a -> IO (Ptr SocketConnectable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connectable
result <- g_socket_connectable_proxy_enumerate connectable'
checkUnexpectedReturnNULL "socketConnectableProxyEnumerate" result
result' <- (wrapObject Gio.SocketAddressEnumerator.SocketAddressEnumerator) result
touchManagedPtr connectable
return result'
#if defined(ENABLE_OVERLOADING)
data SocketConnectableProxyEnumerateMethodInfo
instance (signature ~ (m Gio.SocketAddressEnumerator.SocketAddressEnumerator), MonadIO m, IsSocketConnectable a) => O.OverloadedMethod SocketConnectableProxyEnumerateMethodInfo a signature where
overloadedMethod = socketConnectableProxyEnumerate
instance O.OverloadedMethodInfo SocketConnectableProxyEnumerateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.SocketConnectable.socketConnectableProxyEnumerate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Interfaces-SocketConnectable.html#v:socketConnectableProxyEnumerate"
})
#endif
foreign import ccall "g_socket_connectable_to_string" g_socket_connectable_to_string ::
Ptr SocketConnectable ->
IO CString
socketConnectableToString ::
(B.CallStack.HasCallStack, MonadIO m, IsSocketConnectable a) =>
a
-> m T.Text
socketConnectableToString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSocketConnectable a) =>
a -> m Text
socketConnectableToString a
connectable = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
connectable' <- a -> IO (Ptr SocketConnectable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connectable
result <- g_socket_connectable_to_string connectable'
checkUnexpectedReturnNULL "socketConnectableToString" result
result' <- cstringToText result
freeMem result
touchManagedPtr connectable
return result'
#if defined(ENABLE_OVERLOADING)
data SocketConnectableToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSocketConnectable a) => O.OverloadedMethod SocketConnectableToStringMethodInfo a signature where
overloadedMethod = socketConnectableToString
instance O.OverloadedMethodInfo SocketConnectableToStringMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.SocketConnectable.socketConnectableToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Interfaces-SocketConnectable.html#v:socketConnectableToString"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SocketConnectable = SocketConnectableSignalList
type SocketConnectableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif