{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Defines a Unix mount point (e.g. \<filename>\/dev\<\/filename>).
-- This corresponds roughly to a fstab entry.

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

module GI.Gio.Structs.UnixMountPoint
    ( 

-- * Exported types
    UnixMountPoint(..)                      ,
    noUnixMountPoint                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveUnixMountPointMethod             ,
#endif


-- ** compare #method:compare#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointCompareMethodInfo         ,
#endif
    unixMountPointCompare                   ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointCopyMethodInfo            ,
#endif
    unixMountPointCopy                      ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointFreeMethodInfo            ,
#endif
    unixMountPointFree                      ,


-- ** getDevicePath #method:getDevicePath#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGetDevicePathMethodInfo   ,
#endif
    unixMountPointGetDevicePath             ,


-- ** getFsType #method:getFsType#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGetFsTypeMethodInfo       ,
#endif
    unixMountPointGetFsType                 ,


-- ** getMountPath #method:getMountPath#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGetMountPathMethodInfo    ,
#endif
    unixMountPointGetMountPath              ,


-- ** getOptions #method:getOptions#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGetOptionsMethodInfo      ,
#endif
    unixMountPointGetOptions                ,


-- ** guessCanEject #method:guessCanEject#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGuessCanEjectMethodInfo   ,
#endif
    unixMountPointGuessCanEject             ,


-- ** guessIcon #method:guessIcon#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGuessIconMethodInfo       ,
#endif
    unixMountPointGuessIcon                 ,


-- ** guessName #method:guessName#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGuessNameMethodInfo       ,
#endif
    unixMountPointGuessName                 ,


-- ** guessSymbolicIcon #method:guessSymbolicIcon#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointGuessSymbolicIconMethodInfo,
#endif
    unixMountPointGuessSymbolicIcon         ,


-- ** isLoopback #method:isLoopback#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointIsLoopbackMethodInfo      ,
#endif
    unixMountPointIsLoopback                ,


-- ** isReadonly #method:isReadonly#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointIsReadonlyMethodInfo      ,
#endif
    unixMountPointIsReadonly                ,


-- ** isUserMountable #method:isUserMountable#

#if defined(ENABLE_OVERLOADING)
    UnixMountPointIsUserMountableMethodInfo ,
#endif
    unixMountPointIsUserMountable           ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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 {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon

-- | Memory-managed wrapper type.
newtype UnixMountPoint = UnixMountPoint (ManagedPtr UnixMountPoint)
    deriving (UnixMountPoint -> UnixMountPoint -> Bool
(UnixMountPoint -> UnixMountPoint -> Bool)
-> (UnixMountPoint -> UnixMountPoint -> Bool) -> Eq UnixMountPoint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnixMountPoint -> UnixMountPoint -> Bool
$c/= :: UnixMountPoint -> UnixMountPoint -> Bool
== :: UnixMountPoint -> UnixMountPoint -> Bool
$c== :: UnixMountPoint -> UnixMountPoint -> Bool
Eq)
foreign import ccall "g_unix_mount_point_get_type" c_g_unix_mount_point_get_type :: 
    IO GType

instance BoxedObject UnixMountPoint where
    boxedType :: UnixMountPoint -> IO GType
boxedType _ = IO GType
c_g_unix_mount_point_get_type

-- | Convert 'UnixMountPoint' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue UnixMountPoint where
    toGValue :: UnixMountPoint -> IO GValue
toGValue o :: UnixMountPoint
o = do
        GType
gtype <- IO GType
c_g_unix_mount_point_get_type
        UnixMountPoint -> (Ptr UnixMountPoint -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnixMountPoint
o (GType
-> (GValue -> Ptr UnixMountPoint -> IO ())
-> Ptr UnixMountPoint
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr UnixMountPoint -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO UnixMountPoint
fromGValue gv :: GValue
gv = do
        Ptr UnixMountPoint
ptr <- GValue -> IO (Ptr UnixMountPoint)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr UnixMountPoint)
        (ManagedPtr UnixMountPoint -> UnixMountPoint)
-> Ptr UnixMountPoint -> IO UnixMountPoint
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr UnixMountPoint -> UnixMountPoint
UnixMountPoint Ptr UnixMountPoint
ptr
        
    

-- | A convenience alias for `Nothing` :: `Maybe` `UnixMountPoint`.
noUnixMountPoint :: Maybe UnixMountPoint
noUnixMountPoint :: Maybe UnixMountPoint
noUnixMountPoint = Maybe UnixMountPoint
forall a. Maybe a
Nothing


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

-- method UnixMountPoint::compare
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount1"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMount." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mount2"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMount." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_compare" g_unix_mount_point_compare :: 
    Ptr UnixMountPoint ->                   -- mount1 : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    Ptr UnixMountPoint ->                   -- mount2 : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO Int32

-- | Compares two unix mount points.
unixMountPointCompare ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mount1@/: a @/GUnixMount/@.
    -> UnixMountPoint
    -- ^ /@mount2@/: a @/GUnixMount/@.
    -> m Int32
    -- ^ __Returns:__ 1, 0 or -1 if /@mount1@/ is greater than, equal to,
    -- or less than /@mount2@/, respectively.
unixMountPointCompare :: UnixMountPoint -> UnixMountPoint -> m Int32
unixMountPointCompare mount1 :: UnixMountPoint
mount1 mount2 :: UnixMountPoint
mount2 = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mount1' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mount1
    Ptr UnixMountPoint
mount2' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mount2
    Int32
result <- Ptr UnixMountPoint -> Ptr UnixMountPoint -> IO Int32
g_unix_mount_point_compare Ptr UnixMountPoint
mount1' Ptr UnixMountPoint
mount2'
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mount1
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mount2
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data UnixMountPointCompareMethodInfo
instance (signature ~ (UnixMountPoint -> m Int32), MonadIO m) => O.MethodInfo UnixMountPointCompareMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointCompare

#endif

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

foreign import ccall "g_unix_mount_point_copy" g_unix_mount_point_copy :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO (Ptr UnixMountPoint)

-- | Makes a copy of /@mountPoint@/.
-- 
-- /Since: 2.54/
unixMountPointCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m UnixMountPoint
    -- ^ __Returns:__ a new t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'
unixMountPointCopy :: UnixMountPoint -> m UnixMountPoint
unixMountPointCopy mountPoint :: UnixMountPoint
mountPoint = IO UnixMountPoint -> m UnixMountPoint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UnixMountPoint -> m UnixMountPoint)
-> IO UnixMountPoint -> m UnixMountPoint
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    Ptr UnixMountPoint
result <- Ptr UnixMountPoint -> IO (Ptr UnixMountPoint)
g_unix_mount_point_copy Ptr UnixMountPoint
mountPoint'
    Text -> Ptr UnixMountPoint -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointCopy" Ptr UnixMountPoint
result
    UnixMountPoint
result' <- ((ManagedPtr UnixMountPoint -> UnixMountPoint)
-> Ptr UnixMountPoint -> IO UnixMountPoint
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr UnixMountPoint -> UnixMountPoint
UnixMountPoint) Ptr UnixMountPoint
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    UnixMountPoint -> IO UnixMountPoint
forall (m :: * -> *) a. Monad m => a -> m a
return UnixMountPoint
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointCopyMethodInfo
instance (signature ~ (m UnixMountPoint), MonadIO m) => O.MethodInfo UnixMountPointCopyMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointCopy

#endif

-- method UnixMountPoint::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "unix mount point to free."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_free" g_unix_mount_point_free :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO ()

-- | Frees a unix mount point.
unixMountPointFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: unix mount point to free.
    -> m ()
unixMountPointFree :: UnixMountPoint -> m ()
unixMountPointFree mountPoint :: UnixMountPoint
mountPoint = 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 UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    Ptr UnixMountPoint -> IO ()
g_unix_mount_point_free Ptr UnixMountPoint
mountPoint'
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UnixMountPointFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo UnixMountPointFreeMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointFree

#endif

-- method UnixMountPoint::get_device_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFileName)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_get_device_path" g_unix_mount_point_get_device_path :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CString

-- | Gets the device path for a unix mount point.
unixMountPointGetDevicePath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m [Char]
    -- ^ __Returns:__ a string containing the device path.
unixMountPointGetDevicePath :: UnixMountPoint -> m [Char]
unixMountPointGetDevicePath mountPoint :: UnixMountPoint
mountPoint = IO [Char] -> m [Char]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Char] -> m [Char]) -> IO [Char] -> m [Char]
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CString
result <- Ptr UnixMountPoint -> IO CString
g_unix_mount_point_get_device_path Ptr UnixMountPoint
mountPoint'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGetDevicePath" CString
result
    [Char]
result' <- HasCallStack => CString -> IO [Char]
CString -> IO [Char]
cstringToString CString
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    [Char] -> IO [Char]
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGetDevicePathMethodInfo
instance (signature ~ (m [Char]), MonadIO m) => O.MethodInfo UnixMountPointGetDevicePathMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGetDevicePath

#endif

-- method UnixMountPoint::get_fs_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_get_fs_type" g_unix_mount_point_get_fs_type :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CString

-- | Gets the file system type for the mount point.
unixMountPointGetFsType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m T.Text
    -- ^ __Returns:__ a string containing the file system type.
unixMountPointGetFsType :: UnixMountPoint -> m Text
unixMountPointGetFsType mountPoint :: UnixMountPoint
mountPoint = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CString
result <- Ptr UnixMountPoint -> IO CString
g_unix_mount_point_get_fs_type Ptr UnixMountPoint
mountPoint'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGetFsType" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGetFsTypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo UnixMountPointGetFsTypeMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGetFsType

#endif

-- method UnixMountPoint::get_mount_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFileName)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_get_mount_path" g_unix_mount_point_get_mount_path :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CString

-- | Gets the mount path for a unix mount point.
unixMountPointGetMountPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m [Char]
    -- ^ __Returns:__ a string containing the mount path.
unixMountPointGetMountPath :: UnixMountPoint -> m [Char]
unixMountPointGetMountPath mountPoint :: UnixMountPoint
mountPoint = IO [Char] -> m [Char]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Char] -> m [Char]) -> IO [Char] -> m [Char]
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CString
result <- Ptr UnixMountPoint -> IO CString
g_unix_mount_point_get_mount_path Ptr UnixMountPoint
mountPoint'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGetMountPath" CString
result
    [Char]
