Foreign.Hoppy.Runtime

Runtime support for generated Haskell bindings.

Primitive types

newtype CBool

A numeric type representing a C++ boolean.

Constructors

CBool CUChar

Instances

Bounded CBool

Enum CBool

Eq CBool

Integral CBool

Num CBool

Ord CBool

Real CBool

Show CBool

Storable CBool

Decodable (Ptr CBool) Bool

Assignable (Ptr CBool) Bool

newtype CUChar :: *

Haskell type representing the C unsigned char type.

Constructors

CUChar Word8

Instances

Bounded CUChar

Enum CUChar

Eq CUChar

Integral CUChar

Num CUChar

Ord CUChar

Read CUChar

Real CUChar

Show CUChar

Storable CUChar

Bits CUChar

FiniteBits CUChar

Decodable (Ptr CUChar) CUChar

coerceIntegral :: (Integral a, Integral b, Typeable a, Typeable b, Show a) => a -> b

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

An instance of this class represents a pointer to a C++ object. All C++ classes bound by Hoppy have instances of CppPtr.

Methods

nullptr :: this

Polymorphic null pointer.

toPtr :: this -> Ptr this

Converts to a regular pointer.

class Deletable this where

C++ values that can be deleted. All C++ classes bound by Hoppy have instances of Deletable.

Methods

delete :: this -> IO ()

Deletes the object with the C++ delete operator.

class Assignable cppType value where

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).

Methods

assign :: cppType -> value -> IO ()

assign x v assigns the value v at the location pointed to by x.

Instances

Storable a => Assignable (Ptr a) a

Assignable (Ptr CBool) Bool

class Encodable cppPtrType hsType | cppPtrType -> hsType where

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 value are ambiguously typed, so encodeAs is provided to resolve the ambiguity.

Prefer withCppObj over calling encode directly, to manage the lifetime of the object.

See also Decodable.

Methods

encode :: hsType -> IO cppPtrType

encodeAs :: Encodable cppPtrType hsType => cppPtrType -> hsType -> IO cppPtrType

Takes a dummy argument to help with type resolution of encode, a la asTypeOf. For example, for a C++ pointer type StdString that gets converted to a regular haskell String, the expected usage is:

str :: String
encodeAs (undefined :: StdString) str

class Decodable cppPtrType hsType | cppPtrType -> hsType where

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 ...)) are decodable by peeking at the value.

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.

Methods

decode :: cppPtrType -> IO hsType

Instances

Decodable (Ptr CChar) CChar

Decodable (Ptr CUChar) CUChar

Decodable (Ptr CShort) CShort

Decodable (Ptr CUShort) CUShort

Decodable (Ptr CInt) CInt

Decodable (Ptr CUInt) CUInt

Decodable (Ptr CLong) CLong

Decodable (Ptr CULong) CULong

Decodable (Ptr CLLong) CLLong

Decodable (Ptr CULLong) CULLong

Decodable (Ptr CFloat) CFloat

Decodable (Ptr CDouble) CDouble

Decodable (Ptr CSize) CSize

Decodable (Ptr CBool) Bool

Decodable (Ptr (Ptr a)) (Ptr a)

decodeAndDelete :: (Deletable cppPtrType, Decodable cppPtrType hsType) => cppPtrType -> IO hsType

Decodes a C++ object to a Haskell value with decode, releases the original object with delete, then returns the Haskell value.

withCppObj :: (Deletable cppPtrType, Encodable cppPtrType hsType) => hsType -> (cppPtrType -> IO a) -> IO a

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

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

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

Methods

toContents :: c -> IO [e]

Extracts the contents of a container, returning the elements in a list.

class FromContents c e | c -> e where

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.

Methods

fromContents :: [e] -> IO c

Creates and returns a new container holding the given elements.

Internal

newtype CCallback fnHsCType

Internal type that represents a pointer to a C++ callback object (callback impl object, specifically).

Constructors

CCallback (Ptr ())

freeHaskellFunPtrFunPtr :: FunPtr (FunPtr (IO ()) -> IO ())

A global constant function pointer that points to freeHaskellFunPtr.