{-# 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
-- ** Overloaded methods #method:Overloaded methods#

#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.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 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

-- | Convert 'Serializable' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Serializable where
    toGValue :: Serializable -> IO GValue
toGValue Serializable
o = do
        GType
gtype <- IO GType
c_ibus_serializable_get_type
        Serializable -> (Ptr Serializable -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Serializable
o (GType
-> (GValue -> Ptr Serializable -> IO ())
-> Ptr Serializable
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Serializable -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Serializable
fromGValue GValue
gv = do
        Ptr Serializable
ptr <- GValue -> IO (Ptr Serializable)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Serializable)
        (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
        
    

-- | 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 :: (MonadIO m, IsSerializable o) => o -> m Serializable
toSerializable :: o -> m Serializable
toSerializable = IO Serializable -> m Serializable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr Serializable -> Serializable
Serializable

#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.MethodInfo 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

#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 :: 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 :: 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.MethodInfo SerializableCopyMethodInfo a signature where
    overloadedMethod = 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 :: 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.MethodInfo SerializableGetQattachmentMethodInfo a signature where
    overloadedMethod = 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 :: 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.MethodInfo SerializableRemoveQattachmentMethodInfo a signature where
    overloadedMethod = 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 :: 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.MethodInfo SerializableSerializeObjectMethodInfo a signature where
    overloadedMethod = 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 :: 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.MethodInfo SerializableSetQattachmentMethodInfo a signature where
    overloadedMethod = 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 :: 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