{-# 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.Dazzle.Structs.GraphColumnClass_
    ( 

-- * Exported types
    GraphColumnClass_(..)                   ,
    newZeroGraphColumnClass_                ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveGraphColumnClass_Method          ,
#endif



 -- * Properties


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

    getGraphColumnClass_Parent              ,
#if defined(ENABLE_OVERLOADING)
    graphColumnClass__parent                ,
#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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass

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

#endif

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

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

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


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

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


-- | Get the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' graphColumnClass_ #parent
-- @
getGraphColumnClass_Parent :: MonadIO m => GraphColumnClass_ -> m GObject.ObjectClass.ObjectClass
getGraphColumnClass_Parent :: forall (m :: * -> *).
MonadIO m =>
GraphColumnClass_ -> m ObjectClass
getGraphColumnClass_Parent GraphColumnClass_
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
$ GraphColumnClass_
-> (Ptr GraphColumnClass_ -> IO ObjectClass) -> IO ObjectClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GraphColumnClass_
s ((Ptr GraphColumnClass_ -> IO ObjectClass) -> IO ObjectClass)
-> (Ptr GraphColumnClass_ -> IO ObjectClass) -> IO ObjectClass
forall a b. (a -> b) -> a -> b
$ \Ptr GraphColumnClass_
ptr -> do
    let val :: Ptr ObjectClass
val = Ptr GraphColumnClass_
ptr Ptr GraphColumnClass_ -> 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 GraphColumnClass_ParentFieldInfo
instance AttrInfo GraphColumnClass_ParentFieldInfo where
    type AttrBaseTypeConstraint GraphColumnClass_ParentFieldInfo = (~) GraphColumnClass_
    type AttrAllowedOps GraphColumnClass_ParentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint GraphColumnClass_ParentFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferTypeConstraint GraphColumnClass_ParentFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferType GraphColumnClass_ParentFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
    type AttrGetType GraphColumnClass_ParentFieldInfo = GObject.ObjectClass.ObjectClass
    type AttrLabel GraphColumnClass_ParentFieldInfo = "parent"
    type AttrOrigin GraphColumnClass_ParentFieldInfo = GraphColumnClass_
    attrGet = getGraphColumnClass_Parent
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.GraphColumnClass_.parent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-GraphColumnClass_.html#g:attr:parent"
        })

graphColumnClass__parent :: AttrLabelProxy "parent"
graphColumnClass__parent = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GraphColumnClass_
type instance O.AttributeList GraphColumnClass_ = GraphColumnClass_AttributeList
type GraphColumnClass_AttributeList = ('[ '("parent", GraphColumnClass_ParentFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

instance (info ~ ResolveGraphColumnClass_Method t GraphColumnClass_, O.OverloadedMethod info GraphColumnClass_ p) => OL.IsLabel t (GraphColumnClass_ -> 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 ~ ResolveGraphColumnClass_Method t GraphColumnClass_, O.OverloadedMethod info GraphColumnClass_ p, R.HasField t GraphColumnClass_ p) => R.HasField t GraphColumnClass_ p where
    getField = O.overloadedMethod @info

#endif

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

#endif