{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.OSTree.Structs.SignEd25519Class
    ( 

-- * Exported types
    SignEd25519Class(..)                    ,
    newZeroSignEd25519Class                 ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveSignEd25519ClassMethod           ,
#endif



 -- * Properties


-- ** parentClass #attr:parentClass#
-- | /No description available in the introspection data./

    getSignEd25519ClassParentClass          ,
#if defined(ENABLE_OVERLOADING)
    signEd25519Class_parentClass            ,
#endif




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass

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

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

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


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

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


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

#if defined(ENABLE_OVERLOADING)
data SignEd25519ClassParentClassFieldInfo
instance AttrInfo SignEd25519ClassParentClassFieldInfo where
    type AttrBaseTypeConstraint SignEd25519ClassParentClassFieldInfo = (~) SignEd25519Class
    type AttrAllowedOps SignEd25519ClassParentClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint SignEd25519ClassParentClassFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferTypeConstraint SignEd25519ClassParentClassFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferType SignEd25519ClassParentClassFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
    type AttrGetType SignEd25519ClassParentClassFieldInfo = GObject.ObjectClass.ObjectClass
    type AttrLabel SignEd25519ClassParentClassFieldInfo = "parent_class"
    type AttrOrigin SignEd25519ClassParentClassFieldInfo = SignEd25519Class
    attrGet = getSignEd25519ClassParentClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.SignEd25519Class.parentClass"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.18/docs/GI-OSTree-Structs-SignEd25519Class.html#g:attr:parentClass"
        })

signEd25519Class_parentClass :: AttrLabelProxy "parentClass"
signEd25519Class_parentClass = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SignEd25519Class
type instance O.AttributeList SignEd25519Class = SignEd25519ClassAttributeList
type SignEd25519ClassAttributeList = ('[ '("parentClass", SignEd25519ClassParentClassFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveSignEd25519ClassMethod t SignEd25519Class, O.OverloadedMethod info SignEd25519Class p, R.HasField t SignEd25519Class p) => R.HasField t SignEd25519Class p where
    getField = O.overloadedMethod @info

#endif

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

#endif