{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Provides an interface for implementing seekable functionality on I\/O Streams.

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

module GI.Gio.Structs.SeekableIface
    ( 

-- * Exported types
    SeekableIface(..)                       ,
    newZeroSeekableIface                    ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveSeekableIfaceMethod              ,
#endif



 -- * Properties


-- ** canSeek #attr:canSeek#
-- | Checks if seeking is supported by the stream.

    clearSeekableIfaceCanSeek               ,
    getSeekableIfaceCanSeek                 ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_canSeek                   ,
#endif
    setSeekableIfaceCanSeek                 ,


-- ** canTruncate #attr:canTruncate#
-- | Checks if truncation is supported by the stream.

    clearSeekableIfaceCanTruncate           ,
    getSeekableIfaceCanTruncate             ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_canTruncate               ,
#endif
    setSeekableIfaceCanTruncate             ,


-- ** gIface #attr:gIface#
-- | The parent interface.

    getSeekableIfaceGIface                  ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_gIface                    ,
#endif


-- ** seek #attr:seek#
-- | Seeks to a location within a stream.

    clearSeekableIfaceSeek                  ,
    getSeekableIfaceSeek                    ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_seek                      ,
#endif
    setSeekableIfaceSeek                    ,


-- ** tell #attr:tell#
-- | Tells the current location within a stream.

    clearSeekableIfaceTell                  ,
    getSeekableIfaceTell                    ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_tell                      ,
#endif
    setSeekableIfaceTell                    ,


-- ** truncateFn #attr:truncateFn#
-- | Truncates a stream.

    clearSeekableIfaceTruncateFn            ,
    getSeekableIfaceTruncateFn              ,
#if defined(ENABLE_OVERLOADING)
    seekableIface_truncateFn                ,
#endif
    setSeekableIfaceTruncateFn              ,




    ) 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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Structs.TypeInterface as GObject.TypeInterface
import qualified GI.Gio.Callbacks as Gio.Callbacks

#else
import qualified GI.GObject.Structs.TypeInterface as GObject.TypeInterface
import qualified GI.Gio.Callbacks as Gio.Callbacks

#endif

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

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

instance BoxedPtr SeekableIface where
    boxedPtrCopy :: SeekableIface -> IO SeekableIface
boxedPtrCopy = \SeekableIface
p -> SeekableIface
-> (Ptr SeekableIface -> IO SeekableIface) -> IO SeekableIface
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SeekableIface
p (Int -> Ptr SeekableIface -> IO (Ptr SeekableIface)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
56 (Ptr SeekableIface -> IO (Ptr SeekableIface))
-> (Ptr SeekableIface -> IO SeekableIface)
-> Ptr SeekableIface
-> IO SeekableIface
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr SeekableIface -> SeekableIface)
-> Ptr SeekableIface -> IO SeekableIface
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr SeekableIface -> SeekableIface
SeekableIface)
    boxedPtrFree :: SeekableIface -> IO ()
boxedPtrFree = \SeekableIface
x -> SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr SeekableIface
x Ptr SeekableIface -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr SeekableIface where
    boxedPtrCalloc :: IO (Ptr SeekableIface)
boxedPtrCalloc = Int -> IO (Ptr SeekableIface)
forall a. Int -> IO (Ptr a)
callocBytes Int
56


-- | Construct a `SeekableIface` struct initialized to zero.
newZeroSeekableIface :: MonadIO m => m SeekableIface
newZeroSeekableIface :: forall (m :: * -> *). MonadIO m => m SeekableIface
newZeroSeekableIface = IO SeekableIface -> m SeekableIface
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SeekableIface -> m SeekableIface)
-> IO SeekableIface -> m SeekableIface
forall a b. (a -> b) -> a -> b
$ IO (Ptr SeekableIface)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr SeekableIface)
-> (Ptr SeekableIface -> IO SeekableIface) -> IO SeekableIface
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr SeekableIface -> SeekableIface)
-> Ptr SeekableIface -> IO SeekableIface
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr SeekableIface -> SeekableIface
SeekableIface

