{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a git remote head.

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

module GI.Ggit.Structs.RemoteHead
    (

-- * Exported types
    RemoteHead(..)                          ,
    noRemoteHead                            ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveRemoteHeadMethod                 ,
#endif


-- ** getLocalOid #method:getLocalOid#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadGetLocalOidMethodInfo         ,
#endif
    remoteHeadGetLocalOid                   ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadGetNameMethodInfo             ,
#endif
    remoteHeadGetName                       ,


-- ** getOid #method:getOid#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadGetOidMethodInfo              ,
#endif
    remoteHeadGetOid                        ,


-- ** isLocal #method:isLocal#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadIsLocalMethodInfo             ,
#endif
    remoteHeadIsLocal                       ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadRefMethodInfo                 ,
#endif
    remoteHeadRef                           ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    RemoteHeadUnrefMethodInfo               ,
#endif
    remoteHeadUnref                         ,




    ) 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.Ggit.Structs.OId as Ggit.OId

-- | Memory-managed wrapper type.
newtype RemoteHead = RemoteHead (ManagedPtr RemoteHead)
    deriving (Eq)
foreign import ccall "ggit_remote_head_get_type" c_ggit_remote_head_get_type ::
    IO GType

instance BoxedObject RemoteHead where
    boxedType _ = c_ggit_remote_head_get_type

-- | Convert 'RemoteHead' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue RemoteHead where
    toGValue o = do
        gtype <- c_ggit_remote_head_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_boxed)

    fromGValue gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr RemoteHead)
        B.ManagedPtr.newBoxed RemoteHead ptr



-- | A convenience alias for `Nothing` :: `Maybe` `RemoteHead`.
noRemoteHead :: Maybe RemoteHead
noRemoteHead = Nothing


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

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

foreign import ccall "ggit_remote_head_get_local_oid" ggit_remote_head_get_local_oid ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO (Ptr Ggit.OId.OId)

-- | Get the local oid of the remote head.
remoteHeadGetLocalOid ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -- ^ /@remoteHead@/: a t'GI.Ggit.Structs.RemoteHead.RemoteHead'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the local oid or 'P.Nothing'.
remoteHeadGetLocalOid remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    result <- ggit_remote_head_get_local_oid remoteHead'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr remoteHead
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RemoteHeadGetLocalOidMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo RemoteHeadGetLocalOidMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadGetLocalOid

#endif

-- method RemoteHead::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "remote_head"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteHead" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRemoteHead." , 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 "ggit_remote_head_get_name" ggit_remote_head_get_name ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO CString

-- | Get the remote head name.
remoteHeadGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -- ^ /@remoteHead@/: a t'GI.Ggit.Structs.RemoteHead.RemoteHead'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the remote head name or 'P.Nothing'.
remoteHeadGetName remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    result <- ggit_remote_head_get_name remoteHead'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr remoteHead
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RemoteHeadGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RemoteHeadGetNameMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadGetName

#endif

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

foreign import ccall "ggit_remote_head_get_oid" ggit_remote_head_get_oid ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO (Ptr Ggit.OId.OId)

-- | Get the remote oid of the remote head.
remoteHeadGetOid ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -- ^ /@remoteHead@/: a t'GI.Ggit.Structs.RemoteHead.RemoteHead'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the remote oid or 'P.Nothing'.
remoteHeadGetOid remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    result <- ggit_remote_head_get_oid remoteHead'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr remoteHead
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data RemoteHeadGetOidMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo RemoteHeadGetOidMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadGetOid

#endif

-- method RemoteHead::is_local
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "remote_head"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteHead" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRemoteHead." , 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 "ggit_remote_head_is_local" ggit_remote_head_is_local ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO CInt

-- | Get whether the remote head is local.
remoteHeadIsLocal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -- ^ /@remoteHead@/: a t'GI.Ggit.Structs.RemoteHead.RemoteHead'.
    -> m Bool
    -- ^ __Returns:__ whether the remote head is local.
remoteHeadIsLocal remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    result <- ggit_remote_head_is_local remoteHead'
    let result' = (/= 0) result
    touchManagedPtr remoteHead
    return result'

#if defined(ENABLE_OVERLOADING)
data RemoteHeadIsLocalMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RemoteHeadIsLocalMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadIsLocal

#endif

-- method RemoteHead::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "remote_head"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteHead" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Ggit" , name = "RemoteHead" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_remote_head_ref" ggit_remote_head_ref ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO (Ptr RemoteHead)

-- | /No description available in the introspection data./
remoteHeadRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -> m RemoteHead
remoteHeadRef remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    result <- ggit_remote_head_ref remoteHead'
    checkUnexpectedReturnNULL "remoteHeadRef" result
    result' <- (wrapBoxed RemoteHead) result
    touchManagedPtr remoteHead
    return result'

#if defined(ENABLE_OVERLOADING)
data RemoteHeadRefMethodInfo
instance (signature ~ (m RemoteHead), MonadIO m) => O.MethodInfo RemoteHeadRefMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadRef

#endif

-- method RemoteHead::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "remote_head"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteHead" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_remote_head_unref" ggit_remote_head_unref ::
    Ptr RemoteHead ->                       -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"})
    IO ()

-- | /No description available in the introspection data./
remoteHeadUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RemoteHead
    -> m ()
remoteHeadUnref remoteHead = liftIO $ do
    remoteHead' <- unsafeManagedPtrGetPtr remoteHead
    ggit_remote_head_unref remoteHead'
    touchManagedPtr remoteHead
    return ()

#if defined(ENABLE_OVERLOADING)
data RemoteHeadUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RemoteHeadUnrefMethodInfo RemoteHead signature where
    overloadedMethod = remoteHeadUnref

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRemoteHeadMethod (t :: Symbol) (o :: *) :: * where
    ResolveRemoteHeadMethod "isLocal" o = RemoteHeadIsLocalMethodInfo
    ResolveRemoteHeadMethod "ref" o = RemoteHeadRefMethodInfo
    ResolveRemoteHeadMethod "unref" o = RemoteHeadUnrefMethodInfo
    ResolveRemoteHeadMethod "getLocalOid" o = RemoteHeadGetLocalOidMethodInfo
    ResolveRemoteHeadMethod "getName" o = RemoteHeadGetNameMethodInfo
    ResolveRemoteHeadMethod "getOid" o = RemoteHeadGetOidMethodInfo
    ResolveRemoteHeadMethod l o = O.MethodResolutionFailed l o

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

#endif