{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Defines a Unix mount point (e.g. \<filename>\/dev\<\/filename>).
This corresponds roughly to a fstab entry.
-}

module GI.Gio.Structs.UnixMountPoint
    ( 

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


 -- * Methods
-- ** compare #method:compare#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointCompareMethodInfo         ,
#endif
    unixMountPointCompare                   ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointFreeMethodInfo            ,
#endif
    unixMountPointFree                      ,


-- ** getDevicePath #method:getDevicePath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGetDevicePathMethodInfo   ,
#endif
    unixMountPointGetDevicePath             ,


-- ** getFsType #method:getFsType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGetFsTypeMethodInfo       ,
#endif
    unixMountPointGetFsType                 ,


-- ** getMountPath #method:getMountPath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGetMountPathMethodInfo    ,
#endif
    unixMountPointGetMountPath              ,


-- ** getOptions #method:getOptions#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGetOptionsMethodInfo      ,
#endif
    unixMountPointGetOptions                ,


-- ** guessCanEject #method:guessCanEject#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGuessCanEjectMethodInfo   ,
#endif
    unixMountPointGuessCanEject             ,


-- ** guessIcon #method:guessIcon#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGuessIconMethodInfo       ,
#endif
    unixMountPointGuessIcon                 ,


-- ** guessName #method:guessName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGuessNameMethodInfo       ,
#endif
    unixMountPointGuessName                 ,


-- ** guessSymbolicIcon #method:guessSymbolicIcon#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointGuessSymbolicIconMethodInfo,
#endif
    unixMountPointGuessSymbolicIcon         ,


-- ** isLoopback #method:isLoopback#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointIsLoopbackMethodInfo      ,
#endif
    unixMountPointIsLoopback                ,


-- ** isReadonly #method:isReadonly#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    UnixMountPointIsReadonlyMethodInfo      ,
#endif
    unixMountPointIsReadonly                ,


-- ** isUserMountable #method:isUserMountable#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon

newtype UnixMountPoint = UnixMountPoint (ManagedPtr UnixMountPoint)
-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance WrappedPtr UnixMountPoint where
    wrappedPtrCalloc = return nullPtr
    wrappedPtrCopy = return
    wrappedPtrFree = Nothing

noUnixMountPoint :: Maybe UnixMountPoint
noUnixMountPoint = Nothing


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 mount1 mount2 = liftIO $ do
    mount1' <- unsafeManagedPtrGetPtr mount1
    mount2' <- unsafeManagedPtrGetPtr mount2
    result <- g_unix_mount_point_compare mount1' mount2'
    touchManagedPtr mount1
    touchManagedPtr mount2
    return result

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

#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 mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    g_unix_mount_point_free mountPoint'
    touchManagedPtr mountPoint
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m [Char]
    {- ^ __Returns:__ a string containing the device path. -}
unixMountPointGetDevicePath mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_get_device_path mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGetDevicePath" result
    result' <- cstringToString result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m T.Text
    {- ^ __Returns:__ a string containing the file system type. -}
unixMountPointGetFsType mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_get_fs_type mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGetFsType" result
    result' <- cstringToText result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m [Char]
    {- ^ __Returns:__ a string containing the mount path. -}
unixMountPointGetMountPath mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_get_mount_path mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGetMountPath" result
    result' <- cstringToString result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m T.Text
    {- ^ __Returns:__ a string containing the options. -}
unixMountPointGetOptions mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_get_options mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGetOptions" result
    result' <- cstringToText result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@mountPoint@/ is deemed to be ejectable. -}
unixMountPointGuessCanEject mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_guess_can_eject mountPoint'
    let result' = (/= 0) result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint' -}
    -> m Gio.Icon.Icon
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Icon.Icon' -}
unixMountPointGuessIcon mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_guess_icon mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGuessIcon" result
    result' <- (wrapObject Gio.Icon.Icon) result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint' -}
    -> m T.Text
    {- ^ __Returns:__ A newly allocated string that must
    be freed with 'GI.GLib.Functions.free' -}
unixMountPointGuessName mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_guess_name mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGuessName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint' -}
    -> m Gio.Icon.Icon
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Icon.Icon' -}
unixMountPointGuessSymbolicIcon mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_guess_symbolic_icon mountPoint'
    checkUnexpectedReturnNULL "unixMountPointGuessSymbolicIcon" result
    result' <- (wrapObject Gio.Icon.Icon) result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the mount point is a loopback. 'False' otherwise. -}
unixMountPointIsLoopback mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_is_loopback mountPoint'
    let result' = (/= 0) result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a mount point is read only. -}
unixMountPointIsReadonly mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_is_readonly mountPoint'
    let result' = (/= 0) result
    touchManagedPtr mountPoint
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Gio.Structs.UnixMountPoint.UnixMountPoint'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the mount point is user mountable. -}
unixMountPointIsUserMountable mountPoint = liftIO $ do
    mountPoint' <- unsafeManagedPtrGetPtr mountPoint
    result <- g_unix_mount_point_is_user_mountable mountPoint'
    let result' = (/= 0) result
    touchManagedPtr mountPoint
    return result'

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

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveUnixMountPointMethod (t :: Symbol) (o :: *) :: * where
    ResolveUnixMountPointMethod "compare" o = UnixMountPointCompareMethodInfo
    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) => O.IsLabelProxy t (UnixMountPoint -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif