System.Win32.Com.HDirect.Pointer

This module is part of HaskellDirect (H/Direct), providing helper functions over Ptrs + allocation/freeing of memory via malloc/free or the COM task allocator.

Documentation

data Ptr a :: * -> *

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

Eq (Ptr a)

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Ord (Ptr a)

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Show (Ptr a)

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Foldable (URec (Ptr ()))

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Traversable (URec (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b)

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b)

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)

Storable (Ptr a)

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Variant (Ptr a)

Methods

inVariant :: ArgIn (Ptr a)

inVarList :: ArgIn [Ptr a]

inVarIUnknown :: ArgIn (IUnknown (Ptr a))

vtEltType :: Ptr a -> VARENUM

resVariant :: ArgRes (Ptr a)

defaultVariant :: Ptr a

resVarList :: ArgRes [Ptr a]

resVarIUnknown :: ArgRes (IUnknown (Ptr a))

resVarIDispatch :: ArgRes (IDispatch (Ptr a))

allocMemory :: Word32 -> IO (Ptr a)

stackFrame :: Word32 -> (Ptr a -> IO b) -> IO b

Use stackFrame when the allocated chunk have a limited and known lifetime.

writeSeqAtDec :: Word32 -> [Ptr a -> IO ()] -> Ptr a -> IO ()

freeMemory :: Ptr a -> IO ()

freeBSTR :: Ptr a -> IO ()

freeWith :: (Ptr a -> IO ()) -> Ptr a -> IO ()

freeWithC :: Finalizer () -> Ptr a -> IO ()

primNoFree :: Ptr () -> IO ()

finalNoFree :: Ptr ()

finalFreeMemory :: Ptr ()

makeFO :: Ptr a -> FunPtr (Ptr a -> IO ()) -> IO (ForeignPtr b)