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

Memory is usually created by allocators with a 'GI.Gst.Objects.Allocator.allocatorAlloc'
method call. When 'Nothing' is used as the allocator, the default allocator will
be used.

New allocators can be registered with 'GI.Gst.Objects.Allocator.allocatorRegister'.
Allocators are identified by name and can be retrieved with
'GI.Gst.Objects.Allocator.allocatorFind'. 'GI.Gst.Objects.Allocator.allocatorSetDefault' can be used to change the
default allocator.

New memory can be created with 'GI.Gst.Structs.Memory.memoryNewWrapped' that wraps the memory
allocated elsewhere.
-}

module GI.Gst.Objects.Allocator
    ( 

-- * Exported types
    Allocator(..)                           ,
    IsAllocator                             ,
    toAllocator                             ,
    noAllocator                             ,


 -- * Methods
-- ** alloc #method:alloc#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AllocatorAllocMethodInfo                ,
#endif
    allocatorAlloc                          ,


-- ** find #method:find#
    allocatorFind                           ,


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


-- ** register #method:register#
    allocatorRegister                       ,


-- ** setDefault #method:setDefault#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AllocatorSetDefaultMethodInfo           ,
#endif
    allocatorSetDefault                     ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import {-# SOURCE #-} qualified GI.Gst.Structs.Memory as Gst.Memory

newtype Allocator = Allocator (ManagedPtr Allocator)
foreign import ccall "gst_allocator_get_type"
    c_gst_allocator_get_type :: IO GType

instance GObject Allocator where
    gobjectType _ = c_gst_allocator_get_type
    

class GObject o => IsAllocator o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Allocator a) =>
    IsAllocator a
#endif
instance IsAllocator Allocator
instance Gst.Object.IsObject Allocator
instance GObject.Object.IsObject Allocator

toAllocator :: (MonadIO m, IsAllocator o) => o -> m Allocator
toAllocator = liftIO . unsafeCastTo Allocator

noAllocator :: Maybe Allocator
noAllocator = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveAllocatorMethod (t :: Symbol) (o :: *) :: * where
    ResolveAllocatorMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveAllocatorMethod "alloc" o = AllocatorAllocMethodInfo
    ResolveAllocatorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAllocatorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAllocatorMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveAllocatorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAllocatorMethod "free" o = AllocatorFreeMethodInfo
    ResolveAllocatorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAllocatorMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveAllocatorMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveAllocatorMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveAllocatorMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveAllocatorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAllocatorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAllocatorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAllocatorMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveAllocatorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAllocatorMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveAllocatorMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAllocatorMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAllocatorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAllocatorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAllocatorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAllocatorMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveAllocatorMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveAllocatorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAllocatorMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveAllocatorMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveAllocatorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAllocatorMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveAllocatorMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveAllocatorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAllocatorMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveAllocatorMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveAllocatorMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveAllocatorMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveAllocatorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAllocatorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAllocatorMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveAllocatorMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveAllocatorMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveAllocatorMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveAllocatorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAllocatorMethod "setDefault" o = AllocatorSetDefaultMethodInfo
    ResolveAllocatorMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveAllocatorMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveAllocatorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAllocatorMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAllocatorMethod t Allocator, O.MethodInfo info Allocator p) => O.IsLabelProxy t (Allocator -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAllocatorMethod t Allocator, O.MethodInfo info Allocator p) => O.IsLabel t (Allocator -> 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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList Allocator
type instance O.AttributeList Allocator = AllocatorAttributeList
type AllocatorAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList Allocator = AllocatorSignalList
type AllocatorSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Allocator::alloc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAllocator to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of the visible memory area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Memory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_allocator_alloc" gst_allocator_alloc :: 
    Ptr Allocator ->                        -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
    Word64 ->                               -- size : TBasicType TUInt64
    Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"})
    IO (Ptr Gst.Memory.Memory)

{- |
Use /@allocator@/ to allocate a new memory block with memory that is at least
/@size@/ big.

The optional /@params@/ can specify the prefix and padding for the memory. If
'Nothing' is passed, no flags, no extra prefix\/padding and a default alignment is
used.

The prefix\/padding will be filled with 0 if flags contains
@/GST_MEMORY_FLAG_ZERO_PREFIXED/@ and @/GST_MEMORY_FLAG_ZERO_PADDED/@ respectively.

When /@allocator@/ is 'Nothing', the default allocator will be used.

The alignment in /@params@/ is given as a bitmask so that /@align@/ + 1 equals
the amount of bytes to align to. For example, to align to 8 bytes,
use an alignment of 7.
-}
allocatorAlloc ::
    (B.CallStack.HasCallStack, MonadIO m, IsAllocator a) =>
    a
    {- ^ /@allocator@/: a 'GI.Gst.Objects.Allocator.Allocator' to use -}
    -> Word64
    {- ^ /@size@/: size of the visible memory area -}
    -> Maybe (Gst.AllocationParams.AllocationParams)
    {- ^ /@params@/: optional parameters -}
    -> m Gst.Memory.Memory
    {- ^ __Returns:__ a new 'GI.Gst.Structs.Memory.Memory'. -}
allocatorAlloc allocator size params = liftIO $ do
    allocator' <- unsafeManagedPtrCastPtr allocator
    maybeParams <- case params of
        Nothing -> return nullPtr
        Just jParams -> do
            jParams' <- unsafeManagedPtrGetPtr jParams
            return jParams'
    result <- gst_allocator_alloc allocator' size maybeParams
    checkUnexpectedReturnNULL "allocatorAlloc" result
    result' <- (wrapBoxed Gst.Memory.Memory) result
    touchManagedPtr allocator
    whenJust params touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AllocatorAllocMethodInfo
instance (signature ~ (Word64 -> Maybe (Gst.AllocationParams.AllocationParams) -> m Gst.Memory.Memory), MonadIO m, IsAllocator a) => O.MethodInfo AllocatorAllocMethodInfo a signature where
    overloadedMethod _ = allocatorAlloc

#endif

-- method Allocator::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAllocator to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "memory", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the memory to free", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_allocator_free" gst_allocator_free :: 
    Ptr Allocator ->                        -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
    Ptr Gst.Memory.Memory ->                -- memory : TInterface (Name {namespace = "Gst", name = "Memory"})
    IO ()

{- |
Free /@memory@/ that was previously allocated with 'GI.Gst.Objects.Allocator.allocatorAlloc'.
-}
allocatorFree ::
    (B.CallStack.HasCallStack, MonadIO m, IsAllocator a) =>
    a
    {- ^ /@allocator@/: a 'GI.Gst.Objects.Allocator.Allocator' to use -}
    -> Gst.Memory.Memory
    {- ^ /@memory@/: the memory to free -}
    -> m ()
allocatorFree allocator memory = liftIO $ do
    allocator' <- unsafeManagedPtrCastPtr allocator
    memory' <- B.ManagedPtr.disownBoxed memory
    gst_allocator_free allocator' memory'
    touchManagedPtr allocator
    touchManagedPtr memory
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AllocatorFreeMethodInfo
instance (signature ~ (Gst.Memory.Memory -> m ()), MonadIO m, IsAllocator a) => O.MethodInfo AllocatorFreeMethodInfo a signature where
    overloadedMethod _ = allocatorFree

#endif

-- method Allocator::set_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAllocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_allocator_set_default" gst_allocator_set_default :: 
    Ptr Allocator ->                        -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
    IO ()

{- |
Set the default allocator. This function takes ownership of /@allocator@/.
-}
allocatorSetDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsAllocator a) =>
    a
    {- ^ /@allocator@/: a 'GI.Gst.Objects.Allocator.Allocator' -}
    -> m ()
allocatorSetDefault allocator = liftIO $ do
    allocator' <- B.ManagedPtr.disownObject allocator
    gst_allocator_set_default allocator'
    touchManagedPtr allocator
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AllocatorSetDefaultMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAllocator a) => O.MethodInfo AllocatorSetDefaultMethodInfo a signature where
    overloadedMethod _ = allocatorSetDefault

#endif

-- method Allocator::find
-- method type : MemberFunction
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Allocator"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_allocator_find" gst_allocator_find :: 
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Allocator)

{- |
Find a previously registered allocator with /@name@/. When /@name@/ is 'Nothing', the
default allocator will be returned.
-}
allocatorFind ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@name@/: the name of the allocator -}
    -> m (Maybe Allocator)
    {- ^ __Returns:__ a 'GI.Gst.Objects.Allocator.Allocator' or 'Nothing' when
the allocator with /@name@/ was not registered. Use 'GI.Gst.Objects.Object.objectUnref'
to release the allocator after usage. -}
allocatorFind name = liftIO $ do
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    result <- gst_allocator_find maybeName
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Allocator) result'
        return result''
    freeMem maybeName
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method Allocator::register
-- method type : MemberFunction
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstAllocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_allocator_register" gst_allocator_register :: 
    CString ->                              -- name : TBasicType TUTF8
    Ptr Allocator ->                        -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
    IO ()

{- |
Registers the memory /@allocator@/ with /@name@/. This function takes ownership of
/@allocator@/.
-}
allocatorRegister ::
    (B.CallStack.HasCallStack, MonadIO m, IsAllocator a) =>
    T.Text
    {- ^ /@name@/: the name of the allocator -}
    -> a
    {- ^ /@allocator@/: 'GI.Gst.Objects.Allocator.Allocator' -}
    -> m ()
allocatorRegister name allocator = liftIO $ do
    name' <- textToCString name
    allocator' <- B.ManagedPtr.disownObject allocator
    gst_allocator_register name' allocator'
    touchManagedPtr allocator
    freeMem name'
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif