{-# 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 tag object.

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

module GI.Ggit.Objects.Tag
    (

-- * Exported types
    Tag(..)                                 ,
    IsTag                                   ,
    toTag                                   ,
    noTag                                   ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveTagMethod                        ,
#endif


-- ** getMessage #method:getMessage#

#if defined(ENABLE_OVERLOADING)
    TagGetMessageMethodInfo                 ,
#endif
    tagGetMessage                           ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    TagGetNameMethodInfo                    ,
#endif
    tagGetName                              ,


-- ** getTagger #method:getTagger#

#if defined(ENABLE_OVERLOADING)
    TagGetTaggerMethodInfo                  ,
#endif
    tagGetTagger                            ,


-- ** getTarget #method:getTarget#

#if defined(ENABLE_OVERLOADING)
    TagGetTargetMethodInfo                  ,
#endif
    tagGetTarget                            ,


-- ** getTargetId #method:getTargetId#

#if defined(ENABLE_OVERLOADING)
    TagGetTargetIdMethodInfo                ,
#endif
    tagGetTargetId                          ,


-- ** getTargetType #method:getTargetType#

#if defined(ENABLE_OVERLOADING)
    TagGetTargetTypeMethodInfo              ,
#endif
    tagGetTargetType                        ,


-- ** peel #method:peel#

#if defined(ENABLE_OVERLOADING)
    TagPeelMethodInfo                       ,
#endif
    tagPeel                                 ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId

-- | Memory-managed wrapper type.
newtype Tag = Tag (ManagedPtr Tag)
    deriving (Eq)
foreign import ccall "ggit_tag_get_type"
    c_ggit_tag_get_type :: IO GType

instance GObject Tag where
    gobjectType = c_ggit_tag_get_type


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

    fromGValue gv = do
        ptr <- B.GValue.get_object gv :: IO (Ptr Tag)
        B.ManagedPtr.newObject Tag ptr



-- | Type class for types which can be safely cast to `Tag`, for instance with `toTag`.
class (GObject o, O.IsDescendantOf Tag o) => IsTag o
instance (GObject o, O.IsDescendantOf Tag o) => IsTag o

instance O.HasParentTypes Tag
type instance O.ParentTypes Tag = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]

-- | Cast to `Tag`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTag :: (MonadIO m, IsTag o) => o -> m Tag
toTag = liftIO . unsafeCastTo Tag

-- | A convenience alias for `Nothing` :: `Maybe` `Tag`.
noTag :: Maybe Tag
noTag = Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveTagMethod (t :: Symbol) (o :: *) :: * where
    ResolveTagMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTagMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTagMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTagMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTagMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTagMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTagMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTagMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTagMethod "peel" o = TagPeelMethodInfo
    ResolveTagMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTagMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTagMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTagMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTagMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTagMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTagMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTagMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTagMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTagMethod "getId" o = Ggit.Object.ObjectGetIdMethodInfo
    ResolveTagMethod "getMessage" o = TagGetMessageMethodInfo
    ResolveTagMethod "getName" o = TagGetNameMethodInfo
    ResolveTagMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo
    ResolveTagMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTagMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTagMethod "getTagger" o = TagGetTaggerMethodInfo
    ResolveTagMethod "getTarget" o = TagGetTargetMethodInfo
    ResolveTagMethod "getTargetId" o = TagGetTargetIdMethodInfo
    ResolveTagMethod "getTargetType" o = TagGetTargetTypeMethodInfo
    ResolveTagMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTagMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTagMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTagMethod l o = O.MethodResolutionFailed l o

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Tag
type instance O.AttributeList Tag = TagAttributeList
type TagAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Tag = TagSignalList
type TagSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Tag::get_message
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "tag"
--           , argType = TInterface Name { namespace = "Ggit" , name = "Tag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTag." , 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_tag_get_message" ggit_tag_get_message ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    IO CString

-- | Gets the message of /@tag@/.
tagGetMessage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the message of the tag or 'P.Nothing'.
tagGetMessage tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    result <- ggit_tag_get_message tag'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr tag
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data TagGetMessageMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTag a) => O.MethodInfo TagGetMessageMethodInfo a signature where
    overloadedMethod = tagGetMessage

#endif

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

-- | Gets the name of /@tag@/.
tagGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the tag or 'P.Nothing'.
tagGetName tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    result <- ggit_tag_get_name tag'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr tag
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data TagGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTag a) => O.MethodInfo TagGetNameMethodInfo a signature where
    overloadedMethod = tagGetName

