{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An t'GI.IBus.Objects.Serializable.Serializable' is an IBus object which can be serialized, that is,
-- to be to and from a t'GVariant'.
-- 
-- This class is to be extended by other class that requires serialization.
-- An extended class should overrides following methods:
-- \<itemizedlist>
--    \<listitem>
--       \<para>\<function>serialize(object,iter)\<\/function>: for serialize.\<\/para>
--    \<\/listitem>
--    \<listitem>
--       \<para>\<function>deserialize(object,iter)\<\/function>: for deserialize.\<\/para>
--    \<\/listitem>
--    \<listitem>
--       \<para>\<function>copy(desc,src)\<\/function>: for copy between IBusSerializable.\<\/para>
--    \<\/listitem>
-- \<\/itemizedlist>
-- See @/IBusSerializableSerializeFunc()/@, @/IBusSerializableDeserializeFunc()/@, @/IBusSerializableCopyFunc()/@
-- for function prototype.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.IBus.Objects.Serializable
    ( 

-- * Exported types
    Serializable(..)                        ,
    IsSerializable                          ,
    toSerializable                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [copy]("GI.IBus.Objects.Serializable#g:method:copy"), [destroy]("GI.IBus.Objects.Object#g:method:destroy"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeQattachment]("GI.IBus.Objects.Serializable#g:method:removeQattachment"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [serializeObject]("GI.IBus.Objects.Serializable#g:method:serializeObject"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQattachment]("GI.IBus.Objects.Serializable#g:method:getQattachment"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setQattachment]("GI.IBus.Objects.Serializable#g:method:setQattachment").

#if defined(ENABLE_OVERLOADING)
    ResolveSerializableMethod               ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    SerializableCopyMethodInfo              ,
#endif
    serializableCopy                        ,


-- ** deserializeObject #method:deserializeObject#

    serializableDeserializeObject           ,


-- ** getQattachment #method:getQattachment#

#if defined(ENABLE_OVERLOADING)
    SerializableGetQattachmentMethodInfo    ,
#endif
    serializableGetQattachment              ,


-- ** new #method:new#

    serializableNew                         ,


-- ** removeQattachment #method:removeQattachment#

#if defined(ENABLE_OVERLOADING)
    SerializableRemoveQattachmentMethodInfo ,
#endif
    serializableRemoveQattachment           ,


-- ** serializeObject #method:serializeObject#

#if defined(ENABLE_OVERLOADING)
    SerializableSerializeObjectMethodInfo   ,
#endif
    serializableSerializeObject             ,


-- ** setQattachment #method:setQattachment#

#if defined(ENABLE_OVERLOADING)
    SerializableSetQattachmentMethodInfo    ,
#endif
    serializableSetQattachment              ,




    ) 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.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.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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.Object as IBus.Object

-- | Memory-managed wrapper type.
newtype Serializable = Serializable (SP.ManagedPtr Serializable)
    deriving (Serializable -> Serializable -> Bool
(Serializable -> Serializable -> Bool)
-> (Serializable -> Serializable -> Bool) -> Eq Serializable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Serializable -> Serializable -> Bool
$c/= :: Serializable -> Serializable -> Bool
== :: Serializable -> Serializable -> Bool
$c== :: Serializable -> Serializable -> Bool
Eq)

instance SP.ManagedPtrNewtype Serializable where
    toManagedPtr :: Serializable -> ManagedPtr Serializable
toManagedPtr (Serializable ManagedPtr Serializable
p) = ManagedPtr Serializable
p

foreign import ccall "ibus_serializable_get_type"
    c_ibus_serializable_get_type :: IO B.Types.GType

instance B.Types.TypedObject Serializable where
    glibType :: IO GType
glibType = IO GType
c_ibus_serializable_get_type

instance B.Types.GObject Serializable

-- | Type class for types which can be safely cast to `Serializable`, for instance with `toSerializable`.
class (SP.GObject o, O.IsDescendantOf Serializable o) => IsSerializable o
instance (SP.GObject o, O.IsDescendantOf Serializable o) => IsSerializable o

instance O.HasParentTypes Serializable
type instance O.ParentTypes Serializable = '[IBus.Object.Object, GObject.Object.Object]

-- | Cast to `Serializable`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toSerializable :: (MIO.MonadIO m, IsSerializable o) => o -> m Serializable
toSerializable :: forall (m :: * -> *) o.
(MonadIO m, IsSerializable o) =>
o -> m Serializable
toSerializable = IO Serializable -> m Serializable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Serializable -> m Serializable)
-> (o -> IO Serializable) -> o -> m Serializable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Serializable -> Serializable) -> o -> IO Serializable
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Serializable -> Serializable
Serializable

-- | Convert 'Serializable' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Serializable) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_serializable_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Serializable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Serializable
P.Nothing = Ptr GValue -> Ptr Serializable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Serializable
forall a. Ptr a
FP.nullPtr :: FP.Ptr Serializable)
    gvalueSet_ Ptr GValue
gv (P.Just Serializable
obj) = Serializable -> (Ptr Serializable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Serializable
obj (Ptr GValue -> Ptr Serializable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Serializable)
gvalueGet_ Ptr GValue
gv = do
        Ptr Serializable
ptr <- Ptr GValue -> IO (Ptr Serializable)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Serializable)
        if Ptr Serializable
ptr Ptr Serializable -> Ptr Serializable -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Serializable
forall a. Ptr a
FP.nullPtr
        then Serializable -> Maybe Serializable
forall a. a -> Maybe a
P.Just (Serializable -> Maybe Serializable)
-> IO Serializable -> IO (Maybe Serializable)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Serializable -> Serializable)
-> Ptr Serializable -> IO Serializable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Serializable -> Serializable
Serializable Ptr Serializable
ptr
        else Maybe Serializable -> IO (Maybe Serializable)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Serializable
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSerializableMethod (t :: Symbol) (o :: *) :: * where
    ResolveSerializableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSerializableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSerializableMethod "copy" o = SerializableCopyMethodInfo
    ResolveSerializableMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
    ResolveSerializableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSerializableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSerializableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSerializableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSerializableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSerializableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSerializableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSerializableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSerializableMethod "removeQattachment" o = SerializableRemoveQattachmentMethodInfo
    ResolveSerializableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSerializableMethod "serializeObject" o = SerializableSerializeObjectMethodInfo
    ResolveSerializableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSerializableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSerializableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSerializableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSerializableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSerializableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSerializableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSerializableMethod "getQattachment" o = SerializableGetQattachmentMethodInfo
    ResolveSerializableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSerializableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSerializableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSerializableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSerializableMethod "setQattachment" o = SerializableSetQattachmentMethodInfo
    ResolveSerializableMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSerializableMethod t Serializable, O.OverloadedMethod info Serializable p) => OL.IsLabel t (Serializable -> 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 ~ ResolveSerializableMethod t Serializable, O.OverloadedMethod info Serializable p, R.HasField t Serializable p) => R.HasField t Serializable p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveSerializableMethod t Serializable, O.OverloadedMethodInfo info Serializable) => OL.IsLabel t (O.MethodProxy info Serializable) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Serializable
type instance O.AttributeList Serializable = SerializableAttributeList
type SerializableAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Serializable = SerializableSignalList
type SerializableSignalList = ('[ '("destroy", IBus.Object.ObjectDestroySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Serializable::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "Serializable" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_new" ibus_serializable_new :: 
    IO (Ptr Serializable)

-- | Creates a new instance of an t'GI.IBus.Objects.Serializable.Serializable'.
serializableNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Serializable
    -- ^ __Returns:__ a new instance of t'GI.IBus.Objects.Serializable.Serializable'.
serializableNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Serializable
serializableNew  = IO Serializable -> m Serializable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Serializable -> m Serializable)
-> IO Serializable -> m Serializable
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
result <- IO (Ptr Serializable)
ibus_serializable_new
    Text -> Ptr Serializable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializableNew" Ptr Serializable
result
    Serializable
result' <- ((ManagedPtr Serializable -> Serializable)
-> Ptr Serializable -> IO Serializable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Serializable -> Serializable
Serializable) Ptr Serializable
result
    Serializable -> IO Serializable
forall (m :: * -> *) a. Monad m => a -> m a
return Serializable
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Serializable::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializable"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Serializable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusSerializable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "Serializable" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_copy" ibus_serializable_copy :: 
    Ptr Serializable ->                     -- serializable : TInterface (Name {namespace = "IBus", name = "Serializable"})
    IO (Ptr Serializable)

-- | Clone an t'GI.IBus.Objects.Serializable.Serializable'.
-- The copy method should be implemented in extended class.
serializableCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsSerializable a) =>
    a
    -- ^ /@serializable@/: An t'GI.IBus.Objects.Serializable.Serializable'.
    -> m Serializable
    -- ^ __Returns:__ A newly allocated clone object; or 'P.Nothing'
    --     if /@object@/ is not serializable.
    -- 
    -- See also: @/IBusSerializableCopyFunc()/@.
serializableCopy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSerializable a) =>
a -> m Serializable
serializableCopy a
serializable = IO Serializable -> m Serializable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Serializable -> m Serializable)
-> IO Serializable -> m Serializable
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
serializable' <- a -> IO (Ptr Serializable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializable
    Ptr Serializable
result <- Ptr Serializable -> IO (Ptr Serializable)
ibus_serializable_copy Ptr Serializable
serializable'
    Text -> Ptr Serializable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializableCopy" Ptr Serializable
result
    Serializable
result' <- ((ManagedPtr Serializable -> Serializable)
-> Ptr Serializable -> IO Serializable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Serializable -> Serializable
Serializable) Ptr Serializable
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializable
    Serializable -> IO Serializable
forall (m :: * -> *) a. Monad m => a -> m a
return Serializable
result'

#if defined(ENABLE_OVERLOADING)
data SerializableCopyMethodInfo
instance (signature ~ (m Serializable), MonadIO m, IsSerializable a) => O.OverloadedMethod SerializableCopyMethodInfo a signature where
    overloadedMethod = serializableCopy

instance O.OverloadedMethodInfo SerializableCopyMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.Serializable.serializableCopy",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Serializable.html#v:serializableCopy"
        }


#endif

-- method Serializable::get_qattachment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializable"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Serializable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusSerializable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "String formatted key for indexing value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_get_qattachment" ibus_serializable_get_qattachment :: 
    Ptr Serializable ->                     -- serializable : TInterface (Name {namespace = "IBus", name = "Serializable"})
    Word32 ->                               -- key : TBasicType TUInt32
    IO (Ptr GVariant)

-- | Gets a value from attachment of an t'GI.IBus.Objects.Serializable.Serializable'.
serializableGetQattachment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSerializable a) =>
    a
    -- ^ /@serializable@/: An t'GI.IBus.Objects.Serializable.Serializable'.
    -> Word32
    -- ^ /@key@/: String formatted key for indexing value.
    -> m GVariant
    -- ^ __Returns:__ The attached value; or 'P.Nothing' if fail to retrieve the value.
    -- 
    -- See also: @/ibus_serializable_set_attachment()/@.
serializableGetQattachment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSerializable a) =>
a -> Word32 -> m GVariant
serializableGetQattachment a
serializable Word32
key = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
serializable' <- a -> IO (Ptr Serializable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializable
    Ptr GVariant
result <- Ptr Serializable -> Word32 -> IO (Ptr GVariant)
ibus_serializable_get_qattachment Ptr Serializable
serializable' Word32
key
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializableGetQattachment" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializable
    GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if defined(ENABLE_OVERLOADING)
data SerializableGetQattachmentMethodInfo
instance (signature ~ (Word32 -> m GVariant), MonadIO m, IsSerializable a) => O.OverloadedMethod SerializableGetQattachmentMethodInfo a signature where
    overloadedMethod = serializableGetQattachment

instance O.OverloadedMethodInfo SerializableGetQattachmentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.Serializable.serializableGetQattachment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Serializable.html#v:serializableGetQattachment"
        }


#endif

-- method Serializable::remove_qattachment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializable"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Serializable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusSerializable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "String formatted key for indexing value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_remove_qattachment" ibus_serializable_remove_qattachment :: 
    Ptr Serializable ->                     -- serializable : TInterface (Name {namespace = "IBus", name = "Serializable"})
    Word32 ->                               -- key : TBasicType TUInt32
    IO ()

-- | Remove a value from attachment of an t'GI.IBus.Objects.Serializable.Serializable'.
-- See also: @/ibus_serializable_remove_attachment()/@.
serializableRemoveQattachment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSerializable a) =>
    a
    -- ^ /@serializable@/: An t'GI.IBus.Objects.Serializable.Serializable'.
    -> Word32
    -- ^ /@key@/: String formatted key for indexing value.
    -> m ()
serializableRemoveQattachment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSerializable a) =>
a -> Word32 -> m ()
serializableRemoveQattachment a
serializable Word32
key = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
serializable' <- a -> IO (Ptr Serializable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializable
    Ptr Serializable -> Word32 -> IO ()
ibus_serializable_remove_qattachment Ptr Serializable
serializable' Word32
key
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializable
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SerializableRemoveQattachmentMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSerializable a) => O.OverloadedMethod SerializableRemoveQattachmentMethodInfo a signature where
    overloadedMethod = serializableRemoveQattachment

instance O.OverloadedMethodInfo SerializableRemoveQattachmentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.Serializable.serializableRemoveQattachment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Serializable.html#v:serializableRemoveQattachment"
        }


#endif

-- method Serializable::serialize_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializable"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Serializable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusSerializable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_serialize_object" ibus_serializable_serialize_object :: 
    Ptr Serializable ->                     -- serializable : TInterface (Name {namespace = "IBus", name = "Serializable"})
    IO (Ptr GVariant)

-- | Serialize an t'GI.IBus.Objects.Serializable.Serializable' to a t'GVariant'.
-- The serialize method should be implemented in extended class.
serializableSerializeObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsSerializable a) =>
    a
    -- ^ /@serializable@/: An t'GI.IBus.Objects.Serializable.Serializable'.
    -> m GVariant
    -- ^ __Returns:__ A t'GVariant'.
    -- 
    -- See also: @/IBusSerializableCopyFunc()/@.
serializableSerializeObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSerializable a) =>
a -> m GVariant
serializableSerializeObject a
serializable = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
serializable' <- a -> IO (Ptr Serializable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializable
    Ptr GVariant
result <- Ptr Serializable -> IO (Ptr GVariant)
ibus_serializable_serialize_object Ptr Serializable
serializable'
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializableSerializeObject" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializable
    GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if defined(ENABLE_OVERLOADING)
data SerializableSerializeObjectMethodInfo
instance (signature ~ (m GVariant), MonadIO m, IsSerializable a) => O.OverloadedMethod SerializableSerializeObjectMethodInfo a signature where
    overloadedMethod = serializableSerializeObject

instance O.OverloadedMethodInfo SerializableSerializeObjectMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.Serializable.serializableSerializeObject",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Serializable.html#v:serializableSerializeObject"
        }


#endif

-- method Serializable::set_qattachment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializable"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Serializable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusSerializable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "String formatted key for indexing value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Value to be attached or %NULL to remove any prevoius value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_set_qattachment" ibus_serializable_set_qattachment :: 
    Ptr Serializable ->                     -- serializable : TInterface (Name {namespace = "IBus", name = "Serializable"})
    Word32 ->                               -- key : TBasicType TUInt32
    Ptr GVariant ->                         -- value : TVariant
    IO ()

-- | Attach a value to an t'GI.IBus.Objects.Serializable.Serializable'. If the value is floating,
-- the serializable will take the ownership.
-- 
-- See also: @/ibus_serializable_set_attachment()/@.
serializableSetQattachment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSerializable a) =>
    a
    -- ^ /@serializable@/: An t'GI.IBus.Objects.Serializable.Serializable'.
    -> Word32
    -- ^ /@key@/: String formatted key for indexing value.
    -> GVariant
    -- ^ /@value@/: Value to be attached or 'P.Nothing' to remove any prevoius value.
    -> m ()
serializableSetQattachment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSerializable a) =>
a -> Word32 -> GVariant -> m ()
serializableSetQattachment a
serializable Word32
key GVariant
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Serializable
serializable' <- a -> IO (Ptr Serializable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializable
    Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    Ptr Serializable -> Word32 -> Ptr GVariant -> IO ()
ibus_serializable_set_qattachment Ptr Serializable
serializable' Word32
key Ptr GVariant
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializable
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SerializableSetQattachmentMethodInfo
instance (signature ~ (Word32 -> GVariant -> m ()), MonadIO m, IsSerializable a) => O.OverloadedMethod SerializableSetQattachmentMethodInfo a signature where
    overloadedMethod = serializableSetQattachment

instance O.OverloadedMethodInfo SerializableSetQattachmentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.Serializable.serializableSetQattachment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Serializable.html#v:serializableSetQattachment"
        }


#endif

-- method Serializable::deserialize_object
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "variant"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GVariant." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "Serializable" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_serializable_deserialize_object" ibus_serializable_deserialize_object :: 
    Ptr GVariant ->                         -- variant : TVariant
    IO (Ptr Serializable)

-- | Deserialize a t'GVariant' to an t'GI.IBus.Objects.Serializable.Serializable'\/
-- The deserialize method should be implemented in extended class.
serializableDeserializeObject ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GVariant
    -- ^ /@variant@/: A t'GVariant'.
    -> m Serializable
    -- ^ __Returns:__ The deserialized t'GI.IBus.Objects.Serializable.Serializable'.
    -- 
    -- See also: @/IBusSerializableCopyFunc()/@.
serializableDeserializeObject :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Serializable
serializableDeserializeObject GVariant
variant = IO Serializable -> m Serializable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Serializable -> m Serializable)
-> IO Serializable -> m Serializable
forall a b. (a -> b) -> a -> b
$ do
    Ptr GVariant
variant' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
    Ptr Serializable
result <- Ptr GVariant -> IO (Ptr Serializable)
ibus_serializable_deserialize_object Ptr GVariant
variant'
    Text -> Ptr Serializable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializableDeserializeObject" Ptr Serializable
result
    Serializable
result' <- ((ManagedPtr Serializable -> Serializable)
-> Ptr Serializable -> IO Serializable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Serializable -> Serializable
Serializable) Ptr Serializable
result
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
    Serializable -> IO Serializable
forall (m :: * -> *) a. Monad m => a -> m a
return Serializable
result'

#if defined(ENABLE_OVERLOADING)
#endif