!*      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None 1;=>?ACKVJ. hoppy-runtime#Internal. Provides default values. hoppy-runtimegInternal type that represents a pointer to a C++ callback object (callback impl object, specifically). hoppy-runtime+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 - then the following instance is recommended: instance FromContents Cont FooIf the container uses - then the following instance is recommended: instance HasContents Cont BarNo instances for  ContConst[ are needed because it is easy enough to cast the resulting collection to a const pointer. hoppy-runtime?Creates and returns a new container holding the given elements. hoppy-runtime4Containers 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 / then the following instances are recommended: Einstance HasContents ContConst FooConst instance HasContents Cont FooIf the container uses / then the following instances are recommended: @instance HasContents ContConst Bar instance HasContents Cont Bar hoppy-runtimeGExtracts the contents of a container, returning the elements in a list. hoppy-runtime3Internal. Information about a C++ exception class.  hoppy-runtimevThis maps ancestor classes' exception IDs to functions that cast pointers from the current type to the ancestor type.  hoppy-runtimeDeletes the object. hoppy-runtime&Invokes the object's copy constructor. hoppy-runtime:Assigns the object to the Haskell garbage collector, a la (. hoppy-runtimeHInternal. A database of information about exceptions an interface uses. hoppy-runtimeInternal. Holds an arbitrary .Do not catch this with 0; this can leak exception objects. Always use 6 to catch C++ exceptions. hoppy-runtime8A top type for C++ exceptions. Catching this type with 6 will catch all C++ exceptions. (You still have to declare what exceptions can be thrown from each function, to make exceptions pass through the gateway properly.) hoppy-runtimeA typeclass for C++ values that are throwable as exceptions. C++ classes that have been declared to be used as exceptions have instances of this class. hoppy-runtimeInternal. Creates a throw!able exception from a C++ handle. hoppy-runtimeA typeclass for C++ values that are catchable as exceptions. C++ classes that have been declared to be used as exceptions have instances of this class. Unlike , ( is also an instance of this typeclass. hoppy-runtime0Internal. Returns metadata about the exception. hoppy-runtimeGInternal. Constructs a handle from a GC-managed object's raw pointers. hoppy-runtimeHInternal. Constructs a GC-managed handle from an unmanaged raw pointer. hoppy-runtimeOA unique identifier for a C++ class. The representation is internal to Hoppy. hoppy-runtimeA 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.  ( ...))) are decodable by peeking at the value.YFor 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  .  hoppy-runtimeYFor 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.VBecause the functional dependency points in the direction it does, calls of the form ! value are ambiguously typed, so 1' is provided to resolve the ambiguity.Prefer 3 over calling !1 directly, to manage the lifetime of the object. See also ." hoppy-runtimerA typeclass for creating copies of C++ objects. Every C++ class with a copy constructor will have two instances: 8instance Copyable Foo Foo instance Copyable FooConst Foo$ hoppy-runtime`A typeclass for references to C++ values that can be assigned to. This includes raw pointers (O), as well as handles for object types that have an assignment operator (see ).% hoppy-runtime assign x v assigns the value v at the location pointed to by x.& hoppy-runtimeC++ values that can be deleted. By default, C++ classes bound by Hoppy are assumed to be deletable, so they get instances of  Deletable.' hoppy-runtime Deletes the object with the C++ delete operator.( hoppy-runtime>Converts a handle to one managed by the garbage collector. A new3 managed handle is returned, and existing handles  including the argument remain unmanaged, becoming invalid once all managed handles are unreachable. Calling this on an already managed handle has no effect and the argument is simply returned. It is no longer safe to call ' on the given object after calling this function. It is also not safe to call this function on unmanaged handles for a single object multiple times: the object will get deleted more than once.EUp- and downcasting managed handles keeps the object alive correctly.) hoppy-runtime}An instance of this class represents a handle (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. Handles returned from constructors are unmanaged, and (2 converts an unmanaged handle to a managed one. '( must not be called on managed handles.* hoppy-runtime Polymorphic null pointer handle.+ hoppy-runtimeRuns an IO action on the ) underlying this handle. Equivalent to   for managed handles: the  is only guaranteed to be valid until the action returns. There is no such restriction for unmanaged handles, but of course the object must still be alive to be used., hoppy-runtime}Converts to a regular pointer. For objects managed by the garbage collector, this comes with the warnings associated with  f, namely that the object may be collected immediately after this function returns unless there is a - call later on.- hoppy-runtimeEquivalent to  ; for managed handles. Has no effect on unmanaged handles.. hoppy-runtime*A numeric type representing a C++ boolean.0 hoppy-runtime.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 a1 values don't match, then an error is signalled.1 hoppy-runtime7Takes a dummy argument to help with type resolution of !, a la ". For example, for a handle type  StdString+ that gets converted to a regular haskell , the expected usage is: 3str :: String encodeAs (undefined :: StdString) str2 hoppy-runtime-Decodes a C++ object to a Haskell value with %, releases the original object with '!, then returns the Haskell value.3 hoppy-runtimeTemporarily encodes the Haskell value into a C++ object and passes it to the given function. When the function finishes, the C++ object is deleted.4 hoppy-runtimewithScopedPtr m f runs m$ to get a handle, which is given to f to execute. When f& finishes, the handle is deleted (via  and ').5 hoppy-runtimewithScopedFunPtr m f runs m to get a , which is given to f to execute. When f finishes, the  is deleted (via  and c). This is useful in conjunction with function pointers created via generated callback functions.6 hoppy-runtime$Catches a C++ exception, similar to u. Catching an exception class will also catch subtypes of the class, per normal C++ exception semantics. Catching  will catch all C++ exceptions, but will provide no information about the caught exception. Exceptions caught with this function are GC-managed heap objects; you do not need to manually delete them.7 hoppy-runtimekTakes ownership of a C++ object, and throws it as a Haskell exception. This can be caught in Haskell with 6U, or propagated to C++ when within a callback that is marked as handling exceptions.8 hoppy-runtimejInternal. Wraps a call to a C++ gateway function, and provides propagation of C++ exceptions to Haskell.9 hoppy-runtimeInternal. Wraps a call to a Haskell function while invoking a callback, and provides propagation of C++ exceptions back into C++.: hoppy-runtime2A global constant function pointer that points to .;  !"#$%&'()*+,-./0123456789:;./0)*+,-&'($%"# !1234567:89 None 1;=>?ACKV  hoppy-runtime3Configuration parameters for a project using Hoppy. hoppy-runtime<The name of the executable program in the generator package. hoppy-runtime$The name of the C++ gateway package. hoppy-runtimeVThe directory into which to generate C++ sources, under the C++ gateway package root. hoppy-runtime^The directory into which to generate Haskell sources, under the Haskell gateway package root. hoppy-runtimeA main" implementation to be used in the Setup.hs of a C++ gateway package. cppMain project =  $  project hoppy-runtimevCabal user hooks for a C++ gateway package. When overriding fields in the result, be sure to call the previous hook. The following hooks are defined:D: Runs the generator program to generate C++ sources. Checks if a  configureP script exists in the C++ gateway root, and calls it if so (without arguments).: Runs make- with no arguments from the C++ gateway root. and : Runs make install libdir=$libdir where $libdirA is the directory into which to install the built shared library.5: Removes files created by the generator, then calls  make clean. hoppy-runtimeA main" implementation to be used in the Setup.hs of a Haskell gateway package. hsMain project =  $  project hoppy-runtimezCabal user hooks for a Haskell gateway package. When overriding fields in the result, be sure to call the previous hook. The following hooks are defined:g: Finds the shared library directory for the installed C++ gateway package, and writes this path to a dist/build/hoppy-cpp-libdir@ file. Runs the generator program to generate Haskell sources., , , , (: Reads the C++ library directory from dist/build/hoppy-cpp-libdir* and adds it to the library search path ().): Removes files created by the generator.   !"#$%&&'()*+,-./01234566789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    *hoppy-runtime-0.5.1-Br7gf4JqazWFWutcmKzVmsForeign.Hoppy.RuntimeForeign.Hoppy.SetupForeign.Hoppy.Generator.Std ConvertPtr ConvertValue)Foreign.Hoppy.Generator.Spec.ClassFeature Assignable ForeignPtrwithForeignPtrForeignPtr.UnsafeunsafeForeignPtrToPtrtouchForeignPtrbaseForeign.C.TypesCUChar CCallback FromContents fromContents HasContents toContentsExceptionClassInfoexceptionClassIdexceptionClassNameexceptionClassUpcastsexceptionClassDeleteexceptionClassCopyexceptionClassToGc ExceptionDbSomeCppExceptionSomeUnknownCppExceptionUnknownCppException CppThrowabletoSomeCppException CppExceptioncppExceptionInfocppExceptionBuildcppExceptionBuildToGc ExceptionId Decodabledecode EncodableencodeCopyablecopyassign DeletabledeletetoGcCppPtrnullptr withCppPtrtoPtr touchCppPtrCBoolcoerceIntegralencodeAsdecodeAndDelete withCppObj withScopedPtrwithScopedFunPtrcatchCppthrowCppinternalHandleExceptions internalHandleCallbackExceptionsfreeHaskellFunPtrFunPtr $fEnumCBool$fBoundedCBool$fAssignablePtra$fAssignablePtrDouble$fAssignablePtrFloat$fAssignablePtrInt$fAssignablePtrBool$fDecodablePtrPtr$fDecodablePtrPtr0$fDecodablePtrPtr1$fDecodablePtrPtr2$fDecodablePtrPtr3$fDecodablePtrPtr4$fDecodablePtrPtr5$fDecodablePtrPtr6$fDecodablePtrPtr7$fDecodablePtrPtr8$fDecodablePtrPtr9$fDecodablePtrPtr10$fDecodablePtrPtr11$fDecodablePtrPtr12$fDecodablePtrPtr13$fDecodablePtrPtr14$fDecodablePtrPtr15$fDecodablePtrPtr16$fDecodablePtrPtr17$fDecodablePtrPtr18$fDecodablePtrPtr19$fDecodablePtrPtr20$fDecodablePtrPtr21$fDecodablePtrPtr22$fDecodablePtrPtr23$fDecodablePtrCSsize$fDecodablePtrCSize$fDecodablePtrCPtrdiff$fDecodablePtrWord64$fDecodablePtrWord32$fDecodablePtrWord16$fDecodablePtrWord8$fDecodablePtrInt64$fDecodablePtrInt32$fDecodablePtrInt16$fDecodablePtrInt8$fDecodablePtrDouble$fDecodablePtrFloat$fDecodablePtrCULLong$fDecodablePtrCLLong$fDecodablePtrCULong$fDecodablePtrCLong$fDecodablePtrCUInt$fDecodablePtrInt$fDecodablePtrCUShort$fDecodablePtrCShort$fDecodablePtrCUChar$fDecodablePtrCChar$fDecodablePtrBool$fExceptionSomeCppException$fShowSomeCppException!$fCppExceptionUnknownCppException$fCppDefaultPtr$fCppDefaultCSsize$fCppDefaultCSize$fCppDefaultCPtrdiff$fCppDefaultWord64$fCppDefaultWord32$fCppDefaultWord16$fCppDefaultWord8$fCppDefaultInt64$fCppDefaultInt32$fCppDefaultInt16$fCppDefaultInt8$fCppDefaultCDouble$fCppDefaultCFloat$fCppDefaultCULLong$fCppDefaultCLLong$fCppDefaultCULong$fCppDefaultCLong$fCppDefaultCUInt$fCppDefaultCInt$fCppDefaultCUShort$fCppDefaultCShort$fCppDefaultCUChar$fCppDefaultCChar$fCppDefaultCBool$fCppDefault() $fEqCBool$fIntegralCBool $fNumCBool $fOrdCBool $fRealCBool $fShowCBool$fStorableCBool$fEqExceptionId$fOrdExceptionId$fShowExceptionId ProjectConfiggeneratorExecutableNamecppPackageName cppSourcesDir hsSourcesDircppMain cppUserHookshsMain hsUserHooks CppDefaultGHC.IOcatchGHC.PtrPtrGHC.BaseasTypeOfStringControl.Exception.BasebracketFunPtr Foreign.PtrfreeHaskellFunPtr Cabal-2.2.0.1Distribution.SimpledefaultMainWithHooksDistribution.Simple.UserHookspostConf buildHookcopyHookinstHook cleanHookpreBuildpreTestpreCopypreInstpreRegDistribution.Types.BuildInfo extraLibDirs