| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Foreign.Hoppy.Runtime
Description
Runtime support for generated Haskell bindings.
- newtype CBool = CBool CUChar
- newtype CUChar :: * = CUChar Word8
- coerceIntegral :: (Integral a, Integral b, Typeable a, Typeable b, Show a) => a -> b
- class CppPtr this where
- class Deletable this where
- class Assignable cppType value where
- class Encodable cppPtrType hsType | cppPtrType -> hsType where
- encodeAs :: Encodable cppPtrType hsType => cppPtrType -> hsType -> IO cppPtrType
- class Decodable cppPtrType hsType | cppPtrType -> hsType where
- decodeAndDelete :: (Deletable cppPtrType, Decodable cppPtrType hsType) => cppPtrType -> IO hsType
- withCppObj :: (Deletable cppPtrType, Encodable cppPtrType hsType) => hsType -> (cppPtrType -> IO a) -> IO a
- withScopedPtr :: Deletable cppPtrType => IO cppPtrType -> (cppPtrType -> IO a) -> IO a
- class HasContents c e | c -> e where
- class FromContents c e | c -> e where
- newtype CCallback fnHsCType = CCallback (Ptr ())
- freeHaskellFunPtrFunPtr :: FunPtr (FunPtr (IO ()) -> IO ())
Primitive types
A numeric type representing a C++ boolean.
Instances
| Bounded CBool Source # | |
| Enum CBool Source # | |
| Eq CBool Source # | |
| Integral CBool Source # | |
| Num CBool Source # | |
| Ord CBool Source # | |
| Real CBool Source # | |
| Show CBool Source # | |
| Storable CBool Source # | |
| Decodable (Ptr CBool) Bool Source # | |
| Assignable (Ptr CBool) Bool Source # | |
| Decodable (Ptr (Ptr CBool)) (Ptr CBool) Source # | |
Haskell type representing the C unsigned char type.
coerceIntegral :: (Integral a, Integral b, Typeable a, Typeable b, Show a) => a -> b Source #
Converts between integral types by going from a to b, and also
round-tripping the b value back to an a value. If the two a values
don't match, then an error is signalled.
Objects
class CppPtr this where Source #
An instance of this class represents a pointer to a C++ object. All C++
classes bound by Hoppy have instances of CppPtr. The lifetime of such an
object can optionally be managed by the Haskell garbage collector. Pointers
returned from constructors are unmanaged, and toGc converts an unmanaged
pointer to a managed one. delete must not be called on managed pointers.
Minimal complete definition
Methods
Polymorphic null pointer.
withCppPtr :: this -> (Ptr this -> IO a) -> IO a Source #
Runs an IO action on the Ptr underlying this pointer. Equivalent to
withForeignPtr for managed pointers: the Ptr is only
guaranteed to be valid until the action returns. There is no such
restriction for unmanaged pointers.
toPtr :: this -> Ptr this Source #
Converts to a regular pointer. For objects managed by the garbage
collector, this comes with the warnings associated with
unsafeForeignPtrToPtr, namely that the object
may be collected immediately after this function returns unless there is a
touchCppPtr call later on.
touchCppPtr :: this -> IO () Source #
Equivalent to touchForeignPtr for managed object
pointers. Has no effect on unmanaged pointers.
class Deletable this where Source #
C++ values that can be deleted. All C++ classes bound by Hoppy have
instances of Deletable.
Methods
delete :: this -> IO () Source #
Deletes the object with the C++ delete operator.
toGc :: this -> IO this Source #
Converts a pointer to one managed by the garbage collector. A new
managed pointer is returned, and existing pointers including the
argument remain unmanaged, becoming invalid once all managed pointers are
unreachable. Calling this on an already managed pointer has no effect and
the argument is simply returned. It is no longer safe to call delete on
the given object after calling this function. It is also not safe to call
this function on unmanaged pointers for a single object multiple times: the
object will get deleted more than once.
class Assignable cppType value where Source #
A typeclass for references to C++ values that can be assigned to. This
includes raw pointers (Ptr), as well as pointers to object types that have
an assignment operator (see
Assignable).
Minimal complete definition
class Encodable cppPtrType hsType | cppPtrType -> hsType where Source #
For a C++ class that also has a native Haskell representation (e.g. value
types such as std::string), this typeclass allows converting a Haskell
value into a C++ object on the heap. Encoding to both the non-const and
const objects is supported.
Because the functional dependency points in the direction it does, calls of
the form encode valueencodeAs is provided to
resolve the ambiguity.
Prefer withCppObj over calling encode directly, to manage the lifetime of
the object.
See also Decodable.
Minimal complete definition
class Decodable cppPtrType hsType | cppPtrType -> hsType where Source #
A typeclass for converting references to C++ values into Haskell values.
What this means depends on the type of C++ value. Pointers to numeric types
and to other pointers (i.e. Ptr (Ptr ...)
For a C++ class that also has a native Haskell representation (e.g. value
types such as std::string), this typeclass allows converting a C++ heap
object into a Haskell value based on the defined conversion. Decoding from
both the non-const and const objects is supported.
See also Encodable.
Minimal complete definition
Instances
decodeAndDelete :: (Deletable cppPtrType, Decodable cppPtrType hsType) => cppPtrType -> IO hsType Source #
withCppObj :: (Deletable cppPtrType, Encodable cppPtrType hsType) => hsType -> (cppPtrType -> IO a) -> IO a Source #
Temporarily encodes the Haskell value into a C++ object and passes it to the given function. When the function finishes, the C++ object is deleted.
withScopedPtr :: Deletable cppPtrType => IO cppPtrType -> (cppPtrType -> IO a) -> IO a Source #
withScopedPtr m f runs m to get a pointer, which is given to f to
execute. When f finishes, the pointer is deleted.
Containers
class HasContents c e | c -> e where Source #
Containers whose contents can be convered to a list.
For a container Cont holding values with C-side type Foo and Haskell-side
type Bar, if the container uses ConvertPtr
then the following instances are recommended:
instance HasContents ContConst FooConst instance HasContents Cont Foo
If the container uses ConvertValue then the
following instances are recommended:
instance HasContents ContConst Bar instance HasContents Cont Bar
Minimal complete definition
Methods
toContents :: c -> IO [e] Source #
Extracts the contents of a container, returning the elements in a list.
class FromContents c e | c -> e where Source #
Containers that can be created from a list.
For a container Cont holding values with C-side type Foo and Haskell-side
type Bar, if the container uses ConvertPtr
then the following instance is recommended:
instance FromContents Cont Foo
If the container uses ConvertValue then the
following instance is recommended:
instance HasContents Cont Bar
No instances for ContConst are needed because it is easy enough to cast the
resulting collection to a const pointer.
Minimal complete definition
Methods
fromContents :: [e] -> IO c Source #
Creates and returns a new container holding the given elements.
Internal
newtype CCallback fnHsCType Source #
Internal type that represents a pointer to a C++ callback object (callback impl object, specifically).
freeHaskellFunPtrFunPtr :: FunPtr (FunPtr (IO ()) -> IO ()) Source #
A global constant function pointer that points to freeHaskellFunPtr.