result' <- HasCallStack => CString -> IO [Char]
CString -> IO [Char]
cstringToString CString
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    [Char] -> IO [Char]
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGetMountPathMethodInfo
instance (signature ~ (m [Char]), MonadIO m) => O.MethodInfo UnixMountPointGetMountPathMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGetMountPath

#endif

-- method UnixMountPoint::get_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_get_options" g_unix_mount_point_get_options :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CString

-- | Gets the options for the mount point.
-- 
-- /Since: 2.32/
unixMountPointGetOptions ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m T.Text
    -- ^ __Returns:__ a string containing the options.
unixMountPointGetOptions :: UnixMountPoint -> m Text
unixMountPointGetOptions mountPoint :: UnixMountPoint
mountPoint = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CString
result <- Ptr UnixMountPoint -> IO CString
g_unix_mount_point_get_options Ptr UnixMountPoint
mountPoint'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGetOptions" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGetOptionsMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo UnixMountPointGetOptionsMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGetOptions

#endif

-- method UnixMountPoint::guess_can_eject
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_guess_can_eject" g_unix_mount_point_guess_can_eject :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CInt

-- | Guesses whether a Unix mount point can be ejected.
unixMountPointGuessCanEject ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@mountPoint@/ is deemed to be ejectable.
unixMountPointGuessCanEject :: UnixMountPoint -> m Bool
unixMountPointGuessCanEject mountPoint :: UnixMountPoint
mountPoint = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CInt
result <- Ptr UnixMountPoint -> IO CInt
g_unix_mount_point_guess_can_eject Ptr UnixMountPoint
mountPoint'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGuessCanEjectMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UnixMountPointGuessCanEjectMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGuessCanEject

#endif

-- method UnixMountPoint::guess_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_guess_icon" g_unix_mount_point_guess_icon :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO (Ptr Gio.Icon.Icon)

-- | Guesses the icon of a Unix mount point.
unixMountPointGuessIcon ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'
    -> m Gio.Icon.Icon
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Icon.Icon'
unixMountPointGuessIcon :: UnixMountPoint -> m Icon
unixMountPointGuessIcon mountPoint :: UnixMountPoint
mountPoint = IO Icon -> m Icon
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    Ptr Icon
result <- Ptr UnixMountPoint -> IO (Ptr Icon)
g_unix_mount_point_guess_icon Ptr UnixMountPoint
mountPoint'
    Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGuessIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGuessIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m) => O.MethodInfo UnixMountPointGuessIconMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGuessIcon

#endif

-- method UnixMountPoint::guess_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_guess_name" g_unix_mount_point_guess_name :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CString

-- | Guesses the name of a Unix mount point.
-- The result is a translated string.
unixMountPointGuessName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'
    -> m T.Text
    -- ^ __Returns:__ A newly allocated string that must
    --     be freed with 'GI.GLib.Functions.free'
unixMountPointGuessName :: UnixMountPoint -> m Text
unixMountPointGuessName mountPoint :: UnixMountPoint
mountPoint = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CString
result <- Ptr UnixMountPoint -> IO CString
g_unix_mount_point_guess_name Ptr UnixMountPoint
mountPoint'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGuessName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGuessNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo UnixMountPointGuessNameMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGuessName

#endif

-- method UnixMountPoint::guess_symbolic_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_guess_symbolic_icon" g_unix_mount_point_guess_symbolic_icon :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO (Ptr Gio.Icon.Icon)

-- | Guesses the symbolic icon of a Unix mount point.
-- 
-- /Since: 2.34/
unixMountPointGuessSymbolicIcon ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'
    -> m Gio.Icon.Icon
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Icon.Icon'
unixMountPointGuessSymbolicIcon :: UnixMountPoint -> m Icon
unixMountPointGuessSymbolicIcon mountPoint :: UnixMountPoint
mountPoint = IO Icon -> m Icon
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    Ptr Icon
result <- Ptr UnixMountPoint -> IO (Ptr Icon)
g_unix_mount_point_guess_symbolic_icon Ptr UnixMountPoint
mountPoint'
    Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixMountPointGuessSymbolicIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointGuessSymbolicIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m) => O.MethodInfo UnixMountPointGuessSymbolicIconMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointGuessSymbolicIcon

#endif

-- method UnixMountPoint::is_loopback
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_is_loopback" g_unix_mount_point_is_loopback :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CInt

-- | Checks if a unix mount point is a loopback device.
unixMountPointIsLoopback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the mount point is a loopback. 'P.False' otherwise.
unixMountPointIsLoopback :: UnixMountPoint -> m Bool
unixMountPointIsLoopback mountPoint :: UnixMountPoint
mountPoint = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CInt
result <- Ptr UnixMountPoint -> IO CInt
g_unix_mount_point_is_loopback Ptr UnixMountPoint
mountPoint'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointIsLoopbackMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UnixMountPointIsLoopbackMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointIsLoopback

#endif

-- method UnixMountPoint::is_readonly
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_is_readonly" g_unix_mount_point_is_readonly :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CInt

-- | Checks if a unix mount point is read only.
unixMountPointIsReadonly ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a mount point is read only.
unixMountPointIsReadonly :: UnixMountPoint -> m Bool
unixMountPointIsReadonly mountPoint :: UnixMountPoint
mountPoint = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CInt
result <- Ptr UnixMountPoint -> IO CInt
g_unix_mount_point_is_readonly Ptr UnixMountPoint
mountPoint'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointIsReadonlyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UnixMountPointIsReadonlyMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointIsReadonly

#endif

-- method UnixMountPoint::is_user_mountable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mount_point"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "UnixMountPoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUnixMountPoint."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_mount_point_is_user_mountable" g_unix_mount_point_is_user_mountable :: 
    Ptr UnixMountPoint ->                   -- mount_point : TInterface (Name {namespace = "Gio", name = "UnixMountPoint"})
    IO CInt

-- | Checks if a unix mount point is mountable by the user.
unixMountPointIsUserMountable ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    UnixMountPoint
    -- ^ /@mountPoint@/: a t'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the mount point is user mountable.
unixMountPointIsUserMountable :: UnixMountPoint -> m Bool
unixMountPointIsUserMountable mountPoint :: UnixMountPoint
mountPoint = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UnixMountPoint
mountPoint' <- UnixMountPoint -> IO (Ptr UnixMountPoint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UnixMountPoint
mountPoint
    CInt
result <- Ptr UnixMountPoint -> IO CInt
g_unix_mount_point_is_user_mountable Ptr UnixMountPoint
mountPoint'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    UnixMountPoint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UnixMountPoint
mountPoint
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UnixMountPointIsUserMountableMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UnixMountPointIsUserMountableMethodInfo UnixMountPoint signature where
    overloadedMethod = unixMountPointIsUserMountable

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveUnixMountPointMethod (t :: Symbol) (o :: *) :: * where
    ResolveUnixMountPointMethod "compare" o = UnixMountPointCompareMethodInfo
    ResolveUnixMountPointMethod "copy" o = UnixMountPointCopyMethodInfo
    ResolveUnixMountPointMethod "free" o = UnixMountPointFreeMethodInfo
    ResolveUnixMountPointMethod "guessCanEject" o = UnixMountPointGuessCanEjectMethodInfo
    ResolveUnixMountPointMethod "guessIcon" o = UnixMountPointGuessIconMethodInfo
    ResolveUnixMountPointMethod "guessName" o = UnixMountPointGuessNameMethodInfo
    ResolveUnixMountPointMethod "guessSymbolicIcon" o = UnixMountPointGuessSymbolicIconMethodInfo
    ResolveUnixMountPointMethod "isLoopback" o = UnixMountPointIsLoopbackMethodInfo
    ResolveUnixMountPointMethod "isReadonly" o = UnixMountPointIsReadonlyMethodInfo
    ResolveUnixMountPointMethod "isUserMountable" o = UnixMountPointIsUserMountableMethodInfo
    ResolveUnixMountPointMethod "getDevicePath" o = UnixMountPointGetDevicePathMethodInfo
    ResolveUnixMountPointMethod "getFsType" o = UnixMountPointGetFsTypeMethodInfo
    ResolveUnixMountPointMethod "getMountPath" o = UnixMountPointGetMountPathMethodInfo
    ResolveUnixMountPointMethod "getOptions" o = UnixMountPointGetOptionsMethodInfo
    ResolveUnixMountPointMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveUnixMountPointMethod t UnixMountPoint, O.MethodInfo info UnixMountPoint p) => OL.IsLabel t (UnixMountPoint -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif