{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.GstBase.Structs.BitReader.BitReader' provides a bit reader that can read any number of bits from a memory buffer. It provides functions for reading any number of bits into 8, 16, 32 and 64 bit variables. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GstBase.Structs.BitReader ( -- * Exported types BitReader(..) , newZeroBitReader , noBitReader , -- * Methods -- ** free #method:free# #if ENABLE_OVERLOADING BitReaderFreeMethodInfo , #endif bitReaderFree , -- ** getBitsUint16 #method:getBitsUint16# #if ENABLE_OVERLOADING BitReaderGetBitsUint16MethodInfo , #endif bitReaderGetBitsUint16 , -- ** getBitsUint32 #method:getBitsUint32# #if ENABLE_OVERLOADING BitReaderGetBitsUint32MethodInfo , #endif bitReaderGetBitsUint32 , -- ** getBitsUint64 #method:getBitsUint64# #if ENABLE_OVERLOADING BitReaderGetBitsUint64MethodInfo , #endif bitReaderGetBitsUint64 , -- ** getBitsUint8 #method:getBitsUint8# #if ENABLE_OVERLOADING BitReaderGetBitsUint8MethodInfo , #endif bitReaderGetBitsUint8 , -- ** getPos #method:getPos# #if ENABLE_OVERLOADING BitReaderGetPosMethodInfo , #endif bitReaderGetPos , -- ** getRemaining #method:getRemaining# #if ENABLE_OVERLOADING BitReaderGetRemainingMethodInfo , #endif bitReaderGetRemaining , -- ** getSize #method:getSize# #if ENABLE_OVERLOADING BitReaderGetSizeMethodInfo , #endif bitReaderGetSize , -- ** init #method:init# #if ENABLE_OVERLOADING BitReaderInitMethodInfo , #endif bitReaderInit , -- ** peekBitsUint16 #method:peekBitsUint16# #if ENABLE_OVERLOADING BitReaderPeekBitsUint16MethodInfo , #endif bitReaderPeekBitsUint16 , -- ** peekBitsUint32 #method:peekBitsUint32# #if ENABLE_OVERLOADING BitReaderPeekBitsUint32MethodInfo , #endif bitReaderPeekBitsUint32 , -- ** peekBitsUint64 #method:peekBitsUint64# #if ENABLE_OVERLOADING BitReaderPeekBitsUint64MethodInfo , #endif bitReaderPeekBitsUint64 , -- ** peekBitsUint8 #method:peekBitsUint8# #if ENABLE_OVERLOADING BitReaderPeekBitsUint8MethodInfo , #endif bitReaderPeekBitsUint8 , -- ** setPos #method:setPos# #if ENABLE_OVERLOADING BitReaderSetPosMethodInfo , #endif bitReaderSetPos , -- ** skip #method:skip# #if ENABLE_OVERLOADING BitReaderSkipMethodInfo , #endif bitReaderSkip , -- ** skipToByte #method:skipToByte# #if ENABLE_OVERLOADING BitReaderSkipToByteMethodInfo , #endif bitReaderSkipToByte , -- * Properties -- ** bit #attr:bit# {- | Bit position in the current byte -} #if ENABLE_OVERLOADING bitReader_bit , #endif getBitReaderBit , setBitReaderBit , -- ** byte #attr:byte# {- | Current byte position -} #if ENABLE_OVERLOADING bitReader_byte , #endif getBitReaderByte , setBitReaderByte , -- ** size #attr:size# {- | Size of /@data@/ in bytes -} #if ENABLE_OVERLOADING bitReader_size , #endif getBitReaderSize , setBitReaderSize , ) 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 -- | Memory-managed wrapper type. newtype BitReader = BitReader (ManagedPtr BitReader) instance WrappedPtr BitReader where wrappedPtrCalloc = callocBytes 56 wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr BitReader) wrappedPtrFree = Just ptr_to_g_free -- | Construct a `BitReader` struct initialized to zero. newZeroBitReader :: MonadIO m => m BitReader newZeroBitReader = liftIO $ wrappedPtrCalloc >>= wrapPtr BitReader instance tag ~ 'AttrSet => Constructible BitReader tag where new _ attrs = do o <- newZeroBitReader GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `BitReader`. noBitReader :: Maybe BitReader noBitReader = Nothing -- XXX Skipped attribute for "BitReader:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 1 (TBasicType TUInt8)" {- | Get the value of the “@size@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' bitReader #size @ -} getBitReaderSize :: MonadIO m => BitReader -> m Word32 getBitReaderSize s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO Word32 return val {- | Set the value of the “@size@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' bitReader [ #size 'Data.GI.Base.Attributes.:=' value ] @ -} setBitReaderSize :: MonadIO m => BitReader -> Word32 -> m () setBitReaderSize s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Word32) #if ENABLE_OVERLOADING data BitReaderSizeFieldInfo instance AttrInfo BitReaderSizeFieldInfo where type AttrAllowedOps BitReaderSizeFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BitReaderSizeFieldInfo = (~) Word32 type AttrBaseTypeConstraint BitReaderSizeFieldInfo = (~) BitReader type AttrGetType BitReaderSizeFieldInfo = Word32 type AttrLabel BitReaderSizeFieldInfo = "size" type AttrOrigin BitReaderSizeFieldInfo = BitReader attrGet _ = getBitReaderSize attrSet _ = setBitReaderSize attrConstruct = undefined attrClear _ = undefined bitReader_size :: AttrLabelProxy "size" bitReader_size = AttrLabelProxy #endif {- | Get the value of the “@byte@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' bitReader #byte @ -} getBitReaderByte :: MonadIO m => BitReader -> m Word32 getBitReaderByte s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 12) :: IO Word32 return val {- | Set the value of the “@byte@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' bitReader [ #byte 'Data.GI.Base.Attributes.:=' value ] @ -} setBitReaderByte :: MonadIO m => BitReader -> Word32 -> m () setBitReaderByte s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 12) (val :: Word32) #if ENABLE_OVERLOADING data BitReaderByteFieldInfo instance AttrInfo BitReaderByteFieldInfo where type AttrAllowedOps BitReaderByteFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BitReaderByteFieldInfo = (~) Word32 type AttrBaseTypeConstraint BitReaderByteFieldInfo = (~) BitReader type AttrGetType BitReaderByteFieldInfo = Word32 type AttrLabel BitReaderByteFieldInfo = "byte" type AttrOrigin BitReaderByteFieldInfo = BitReader attrGet _ = getBitReaderByte attrSet _ = setBitReaderByte attrConstruct = undefined attrClear _ = undefined bitReader_byte :: AttrLabelProxy "byte" bitReader_byte = AttrLabelProxy #endif {- | Get the value of the “@bit@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' bitReader #bit @ -} getBitReaderBit :: MonadIO m => BitReader -> m Word32 getBitReaderBit s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 16) :: IO Word32 return val {- | Set the value of the “@bit@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' bitReader [ #bit 'Data.GI.Base.Attributes.:=' value ] @ -} setBitReaderBit :: MonadIO m => BitReader -> Word32 -> m () setBitReaderBit s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 16) (val :: Word32) #if ENABLE_OVERLOADING data BitReaderBitFieldInfo instance AttrInfo BitReaderBitFieldInfo where type AttrAllowedOps BitReaderBitFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint BitReaderBitFieldInfo = (~) Word32 type AttrBaseTypeConstraint BitReaderBitFieldInfo = (~) BitReader type AttrGetType BitReaderBitFieldInfo = Word32 type AttrLabel BitReaderBitFieldInfo = "bit" type AttrOrigin BitReaderBitFieldInfo = BitReader attrGet _ = getBitReaderBit attrSet _ = setBitReaderBit attrConstruct = undefined attrClear _ = undefined bitReader_bit :: AttrLabelProxy "bit" bitReader_bit = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList BitReader type instance O.AttributeList BitReader = BitReaderAttributeList type BitReaderAttributeList = ('[ '("size", BitReaderSizeFieldInfo), '("byte", BitReaderByteFieldInfo), '("bit", BitReaderBitFieldInfo)] :: [(Symbol, *)]) #endif -- method BitReader::free -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_free" gst_bit_reader_free :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) IO () {- | Frees a 'GI.GstBase.Structs.BitReader.BitReader' instance, which was previously allocated by @/gst_bit_reader_new()/@. -} bitReaderFree :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> m () bitReaderFree reader = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader gst_bit_reader_free reader' touchManagedPtr reader return () #if ENABLE_OVERLOADING data BitReaderFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BitReaderFreeMethodInfo BitReader signature where overloadedMethod _ = bitReaderFree #endif -- method BitReader::get_bits_uint16 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint16 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_bits_uint16" gst_bit_reader_get_bits_uint16 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word16 -> -- val : TBasicType TUInt16 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ and update the current position. -} bitReaderGetBitsUint16 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word16)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderGetBitsUint16 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word16) result <- gst_bit_reader_get_bits_uint16 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderGetBitsUint16MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word16))), MonadIO m) => O.MethodInfo BitReaderGetBitsUint16MethodInfo BitReader signature where overloadedMethod _ = bitReaderGetBitsUint16 #endif -- method BitReader::get_bits_uint32 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint32 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_bits_uint32" gst_bit_reader_get_bits_uint32 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word32 -> -- val : TBasicType TUInt32 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ and update the current position. -} bitReaderGetBitsUint32 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word32)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderGetBitsUint32 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word32) result <- gst_bit_reader_get_bits_uint32 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderGetBitsUint32MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word32))), MonadIO m) => O.MethodInfo BitReaderGetBitsUint32MethodInfo BitReader signature where overloadedMethod _ = bitReaderGetBitsUint32 #endif -- method BitReader::get_bits_uint64 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint64 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_bits_uint64" gst_bit_reader_get_bits_uint64 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word64 -> -- val : TBasicType TUInt64 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ and update the current position. -} bitReaderGetBitsUint64 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word64)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderGetBitsUint64 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word64) result <- gst_bit_reader_get_bits_uint64 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderGetBitsUint64MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word64))), MonadIO m) => O.MethodInfo BitReaderGetBitsUint64MethodInfo BitReader signature where overloadedMethod _ = bitReaderGetBitsUint64 #endif -- method BitReader::get_bits_uint8 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint8 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_bits_uint8" gst_bit_reader_get_bits_uint8 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word8 -> -- val : TBasicType TUInt8 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ and update the current position. -} bitReaderGetBitsUint8 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word8)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderGetBitsUint8 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word8) result <- gst_bit_reader_get_bits_uint8 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderGetBitsUint8MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word8))), MonadIO m) => O.MethodInfo BitReaderGetBitsUint8MethodInfo BitReader signature where overloadedMethod _ = bitReaderGetBitsUint8 #endif -- method BitReader::get_pos -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_pos" gst_bit_reader_get_pos :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) IO Word32 {- | Returns the current position of a 'GI.GstBase.Structs.BitReader.BitReader' instance in bits. -} bitReaderGetPos :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> m Word32 {- ^ __Returns:__ The current position of /@reader@/ in bits. -} bitReaderGetPos reader = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_get_pos reader' touchManagedPtr reader return result #if ENABLE_OVERLOADING data BitReaderGetPosMethodInfo instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BitReaderGetPosMethodInfo BitReader signature where overloadedMethod _ = bitReaderGetPos #endif -- method BitReader::get_remaining -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_remaining" gst_bit_reader_get_remaining :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) IO Word32 {- | Returns the remaining number of bits of a 'GI.GstBase.Structs.BitReader.BitReader' instance. -} bitReaderGetRemaining :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> m Word32 {- ^ __Returns:__ The remaining number of bits of /@reader@/ instance. -} bitReaderGetRemaining reader = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_get_remaining reader' touchManagedPtr reader return result #if ENABLE_OVERLOADING data BitReaderGetRemainingMethodInfo instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BitReaderGetRemainingMethodInfo BitReader signature where overloadedMethod _ = bitReaderGetRemaining #endif -- method BitReader::get_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_get_size" gst_bit_reader_get_size :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) IO Word32 {- | Returns the total number of bits of a 'GI.GstBase.Structs.BitReader.BitReader' instance. -} bitReaderGetSize :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> m Word32 {- ^ __Returns:__ The total number of bits of /@reader@/ instance. -} bitReaderGetSize reader = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_get_size reader' touchManagedPtr reader return result #if ENABLE_OVERLOADING data BitReaderGetSizeMethodInfo instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BitReaderGetSizeMethodInfo BitReader signature where overloadedMethod _ = bitReaderGetSize #endif -- method BitReader::init -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data from which the bit reader should read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_init" gst_bit_reader_init :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) Word32 -> -- size : TBasicType TUInt IO () {- | Initializes a 'GI.GstBase.Structs.BitReader.BitReader' instance to read from /@data@/. This function can be called on already initialized instances. -} bitReaderInit :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> ByteString {- ^ /@data@/: data from which the bit reader should read -} -> m () bitReaderInit reader data_ = liftIO $ do let size = fromIntegral $ B.length data_ reader' <- unsafeManagedPtrGetPtr reader data_' <- packByteString data_ gst_bit_reader_init reader' data_' size touchManagedPtr reader freeMem data_' return () #if ENABLE_OVERLOADING data BitReaderInitMethodInfo instance (signature ~ (ByteString -> m ()), MonadIO m) => O.MethodInfo BitReaderInitMethodInfo BitReader signature where overloadedMethod _ = bitReaderInit #endif -- method BitReader::peek_bits_uint16 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint16 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_peek_bits_uint16" gst_bit_reader_peek_bits_uint16 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word16 -> -- val : TBasicType TUInt16 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ but keep the current position. -} bitReaderPeekBitsUint16 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word16)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderPeekBitsUint16 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word16) result <- gst_bit_reader_peek_bits_uint16 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderPeekBitsUint16MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word16))), MonadIO m) => O.MethodInfo BitReaderPeekBitsUint16MethodInfo BitReader signature where overloadedMethod _ = bitReaderPeekBitsUint16 #endif -- method BitReader::peek_bits_uint32 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint32 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_peek_bits_uint32" gst_bit_reader_peek_bits_uint32 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word32 -> -- val : TBasicType TUInt32 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ but keep the current position. -} bitReaderPeekBitsUint32 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word32)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderPeekBitsUint32 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word32) result <- gst_bit_reader_peek_bits_uint32 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderPeekBitsUint32MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word32))), MonadIO m) => O.MethodInfo BitReaderPeekBitsUint32MethodInfo BitReader signature where overloadedMethod _ = bitReaderPeekBitsUint32 #endif -- method BitReader::peek_bits_uint64 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint64 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_peek_bits_uint64" gst_bit_reader_peek_bits_uint64 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word64 -> -- val : TBasicType TUInt64 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ but keep the current position. -} bitReaderPeekBitsUint64 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word64)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderPeekBitsUint64 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word64) result <- gst_bit_reader_peek_bits_uint64 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderPeekBitsUint64MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word64))), MonadIO m) => O.MethodInfo BitReaderPeekBitsUint64MethodInfo BitReader signature where overloadedMethod _ = bitReaderPeekBitsUint64 #endif -- method BitReader::peek_bits_uint8 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint8 to store the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bits to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_peek_bits_uint8" gst_bit_reader_peek_bits_uint8 :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Ptr Word8 -> -- val : TBasicType TUInt8 Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Read /@nbits@/ bits into /@val@/ but keep the current position. -} bitReaderPeekBitsUint8 :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: number of bits to read -} -> m ((Bool, Word8)) {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderPeekBitsUint8 reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader val <- allocMem :: IO (Ptr Word8) result <- gst_bit_reader_peek_bits_uint8 reader' val nbits let result' = (/= 0) result val' <- peek val touchManagedPtr reader freeMem val return (result', val') #if ENABLE_OVERLOADING data BitReaderPeekBitsUint8MethodInfo instance (signature ~ (Word32 -> m ((Bool, Word8))), MonadIO m) => O.MethodInfo BitReaderPeekBitsUint8MethodInfo BitReader signature where overloadedMethod _ = bitReaderPeekBitsUint8 #endif -- method BitReader::set_pos -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new position in bits", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_set_pos" gst_bit_reader_set_pos :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Word32 -> -- pos : TBasicType TUInt IO CInt {- | Sets the new position of a 'GI.GstBase.Structs.BitReader.BitReader' instance to /@pos@/ in bits. -} bitReaderSetPos :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@pos@/: The new position in bits -} -> m Bool {- ^ __Returns:__ 'True' if the position could be set successfully, 'False' otherwise. -} bitReaderSetPos reader pos = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_set_pos reader' pos let result' = (/= 0) result touchManagedPtr reader return result' #if ENABLE_OVERLOADING data BitReaderSetPosMethodInfo instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo BitReaderSetPosMethodInfo BitReader signature where overloadedMethod _ = bitReaderSetPos #endif -- method BitReader::skip -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbits", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bits to skip", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_skip" gst_bit_reader_skip :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) Word32 -> -- nbits : TBasicType TUInt IO CInt {- | Skips /@nbits@/ bits of the 'GI.GstBase.Structs.BitReader.BitReader' instance. -} bitReaderSkip :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> Word32 {- ^ /@nbits@/: the number of bits to skip -} -> m Bool {- ^ __Returns:__ 'True' if /@nbits@/ bits could be skipped, 'False' otherwise. -} bitReaderSkip reader nbits = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_skip reader' nbits let result' = (/= 0) result touchManagedPtr reader return result' #if ENABLE_OVERLOADING data BitReaderSkipMethodInfo instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo BitReaderSkipMethodInfo BitReader signature where overloadedMethod _ = bitReaderSkip #endif -- method BitReader::skip_to_byte -- method type : OrdinaryMethod -- Args : [Arg {argCName = "reader", argType = TInterface (Name {namespace = "GstBase", name = "BitReader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBitReader instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bit_reader_skip_to_byte" gst_bit_reader_skip_to_byte :: Ptr BitReader -> -- reader : TInterface (Name {namespace = "GstBase", name = "BitReader"}) IO CInt {- | Skips until the next byte. -} bitReaderSkipToByte :: (B.CallStack.HasCallStack, MonadIO m) => BitReader {- ^ /@reader@/: a 'GI.GstBase.Structs.BitReader.BitReader' instance -} -> m Bool {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -} bitReaderSkipToByte reader = liftIO $ do reader' <- unsafeManagedPtrGetPtr reader result <- gst_bit_reader_skip_to_byte reader' let result' = (/= 0) result touchManagedPtr reader return result' #if ENABLE_OVERLOADING data BitReaderSkipToByteMethodInfo instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BitReaderSkipToByteMethodInfo BitReader signature where overloadedMethod _ = bitReaderSkipToByte #endif #if ENABLE_OVERLOADING type family ResolveBitReaderMethod (t :: Symbol) (o :: *) :: * where ResolveBitReaderMethod "free" o = BitReaderFreeMethodInfo ResolveBitReaderMethod "init" o = BitReaderInitMethodInfo ResolveBitReaderMethod "peekBitsUint16" o = BitReaderPeekBitsUint16MethodInfo ResolveBitReaderMethod "peekBitsUint32" o = BitReaderPeekBitsUint32MethodInfo ResolveBitReaderMethod "peekBitsUint64" o = BitReaderPeekBitsUint64MethodInfo ResolveBitReaderMethod "peekBitsUint8" o = BitReaderPeekBitsUint8MethodInfo ResolveBitReaderMethod "skip" o = BitReaderSkipMethodInfo ResolveBitReaderMethod "skipToByte" o = BitReaderSkipToByteMethodInfo ResolveBitReaderMethod "getBitsUint16" o = BitReaderGetBitsUint16MethodInfo ResolveBitReaderMethod "getBitsUint32" o = BitReaderGetBitsUint32MethodInfo ResolveBitReaderMethod "getBitsUint64" o = BitReaderGetBitsUint64MethodInfo ResolveBitReaderMethod "getBitsUint8" o = BitReaderGetBitsUint8MethodInfo ResolveBitReaderMethod "getPos" o = BitReaderGetPosMethodInfo ResolveBitReaderMethod "getRemaining" o = BitReaderGetRemainingMethodInfo ResolveBitReaderMethod "getSize" o = BitReaderGetSizeMethodInfo ResolveBitReaderMethod "setPos" o = BitReaderSetPosMethodInfo ResolveBitReaderMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveBitReaderMethod t BitReader, O.MethodInfo info BitReader p) => OL.IsLabel t (BitReader -> 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