#endif

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

foreign import ccall "ggit_tag_get_tagger" ggit_tag_get_tagger ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    IO (Ptr Ggit.Signature.Signature)

-- | Get the tagger (author) of /@tag@/. The returned value must be free with
-- 'GI.GObject.Objects.Object.objectUnref'.
tagGetTagger ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe Ggit.Signature.Signature)
    -- ^ __Returns:__ the tagger (author) of the tag or 'P.Nothing'.
tagGetTagger tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    result <- ggit_tag_get_tagger tag'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Ggit.Signature.Signature) result'
        return result''
    touchManagedPtr tag
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data TagGetTaggerMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsTag a) => O.MethodInfo TagGetTaggerMethodInfo a signature where
    overloadedMethod = tagGetTagger

#endif

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

foreign import ccall "ggit_tag_get_target" ggit_tag_get_target ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.Object.Object)

-- | Gets the target t'GI.Ggit.Objects.Object.Object' of /@tag@/.
-- 
-- This method performs a repository lookup for the
-- given object and returns it.
tagGetTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe Ggit.Object.Object)
    -- ^ __Returns:__ the target t'GI.Ggit.Objects.Object.Object' of the tag or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
tagGetTarget tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    onException (do
        result <- propagateGError $ ggit_tag_get_target tag'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapObject Ggit.Object.Object) result'
            return result''
        touchManagedPtr tag
        return maybeResult
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data TagGetTargetMethodInfo
instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetMethodInfo a signature where
    overloadedMethod = tagGetTarget

#endif

-- method Tag::get_target_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "tag"
--           , argType = TInterface Name { namespace = "Ggit" , name = "Tag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTag." , 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_tag_get_target_id" ggit_tag_get_target_id ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    IO (Ptr Ggit.OId.OId)

-- | Gets the target t'GI.Ggit.Structs.OId.OId' of /@tag@/.
tagGetTargetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the target t'GI.Ggit.Structs.OId.OId' of the tag or 'P.Nothing'.
tagGetTargetId tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    result <- ggit_tag_get_target_id tag'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr tag
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data TagGetTargetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetIdMethodInfo a signature where
    overloadedMethod = tagGetTargetId

#endif

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

foreign import ccall "ggit_tag_get_target_type" ggit_tag_get_target_type ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    IO CGType

-- | Get the target object type.
tagGetTargetType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m GType
    -- ^ __Returns:__ a t'GType'.
tagGetTargetType tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    result <- ggit_tag_get_target_type tag'
    let result' = GType result
    touchManagedPtr tag
    return result'

#if defined(ENABLE_OVERLOADING)
data TagGetTargetTypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetTypeMethodInfo a signature where
    overloadedMethod = tagGetTargetType

#endif

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

foreign import ccall "ggit_tag_peel" ggit_tag_peel ::
    Ptr Tag ->                              -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.Object.Object)

-- | Recursively peel a tag until a non tag object is found.
tagPeel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTag a) =>
    a
    -- ^ /@tag@/: a t'GI.Ggit.Objects.Tag.Tag'.
    -> m (Maybe Ggit.Object.Object)
    -- ^ __Returns:__ a t'GI.Ggit.Objects.Object.Object' or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
tagPeel tag = liftIO $ do
    tag' <- unsafeManagedPtrCastPtr tag
    onException (do
        result <- propagateGError $ ggit_tag_peel tag'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapObject Ggit.Object.Object) result'
            return result''
        touchManagedPtr tag
        return maybeResult
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data TagPeelMethodInfo
instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsTag a) => O.MethodInfo TagPeelMethodInfo a signature where
    overloadedMethod = tagPeel

#endif