instance tag ~ 'AttrSet => Constructible SeekableIface tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr SeekableIface -> SeekableIface)
-> [AttrOp SeekableIface tag] -> m SeekableIface
new ManagedPtr SeekableIface -> SeekableIface
_ [AttrOp SeekableIface tag]
attrs = do
        SeekableIface
o <- m SeekableIface
forall (m :: * -> *). MonadIO m => m SeekableIface
newZeroSeekableIface
        SeekableIface -> [AttrOp SeekableIface 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set SeekableIface
o [AttrOp SeekableIface tag]
[AttrOp SeekableIface 'AttrSet]
attrs
        SeekableIface -> m SeekableIface
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIface
o


-- | Get the value of the “@g_iface@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #gIface
-- @
getSeekableIfaceGIface :: MonadIO m => SeekableIface -> m GObject.TypeInterface.TypeInterface
getSeekableIfaceGIface :: forall (m :: * -> *). MonadIO m => SeekableIface -> m TypeInterface
getSeekableIfaceGIface SeekableIface
s = IO TypeInterface -> m TypeInterface
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeInterface -> m TypeInterface)
-> IO TypeInterface -> m TypeInterface
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface -> IO TypeInterface) -> IO TypeInterface
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO TypeInterface) -> IO TypeInterface)
-> (Ptr SeekableIface -> IO TypeInterface) -> IO TypeInterface
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    let val :: Ptr TypeInterface
val = Ptr SeekableIface
ptr Ptr SeekableIface -> Int -> Ptr TypeInterface
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.TypeInterface.TypeInterface)
    TypeInterface
val' <- ((ManagedPtr TypeInterface -> TypeInterface)
-> Ptr TypeInterface -> IO TypeInterface
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInterface -> TypeInterface
GObject.TypeInterface.TypeInterface) Ptr TypeInterface
val
    TypeInterface -> IO TypeInterface
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeInterface
val'

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceGIfaceFieldInfo
instance AttrInfo SeekableIfaceGIfaceFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceGIfaceFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceGIfaceFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint SeekableIfaceGIfaceFieldInfo = (~) (Ptr GObject.TypeInterface.TypeInterface)
    type AttrTransferTypeConstraint SeekableIfaceGIfaceFieldInfo = (~)(Ptr GObject.TypeInterface.TypeInterface)
    type AttrTransferType SeekableIfaceGIfaceFieldInfo = (Ptr GObject.TypeInterface.TypeInterface)
    type AttrGetType SeekableIfaceGIfaceFieldInfo = GObject.TypeInterface.TypeInterface
    type AttrLabel SeekableIfaceGIfaceFieldInfo = "g_iface"
    type AttrOrigin SeekableIfaceGIfaceFieldInfo = SeekableIface
    attrGet = getSeekableIfaceGIface
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.gIface"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:gIface"
        })

seekableIface_gIface :: AttrLabelProxy "gIface"
seekableIface_gIface = AttrLabelProxy

#endif


-- | Get the value of the “@tell@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #tell
-- @
getSeekableIfaceTell :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceTellFieldCallback)
getSeekableIfaceTell :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> m (Maybe SeekableIfaceTellFieldCallback)
getSeekableIfaceTell SeekableIface
s = IO (Maybe SeekableIfaceTellFieldCallback)
-> m (Maybe SeekableIfaceTellFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SeekableIfaceTellFieldCallback)
 -> m (Maybe SeekableIfaceTellFieldCallback))
-> IO (Maybe SeekableIfaceTellFieldCallback)
-> m (Maybe SeekableIfaceTellFieldCallback)
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
-> IO (Maybe SeekableIfaceTellFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
 -> IO (Maybe SeekableIfaceTellFieldCallback))
-> (Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
-> IO (Maybe SeekableIfaceTellFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    FunPtr C_SeekableIfaceTellFieldCallback
val <- Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
-> IO (FunPtr C_SeekableIfaceTellFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
    Maybe SeekableIfaceTellFieldCallback
result <- FunPtr C_SeekableIfaceTellFieldCallback
-> (FunPtr C_SeekableIfaceTellFieldCallback
    -> IO SeekableIfaceTellFieldCallback)
-> IO (Maybe SeekableIfaceTellFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceTellFieldCallback
val ((FunPtr C_SeekableIfaceTellFieldCallback
  -> IO SeekableIfaceTellFieldCallback)
 -> IO (Maybe SeekableIfaceTellFieldCallback))
-> (FunPtr C_SeekableIfaceTellFieldCallback
    -> IO SeekableIfaceTellFieldCallback)
-> IO (Maybe SeekableIfaceTellFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_SeekableIfaceTellFieldCallback
val' -> do
        let val'' :: SeekableIfaceTellFieldCallback
val'' = FunPtr C_SeekableIfaceTellFieldCallback
-> SeekableIfaceTellFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceTellFieldCallback -> a -> m Int64
Gio.Callbacks.dynamic_SeekableIfaceTellFieldCallback FunPtr C_SeekableIfaceTellFieldCallback
val'
        SeekableIfaceTellFieldCallback -> IO SeekableIfaceTellFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIfaceTellFieldCallback
val''
    Maybe SeekableIfaceTellFieldCallback
-> IO (Maybe SeekableIfaceTellFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SeekableIfaceTellFieldCallback
result

-- | Set the value of the “@tell@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' seekableIface [ #tell 'Data.GI.Base.Attributes.:=' value ]
-- @
setSeekableIfaceTell :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback -> m ()
setSeekableIfaceTell :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> FunPtr C_SeekableIfaceTellFieldCallback -> m ()
setSeekableIfaceTell SeekableIface
s FunPtr C_SeekableIfaceTellFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
-> FunPtr C_SeekableIfaceTellFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_SeekableIfaceTellFieldCallback
val :: FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)

-- | Set the value of the “@tell@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #tell
-- @
clearSeekableIfaceTell :: MonadIO m => SeekableIface -> m ()
clearSeekableIfaceTell :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
clearSeekableIfaceTell SeekableIface
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
-> FunPtr C_SeekableIfaceTellFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_SeekableIfaceTellFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceTellFieldInfo
instance AttrInfo SeekableIfaceTellFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceTellFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceTellFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SeekableIfaceTellFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
    type AttrTransferTypeConstraint SeekableIfaceTellFieldInfo = (~)Gio.Callbacks.SeekableIfaceTellFieldCallback
    type AttrTransferType SeekableIfaceTellFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
    type AttrGetType SeekableIfaceTellFieldInfo = Maybe Gio.Callbacks.SeekableIfaceTellFieldCallback
    type AttrLabel SeekableIfaceTellFieldInfo = "tell"
    type AttrOrigin SeekableIfaceTellFieldInfo = SeekableIface
    attrGet = getSeekableIfaceTell
    attrSet = setSeekableIfaceTell
    attrConstruct = undefined
    attrClear = clearSeekableIfaceTell
    attrTransfer _ v = do
        Gio.Callbacks.mk_SeekableIfaceTellFieldCallback (Gio.Callbacks.wrap_SeekableIfaceTellFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.tell"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:tell"
        })

seekableIface_tell :: AttrLabelProxy "tell"
seekableIface_tell = AttrLabelProxy

#endif


-- | Get the value of the “@can_seek@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #canSeek
-- @
getSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceCanSeekFieldCallback)
getSeekableIfaceCanSeek :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> m (Maybe SeekableIfaceCanSeekFieldCallback)
getSeekableIfaceCanSeek SeekableIface
s = IO (Maybe SeekableIfaceCanSeekFieldCallback)
-> m (Maybe SeekableIfaceCanSeekFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SeekableIfaceCanSeekFieldCallback)
 -> m (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
-> m (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface
  -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
 -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    FunPtr C_SeekableIfaceCanSeekFieldCallback
val <- Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
    Maybe SeekableIfaceCanSeekFieldCallback
result <- FunPtr C_SeekableIfaceCanSeekFieldCallback
-> (FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback)
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceCanSeekFieldCallback
val ((FunPtr C_SeekableIfaceCanSeekFieldCallback
  -> IO SeekableIfaceCanSeekFieldCallback)
 -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> (FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback)
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_SeekableIfaceCanSeekFieldCallback
val' -> do
        let val'' :: SeekableIfaceCanSeekFieldCallback
val'' = FunPtr C_SeekableIfaceCanSeekFieldCallback
-> SeekableIfaceCanSeekFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceCanSeekFieldCallback -> a -> m Bool
Gio.Callbacks.dynamic_SeekableIfaceCanSeekFieldCallback FunPtr C_SeekableIfaceCanSeekFieldCallback
val'
        SeekableIfaceCanSeekFieldCallback
-> IO SeekableIfaceCanSeekFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIfaceCanSeekFieldCallback
val''
    Maybe SeekableIfaceCanSeekFieldCallback
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SeekableIfaceCanSeekFieldCallback
result

-- | Set the value of the “@can_seek@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' seekableIface [ #canSeek 'Data.GI.Base.Attributes.:=' value ]
-- @
setSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback -> m ()
setSeekableIfaceCanSeek :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> m ()
setSeekableIfaceCanSeek SeekableIface
s FunPtr C_SeekableIfaceCanSeekFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_SeekableIfaceCanSeekFieldCallback
val :: FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)

-- | Set the value of the “@can_seek@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #canSeek
-- @
clearSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> m ()
clearSeekableIfaceCanSeek :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
clearSeekableIfaceCanSeek SeekableIface
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_SeekableIfaceCanSeekFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceCanSeekFieldInfo
instance AttrInfo SeekableIfaceCanSeekFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceCanSeekFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceCanSeekFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SeekableIfaceCanSeekFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
    type AttrTransferTypeConstraint SeekableIfaceCanSeekFieldInfo = (~)Gio.Callbacks.SeekableIfaceCanSeekFieldCallback
    type AttrTransferType SeekableIfaceCanSeekFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
    type AttrGetType SeekableIfaceCanSeekFieldInfo = Maybe Gio.Callbacks.SeekableIfaceCanSeekFieldCallback
    type AttrLabel SeekableIfaceCanSeekFieldInfo = "can_seek"
    type AttrOrigin SeekableIfaceCanSeekFieldInfo = SeekableIface
    attrGet = getSeekableIfaceCanSeek
    attrSet = setSeekableIfaceCanSeek
    attrConstruct = undefined
    attrClear = clearSeekableIfaceCanSeek
    attrTransfer _ v = do
        Gio.Callbacks.mk_SeekableIfaceCanSeekFieldCallback (Gio.Callbacks.wrap_SeekableIfaceCanSeekFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.canSeek"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:canSeek"
        })

seekableIface_canSeek :: AttrLabelProxy "canSeek"
seekableIface_canSeek = AttrLabelProxy

#endif


-- | Get the value of the “@seek@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #seek
-- @
getSeekableIfaceSeek :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceSeekFieldCallback)
getSeekableIfaceSeek :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> m (Maybe SeekableIfaceSeekFieldCallback)
getSeekableIfaceSeek SeekableIface
s = IO (Maybe SeekableIfaceSeekFieldCallback)
-> m (Maybe SeekableIfaceSeekFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SeekableIfaceSeekFieldCallback)
 -> m (Maybe SeekableIfaceSeekFieldCallback))
-> IO (Maybe SeekableIfaceSeekFieldCallback)
-> m (Maybe SeekableIfaceSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
-> IO (Maybe SeekableIfaceSeekFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
 -> IO (Maybe SeekableIfaceSeekFieldCallback))
-> (Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
-> IO (Maybe SeekableIfaceSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    FunPtr C_SeekableIfaceSeekFieldCallback
val <- Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
-> IO (FunPtr C_SeekableIfaceSeekFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)
    Maybe SeekableIfaceSeekFieldCallback
result <- FunPtr C_SeekableIfaceSeekFieldCallback
-> (FunPtr C_SeekableIfaceSeekFieldCallback
    -> IO SeekableIfaceSeekFieldCallback)
-> IO (Maybe SeekableIfaceSeekFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceSeekFieldCallback
val ((FunPtr C_SeekableIfaceSeekFieldCallback
  -> IO SeekableIfaceSeekFieldCallback)
 -> IO (Maybe SeekableIfaceSeekFieldCallback))
-> (FunPtr C_SeekableIfaceSeekFieldCallback
    -> IO SeekableIfaceSeekFieldCallback)
-> IO (Maybe SeekableIfaceSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_SeekableIfaceSeekFieldCallback
val' -> do
        let val'' :: SeekableIfaceSeekFieldCallback
val'' = FunPtr C_SeekableIfaceSeekFieldCallback
-> SeekableIfaceSeekFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
FunPtr C_SeekableIfaceSeekFieldCallback
-> a -> Int64 -> SeekType -> Maybe b -> m ()
Gio.Callbacks.dynamic_SeekableIfaceSeekFieldCallback FunPtr C_SeekableIfaceSeekFieldCallback
val'
        SeekableIfaceSeekFieldCallback -> IO SeekableIfaceSeekFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIfaceSeekFieldCallback
val''
    Maybe SeekableIfaceSeekFieldCallback
-> IO (Maybe SeekableIfaceSeekFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SeekableIfaceSeekFieldCallback
result

-- | Set the value of the “@seek@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' seekableIface [ #seek 'Data.GI.Base.Attributes.:=' value ]
-- @
setSeekableIfaceSeek :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback -> m ()
setSeekableIfaceSeek :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> FunPtr C_SeekableIfaceSeekFieldCallback -> m ()
setSeekableIfaceSeek SeekableIface
s FunPtr C_SeekableIfaceSeekFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
-> FunPtr C_SeekableIfaceSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_SeekableIfaceSeekFieldCallback
val :: FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)

-- | Set the value of the “@seek@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #seek
-- @
clearSeekableIfaceSeek :: MonadIO m => SeekableIface -> m ()
clearSeekableIfaceSeek :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
clearSeekableIfaceSeek SeekableIface
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
-> FunPtr C_SeekableIfaceSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_SeekableIfaceSeekFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceSeekFieldInfo
instance AttrInfo SeekableIfaceSeekFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceSeekFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceSeekFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SeekableIfaceSeekFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)
    type AttrTransferTypeConstraint SeekableIfaceSeekFieldInfo = (~)(FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)
    type AttrTransferType SeekableIfaceSeekFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)
    type AttrGetType SeekableIfaceSeekFieldInfo = Maybe Gio.Callbacks.SeekableIfaceSeekFieldCallback
    type AttrLabel SeekableIfaceSeekFieldInfo = "seek"
    type AttrOrigin SeekableIfaceSeekFieldInfo = SeekableIface
    attrGet = getSeekableIfaceSeek
    attrSet = setSeekableIfaceSeek
    attrConstruct = undefined
    attrClear = clearSeekableIfaceSeek
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.seek"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:seek"
        })

seekableIface_seek :: AttrLabelProxy "seek"
seekableIface_seek = AttrLabelProxy

#endif


-- | Get the value of the “@can_truncate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #canTruncate
-- @
getSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback)
getSeekableIfaceCanTruncate :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> m (Maybe SeekableIfaceCanSeekFieldCallback)
getSeekableIfaceCanTruncate SeekableIface
s = IO (Maybe SeekableIfaceCanSeekFieldCallback)
-> m (Maybe SeekableIfaceCanSeekFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SeekableIfaceCanSeekFieldCallback)
 -> m (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
-> m (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface
  -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
 -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    FunPtr C_SeekableIfaceCanSeekFieldCallback
val <- Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
    Maybe SeekableIfaceCanSeekFieldCallback
result <- FunPtr C_SeekableIfaceCanSeekFieldCallback
-> (FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback)
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceCanSeekFieldCallback
val ((FunPtr C_SeekableIfaceCanSeekFieldCallback
  -> IO SeekableIfaceCanSeekFieldCallback)
 -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
-> (FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback)
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_SeekableIfaceCanSeekFieldCallback
val' -> do
        let val'' :: SeekableIfaceCanSeekFieldCallback
val'' = FunPtr C_SeekableIfaceCanSeekFieldCallback
-> SeekableIfaceCanSeekFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceCanSeekFieldCallback -> a -> m Bool
Gio.Callbacks.dynamic_SeekableIfaceCanTruncateFieldCallback FunPtr C_SeekableIfaceCanSeekFieldCallback
val'
        SeekableIfaceCanSeekFieldCallback
-> IO SeekableIfaceCanSeekFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIfaceCanSeekFieldCallback
val''
    Maybe SeekableIfaceCanSeekFieldCallback
-> IO (Maybe SeekableIfaceCanSeekFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SeekableIfaceCanSeekFieldCallback
result

-- | Set the value of the “@can_truncate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' seekableIface [ #canTruncate 'Data.GI.Base.Attributes.:=' value ]
-- @
setSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback -> m ()
setSeekableIfaceCanTruncate :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> m ()
setSeekableIfaceCanTruncate SeekableIface
s FunPtr C_SeekableIfaceCanSeekFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_SeekableIfaceCanSeekFieldCallback
val :: FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)

-- | Set the value of the “@can_truncate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #canTruncate
-- @
clearSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> m ()
clearSeekableIfaceCanTruncate :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
clearSeekableIfaceCanTruncate SeekableIface
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
-> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_SeekableIfaceCanSeekFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceCanTruncateFieldInfo
instance AttrInfo SeekableIfaceCanTruncateFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceCanTruncateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
    type AttrTransferTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~)Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback
    type AttrTransferType SeekableIfaceCanTruncateFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
    type AttrGetType SeekableIfaceCanTruncateFieldInfo = Maybe Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback
    type AttrLabel SeekableIfaceCanTruncateFieldInfo = "can_truncate"
    type AttrOrigin SeekableIfaceCanTruncateFieldInfo = SeekableIface
    attrGet = getSeekableIfaceCanTruncate
    attrSet = setSeekableIfaceCanTruncate
    attrConstruct = undefined
    attrClear = clearSeekableIfaceCanTruncate
    attrTransfer _ v = do
        Gio.Callbacks.mk_SeekableIfaceCanTruncateFieldCallback (Gio.Callbacks.wrap_SeekableIfaceCanTruncateFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.canTruncate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:canTruncate"
        })

seekableIface_canTruncate :: AttrLabelProxy "canTruncate"
seekableIface_canTruncate = AttrLabelProxy

#endif


-- | Get the value of the “@truncate_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' seekableIface #truncateFn
-- @
getSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceTruncateFnFieldCallback)
getSeekableIfaceTruncateFn :: forall (m :: * -> *).
MonadIO m =>
SeekableIface -> m (Maybe SeekableIfaceTruncateFnFieldCallback)
getSeekableIfaceTruncateFn SeekableIface
s = IO (Maybe SeekableIfaceTruncateFnFieldCallback)
-> m (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SeekableIfaceTruncateFnFieldCallback)
 -> m (Maybe SeekableIfaceTruncateFnFieldCallback))
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
-> m (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ SeekableIface
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface
  -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
 -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
-> (Ptr SeekableIface
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    FunPtr C_SeekableIfaceTruncateFnFieldCallback
val <- Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
-> IO (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)
    Maybe SeekableIfaceTruncateFnFieldCallback
result <- FunPtr C_SeekableIfaceTruncateFnFieldCallback
-> (FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> IO SeekableIfaceTruncateFnFieldCallback)
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceTruncateFnFieldCallback
val ((FunPtr C_SeekableIfaceTruncateFnFieldCallback
  -> IO SeekableIfaceTruncateFnFieldCallback)
 -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
-> (FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> IO SeekableIfaceTruncateFnFieldCallback)
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_SeekableIfaceTruncateFnFieldCallback
val' -> do
        let val'' :: SeekableIfaceTruncateFnFieldCallback
val'' = FunPtr C_SeekableIfaceTruncateFnFieldCallback
-> SeekableIfaceTruncateFnFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
FunPtr C_SeekableIfaceTruncateFnFieldCallback
-> a -> Int64 -> Maybe b -> m ()
Gio.Callbacks.dynamic_SeekableIfaceTruncateFnFieldCallback FunPtr C_SeekableIfaceTruncateFnFieldCallback
val'
        SeekableIfaceTruncateFnFieldCallback
-> IO SeekableIfaceTruncateFnFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SeekableIfaceTruncateFnFieldCallback
val''
    Maybe SeekableIfaceTruncateFnFieldCallback
-> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SeekableIfaceTruncateFnFieldCallback
result

-- | Set the value of the “@truncate_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' seekableIface [ #truncateFn 'Data.GI.Base.Attributes.:=' value ]
-- @
setSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback -> m ()
setSeekableIfaceTruncateFn :: forall (m :: * -> *).
MonadIO m =>
SeekableIface
-> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> m ()
setSeekableIfaceTruncateFn SeekableIface
s FunPtr C_SeekableIfaceTruncateFnFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
-> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (FunPtr C_SeekableIfaceTruncateFnFieldCallback
val :: FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)

-- | Set the value of the “@truncate_fn@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #truncateFn
-- @
clearSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> m ()
clearSeekableIfaceTruncateFn :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
clearSeekableIfaceTruncateFn SeekableIface
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SeekableIface
s ((Ptr SeekableIface -> IO ()) -> IO ())
-> (Ptr SeekableIface -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SeekableIface
ptr -> do
    Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
-> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SeekableIface
ptr Ptr SeekableIface
-> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (FunPtr C_SeekableIfaceTruncateFnFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)

#if defined(ENABLE_OVERLOADING)
data SeekableIfaceTruncateFnFieldInfo
instance AttrInfo SeekableIfaceTruncateFnFieldInfo where
    type AttrBaseTypeConstraint SeekableIfaceTruncateFnFieldInfo = (~) SeekableIface
    type AttrAllowedOps SeekableIfaceTruncateFnFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SeekableIfaceTruncateFnFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)
    type AttrTransferTypeConstraint SeekableIfaceTruncateFnFieldInfo = (~)(FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)
    type AttrTransferType SeekableIfaceTruncateFnFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)
    type AttrGetType SeekableIfaceTruncateFnFieldInfo = Maybe Gio.Callbacks.SeekableIfaceTruncateFnFieldCallback
    type AttrLabel SeekableIfaceTruncateFnFieldInfo = "truncate_fn"
    type AttrOrigin SeekableIfaceTruncateFnFieldInfo = SeekableIface
    attrGet = getSeekableIfaceTruncateFn
    attrSet = setSeekableIfaceTruncateFn
    attrConstruct = undefined
    attrClear = clearSeekableIfaceTruncateFn
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.truncateFn"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.34/docs/GI-Gio-Structs-SeekableIface.html#g:attr:truncateFn"
        })

seekableIface_truncateFn :: AttrLabelProxy "truncateFn"
seekableIface_truncateFn = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SeekableIface
type instance O.AttributeList SeekableIface = SeekableIfaceAttributeList
type SeekableIfaceAttributeList = ('[ '("gIface", SeekableIfaceGIfaceFieldInfo), '("tell", SeekableIfaceTellFieldInfo), '("canSeek", SeekableIfaceCanSeekFieldInfo), '("seek", SeekableIfaceSeekFieldInfo), '("canTruncate", SeekableIfaceCanTruncateFieldInfo), '("truncateFn", SeekableIfaceTruncateFnFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveSeekableIfaceMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSeekableIfaceMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif