{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) Frame (context) data passed to each frame parsing virtual methods. In addition to providing the data to be checked for a valid frame or an already identified frame, it conveys additional metadata or control information from and to the subclass w.r.t. the particular frame in question (rather than global parameters). Some of these may apply to each parsing stage, others only to some a particular one. These parameters are effectively zeroed at start of each frame\'s processing, i.e. parsing virtual method invocation sequence. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GstBase.Structs.BaseParseFrame ( -- * Exported types BaseParseFrame(..) , newZeroBaseParseFrame , noBaseParseFrame , -- * Methods -- ** copy #method:copy# #if ENABLE_OVERLOADING BaseParseFrameCopyMethodInfo , #endif baseParseFrameCopy , -- ** free #method:free# #if ENABLE_OVERLOADING BaseParseFrameFreeMethodInfo , #endif baseParseFrameFree , -- ** init #method:init# #if ENABLE_OVERLOADING BaseParseFrameInitMethodInfo , #endif baseParseFrameInit , -- ** new #method:new# baseParseFrameNew , -- * Properties -- ** buffer #attr:buffer# {- | input data to be parsed for frames. -} #if ENABLE_OVERLOADING baseParseFrame_buffer , #endif clearBaseParseFrameBuffer , getBaseParseFrameBuffer , setBaseParseFrameBuffer , -- ** flags #attr:flags# {- | a combination of input and output 'GI.GstBase.Flags.BaseParseFrameFlags' that convey additional context to subclass or allow subclass to tune subsequent 'GI.GstBase.Objects.BaseParse.BaseParse' actions. -} #if ENABLE_OVERLOADING baseParseFrame_flags , #endif getBaseParseFrameFlags , setBaseParseFrameFlags , -- ** offset #attr:offset# {- | media specific offset of input frame Note that a converter may have a different one on the frame\'s buffer. -} #if ENABLE_OVERLOADING baseParseFrame_offset , #endif getBaseParseFrameOffset , setBaseParseFrameOffset , -- ** outBuffer #attr:outBuffer# {- | output data. -} #if ENABLE_OVERLOADING baseParseFrame_outBuffer , #endif clearBaseParseFrameOutBuffer , getBaseParseFrameOutBuffer , setBaseParseFrameOutBuffer , -- ** overhead #attr:overhead# {- | subclass can set this to indicates the metadata overhead for the given frame, which is then used to enable more accurate bitrate computations. If this is -1, it is assumed that this frame should be skipped in bitrate calculation. -} #if ENABLE_OVERLOADING baseParseFrame_overhead , #endif getBaseParseFrameOverhead , setBaseParseFrameOverhead , ) 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.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.Gst.Structs.Buffer as Gst.Buffer import {-# SOURCE #-} qualified GI.GstBase.Flags as GstBase.Flags -- | Memory-managed wrapper type. newtype BaseParseFrame = BaseParseFrame (ManagedPtr BaseParseFrame) foreign import ccall "gst_base_parse_frame_get_type" c_gst_base_parse_frame_get_type :: IO GType instance BoxedObject BaseParseFrame where boxedType _ = c_gst_base_parse_frame_get_type -- | Construct a `BaseParseFrame` struct initialized to zero. newZeroBaseParseFrame :: MonadIO m => m BaseParseFrame newZeroBaseParseFrame = liftIO $ callocBoxedBytes 72 >>= wrapBoxed BaseParseFrame instance tag ~ 'AttrSet => Constructible BaseParseFrame tag where new _ attrs = do o <- newZeroBaseParseFrame GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `BaseParseFrame`. noBaseParseFrame :: Maybe BaseParseFrame noBaseParseFrame = Nothing {- | Get the value of the “@buffer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' baseParseFrame #buffer @ -} getBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> m (Maybe Gst.Buffer.Buffer) getBaseParseFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Buffer.Buffer) result <- SP.convertIfNonNull val $ \val' -> do val'' <- (newBoxed Gst.Buffer.Buffer) val' return val'' return result {- | Set the value of the “@buffer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' baseParseFrame [ #buffer 'Data.GI.Base.Attributes.:=' value ] @ -} setBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> Ptr Gst.Buffer.Buffer -> m () setBaseParseFrameBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Ptr Gst.Buffer.Buffer) {- | Set the value of the “@buffer@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #buffer @ -} clearBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> m () clearBaseParseFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) #if ENABLE_OVERLOADING data BaseParseFrameBufferFieldInfo instance AttrInfo BaseParseFrameBufferFieldInfo where type AttrAllowedOps BaseParseFrameBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint BaseParseFrameBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) type AttrBaseTypeConstraint BaseParseFrameBufferFieldInfo = (~) BaseParseFrame type AttrGetType BaseParseFrameBufferFieldInfo = Maybe Gst.Buffer.Buffer type AttrLabel BaseParseFrameBufferFieldInfo = "buffer" type AttrOrigin BaseParseFrameBufferFieldInfo = BaseParseFrame attrGet _ = getBaseParseFrameBuffer attrSet _ = setBaseParseFrameBuffer attrConstruct = undefined attrClear _ = clearBaseParseFrameBuffer baseParseFrame_buffer :: AttrLabelProxy "buffer" baseParseFrame_buffer = AttrLabelProxy #endif {- | Get the value of the “@out_buffer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' baseParseFrame #outBuffer @ -} getBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> m (Maybe Gst.Buffer.Buffer) getBaseParseFrameOutBuffer s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Buffer.Buffer) result <- SP.convertIfNonNull val $ \val' -> do val'' <- (newBoxed Gst.Buffer.Buffer) val' return val'' return result {- | Set the value of the “@out_buffer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' baseParseFrame [ #outBuffer 'Data.GI.Base.Attributes.:=' value ] @ -} setBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> Ptr Gst.Buffer.Buffer -> m () setBaseParseFrameOutBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Ptr Gst.Buffer.Buffer) {- | Set the value of the “@out_buffer@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #outBuffer @ -} clearBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> m () clearBaseParseFrameOutBuffer s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) #if ENABLE_OVERLOADING data BaseParseFrameOutBufferFieldInfo instance AttrInfo BaseParseFrameOutBufferFieldInfo where type AttrAllowedOps BaseParseFrameOutBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint BaseParseFrameOutBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) type AttrBaseTypeConstraint BaseParseFrameOutBufferFieldInfo = (~) BaseParseFrame type AttrGetType BaseParseFrameOutBufferFieldInfo = Maybe Gst.Buffer.Buffer type AttrLabel BaseParseFrameOutBufferFieldInfo = "out_buffer" type AttrOrigin BaseParseFrameOutBufferFieldInfo = BaseParseFrame attrGet _ = getBaseParseFrameOutBuffer attrSet _ = setBaseParseFrameOutBuffer attrConstruct = undefined attrClear _ = clearBaseParseFrameOutBuffer baseParseFrame_outBuffer :: AttrLabelProxy "outBuffer" baseParseFrame_outBuffer = AttrLabelProxy #endif {- | Get the value of the “@flags@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' baseParseFrame #flags @ -} getBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> m Word32 getBaseParseFrameFlags s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 16) :: IO Word32 return val {- | Set the value of the “@flags@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' baseParseFrame [ #flags 'Data.GI.Base.Attributes.:=' value ] @ -} setBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> Word32 -> m () setBaseParseFrameFlags s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 16) (val :: Word32) #if ENABLE_OVERLOADING data BaseParseFrameFlagsFieldInfo instance AttrInfo BaseParseFrameFlagsFieldInfo where type AttrAllowedOps BaseParseFrameFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BaseParseFrameFlagsFieldInfo = (~) Word32 type AttrBaseTypeConstraint BaseParseFrameFlagsFieldInfo = (~) BaseParseFrame type AttrGetType BaseParseFrameFlagsFieldInfo = Word32 type AttrLabel BaseParseFrameFlagsFieldInfo = "flags" type AttrOrigin BaseParseFrameFlagsFieldInfo = BaseParseFrame attrGet _ = getBaseParseFrameFlags attrSet _ = setBaseParseFrameFlags attrConstruct = undefined attrClear _ = undefined baseParseFrame_flags :: AttrLabelProxy "flags" baseParseFrame_flags = AttrLabelProxy #endif {- | Get the value of the “@offset@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' baseParseFrame #offset @ -} getBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> m Word64 getBaseParseFrameOffset s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 24) :: IO Word64 return val {- | Set the value of the “@offset@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' baseParseFrame [ #offset 'Data.GI.Base.Attributes.:=' value ] @ -} setBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> Word64 -> m () setBaseParseFrameOffset s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 24) (val :: Word64) #if ENABLE_OVERLOADING data BaseParseFrameOffsetFieldInfo instance AttrInfo BaseParseFrameOffsetFieldInfo where type AttrAllowedOps BaseParseFrameOffsetFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BaseParseFrameOffsetFieldInfo = (~) Word64 type AttrBaseTypeConstraint BaseParseFrameOffsetFieldInfo = (~) BaseParseFrame type AttrGetType BaseParseFrameOffsetFieldInfo = Word64 type AttrLabel BaseParseFrameOffsetFieldInfo = "offset" type AttrOrigin BaseParseFrameOffsetFieldInfo = BaseParseFrame attrGet _ = getBaseParseFrameOffset attrSet _ = setBaseParseFrameOffset attrConstruct = undefined attrClear _ = undefined baseParseFrame_offset :: AttrLabelProxy "offset" baseParseFrame_offset = AttrLabelProxy #endif {- | Get the value of the “@overhead@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' baseParseFrame #overhead @ -} getBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> m Int32 getBaseParseFrameOverhead s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 32) :: IO Int32 return val {- | Set the value of the “@overhead@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' baseParseFrame [ #overhead 'Data.GI.Base.Attributes.:=' value ] @ -} setBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> Int32 -> m () setBaseParseFrameOverhead s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 32) (val :: Int32) #if ENABLE_OVERLOADING data BaseParseFrameOverheadFieldInfo instance AttrInfo BaseParseFrameOverheadFieldInfo where type AttrAllowedOps BaseParseFrameOverheadFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BaseParseFrameOverheadFieldInfo = (~) Int32 type AttrBaseTypeConstraint BaseParseFrameOverheadFieldInfo = (~) BaseParseFrame type AttrGetType BaseParseFrameOverheadFieldInfo = Int32 type AttrLabel BaseParseFrameOverheadFieldInfo = "overhead" type AttrOrigin BaseParseFrameOverheadFieldInfo = BaseParseFrame attrGet _ = getBaseParseFrameOverhead attrSet _ = setBaseParseFrameOverhead attrConstruct = undefined attrClear _ = undefined baseParseFrame_overhead :: AttrLabelProxy "overhead" baseParseFrame_overhead = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList BaseParseFrame type instance O.AttributeList BaseParseFrame = BaseParseFrameAttributeList type BaseParseFrameAttributeList = ('[ '("buffer", BaseParseFrameBufferFieldInfo), '("outBuffer", BaseParseFrameOutBufferFieldInfo), '("flags", BaseParseFrameFlagsFieldInfo), '("offset", BaseParseFrameOffsetFieldInfo), '("overhead", BaseParseFrameOverheadFieldInfo)] :: [(Symbol, *)]) #endif -- method BaseParseFrame::new -- method type : Constructor -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overhead", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in this frame which should be counted as\n metadata overhead, ie. not used to calculate the average bitrate.\n Set to -1 to mark the entire frame as metadata. If in doubt, set to 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})) -- throws : False -- Skip return : False foreign import ccall "gst_base_parse_frame_new" gst_base_parse_frame_new :: Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) CUInt -> -- flags : TInterface (Name {namespace = "GstBase", name = "BaseParseFrameFlags"}) Int32 -> -- overhead : TBasicType TInt IO (Ptr BaseParseFrame) {- | Allocates a new 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. This function is mainly for bindings, elements written in C should usually allocate the frame on the stack and then use 'GI.GstBase.Structs.BaseParseFrame.baseParseFrameInit' to initialise it. -} baseParseFrameNew :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Buffer.Buffer {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} -> [GstBase.Flags.BaseParseFrameFlags] {- ^ /@flags@/: the flags -} -> Int32 {- ^ /@overhead@/: number of bytes in this frame which should be counted as metadata overhead, ie. not used to calculate the average bitrate. Set to -1 to mark the entire frame as metadata. If in doubt, set to 0. -} -> m BaseParseFrame {- ^ __Returns:__ a newly-allocated 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. Free with 'GI.GstBase.Structs.BaseParseFrame.baseParseFrameFree' when no longer needed. -} baseParseFrameNew buffer flags overhead = liftIO $ do buffer' <- unsafeManagedPtrGetPtr buffer let flags' = gflagsToWord flags result <- gst_base_parse_frame_new buffer' flags' overhead checkUnexpectedReturnNULL "baseParseFrameNew" result result' <- (wrapBoxed BaseParseFrame) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING #endif -- method BaseParseFrame::copy -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBaseParseFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})) -- throws : False -- Skip return : False foreign import ccall "gst_base_parse_frame_copy" gst_base_parse_frame_copy :: Ptr BaseParseFrame -> -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}) IO (Ptr BaseParseFrame) {- | Copies a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. -} baseParseFrameCopy :: (B.CallStack.HasCallStack, MonadIO m) => BaseParseFrame {- ^ /@frame@/: a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' -} -> m BaseParseFrame {- ^ __Returns:__ A copy of /@frame@/ -} baseParseFrameCopy frame = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame result <- gst_base_parse_frame_copy frame' checkUnexpectedReturnNULL "baseParseFrameCopy" result result' <- (wrapBoxed BaseParseFrame) result touchManagedPtr frame return result' #if ENABLE_OVERLOADING data BaseParseFrameCopyMethodInfo instance (signature ~ (m BaseParseFrame), MonadIO m) => O.MethodInfo BaseParseFrameCopyMethodInfo BaseParseFrame signature where overloadedMethod _ = baseParseFrameCopy #endif -- method BaseParseFrame::free -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstBaseParseFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_base_parse_frame_free" gst_base_parse_frame_free :: Ptr BaseParseFrame -> -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}) IO () {- | Frees the provided /@frame@/. -} baseParseFrameFree :: (B.CallStack.HasCallStack, MonadIO m) => BaseParseFrame {- ^ /@frame@/: A 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' -} -> m () baseParseFrameFree frame = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame gst_base_parse_frame_free frame' touchManagedPtr frame return () #if ENABLE_OVERLOADING data BaseParseFrameFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BaseParseFrameFreeMethodInfo BaseParseFrame signature where overloadedMethod _ = baseParseFrameFree #endif -- method BaseParseFrame::init -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstBaseParseFrame.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_base_parse_frame_init" gst_base_parse_frame_init :: Ptr BaseParseFrame -> -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}) IO () {- | Sets a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' to initial state. Currently this means all public fields are zero-ed and a private flag is set to make sure 'GI.GstBase.Structs.BaseParseFrame.baseParseFrameFree' only frees the contents but not the actual frame. Use this function to initialise a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' allocated on the stack. -} baseParseFrameInit :: (B.CallStack.HasCallStack, MonadIO m) => BaseParseFrame {- ^ /@frame@/: 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. -} -> m () baseParseFrameInit frame = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame gst_base_parse_frame_init frame' touchManagedPtr frame return () #if ENABLE_OVERLOADING data BaseParseFrameInitMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BaseParseFrameInitMethodInfo BaseParseFrame signature where overloadedMethod _ = baseParseFrameInit #endif #if ENABLE_OVERLOADING type family ResolveBaseParseFrameMethod (t :: Symbol) (o :: *) :: * where ResolveBaseParseFrameMethod "copy" o = BaseParseFrameCopyMethodInfo ResolveBaseParseFrameMethod "free" o = BaseParseFrameFreeMethodInfo ResolveBaseParseFrameMethod "init" o = BaseParseFrameInitMethodInfo ResolveBaseParseFrameMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveBaseParseFrameMethod t BaseParseFrame, O.MethodInfo info BaseParseFrame p) => OL.IsLabel t (BaseParseFrame -> 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