casadi-bindings-1.9.0.0: Casadi/Wrappers/Classes/GenericType.hs

{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language ForeignFunctionInterface #-}
{-# Language FlexibleInstances #-}
{-# Language MultiParamTypeClasses #-}

module Casadi.Wrappers.Classes.GenericType
       (
         GenericType,
         GenericTypeClass(..),
         genericType,
         genericType',
         genericType'',
         genericType''',
         genericType'''',
         genericType''''',
         genericType'''''',
         genericType''''''',
         genericType'''''''',
         genericType''''''''',
         genericType'''''''''',
         genericType''''''''''',
         genericType'''''''''''',
         genericType_can_cast_to,
         genericType_can_cast_to',
         genericType_from_type,
         genericType_getType,
         genericType_get_description,
         genericType_get_type_description,
         genericType_isBool,
         genericType_isDictionary,
         genericType_isDouble,
         genericType_isDoubleVector,
         genericType_isEmptyVector,
         genericType_isFunction,
         genericType_isInt,
         genericType_isIntVector,
         genericType_isSharedObject,
         genericType_isString,
         genericType_isStringVector,
         genericType_operator_equals,
         genericType_operator_nequals,
         genericType_toBool,
         genericType_toDouble,
         genericType_toInt,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Ptr ( Ptr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Wrappers.Classes.PrintableObject
import Casadi.Wrappers.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show GenericType where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__get_type_description" c_CasADi__GenericType__get_type_description
  :: CInt -> IO (Ptr StdString')
casADi__GenericType__get_type_description
  :: Opt_type -> IO String
casADi__GenericType__get_type_description x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__get_type_description x0' >>= wrapReturn

-- classy wrapper
genericType_get_type_description :: Opt_type -> IO String
genericType_get_type_description = casADi__GenericType__get_type_description


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__get_description" c_CasADi__GenericType__get_description
  :: Ptr GenericType' -> IO (Ptr StdString')
casADi__GenericType__get_description
  :: GenericType -> IO String
casADi__GenericType__get_description x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__get_description x0' >>= wrapReturn

-- classy wrapper
{-|
>Get a description of the object's type.
-}
genericType_get_description :: GenericTypeClass a => a -> IO String
genericType_get_description x = casADi__GenericType__get_description (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__from_type" c_CasADi__GenericType__from_type
  :: CInt -> IO (Ptr GenericType')
casADi__GenericType__from_type
  :: Opt_type -> IO GenericType
casADi__GenericType__from_type x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__from_type x0' >>= wrapReturn

-- classy wrapper
genericType_from_type :: Opt_type -> IO GenericType
genericType_from_type = casADi__GenericType__from_type


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__getType" c_CasADi__GenericType__getType
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__getType
  :: GenericType -> IO Opt_type
casADi__GenericType__getType x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__getType x0' >>= wrapReturn

-- classy wrapper
genericType_getType :: GenericTypeClass a => a -> IO Opt_type
genericType_getType x = casADi__GenericType__getType (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__can_cast_to" c_CasADi__GenericType__can_cast_to
  :: Ptr GenericType' -> CInt -> IO CInt
casADi__GenericType__can_cast_to
  :: GenericType -> Opt_type -> IO Bool
casADi__GenericType__can_cast_to x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericType__can_cast_to x0' x1' >>= wrapReturn

-- classy wrapper
genericType_can_cast_to :: GenericTypeClass a => a -> Opt_type -> IO Bool
genericType_can_cast_to x = casADi__GenericType__can_cast_to (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__can_cast_to_TIC" c_CasADi__GenericType__can_cast_to_TIC
  :: Ptr GenericType' -> Ptr GenericType' -> IO CInt
casADi__GenericType__can_cast_to'
  :: GenericType -> GenericType -> IO Bool
casADi__GenericType__can_cast_to' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericType__can_cast_to_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genericType_can_cast_to' :: GenericTypeClass a => a -> GenericType -> IO Bool
genericType_can_cast_to' x = casADi__GenericType__can_cast_to' (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isBool" c_CasADi__GenericType__isBool
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isBool
  :: GenericType -> IO Bool
casADi__GenericType__isBool x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isBool x0' >>= wrapReturn

-- classy wrapper
{-|
>Is boolean?
-}
genericType_isBool :: GenericTypeClass a => a -> IO Bool
genericType_isBool x = casADi__GenericType__isBool (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isInt" c_CasADi__GenericType__isInt
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isInt
  :: GenericType -> IO Bool
casADi__GenericType__isInt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isInt x0' >>= wrapReturn

-- classy wrapper
{-|
>Is an integer?
-}
genericType_isInt :: GenericTypeClass a => a -> IO Bool
genericType_isInt x = casADi__GenericType__isInt (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isDouble" c_CasADi__GenericType__isDouble
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isDouble
  :: GenericType -> IO Bool
casADi__GenericType__isDouble x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isDouble x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a double?
-}
genericType_isDouble :: GenericTypeClass a => a -> IO Bool
genericType_isDouble x = casADi__GenericType__isDouble (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isString" c_CasADi__GenericType__isString
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isString
  :: GenericType -> IO Bool
casADi__GenericType__isString x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isString x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a string?
-}
genericType_isString :: GenericTypeClass a => a -> IO Bool
genericType_isString x = casADi__GenericType__isString (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isEmptyVector" c_CasADi__GenericType__isEmptyVector
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isEmptyVector
  :: GenericType -> IO Bool
casADi__GenericType__isEmptyVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isEmptyVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Is an empty vector?
-}
genericType_isEmptyVector :: GenericTypeClass a => a -> IO Bool
genericType_isEmptyVector x = casADi__GenericType__isEmptyVector (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isIntVector" c_CasADi__GenericType__isIntVector
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isIntVector
  :: GenericType -> IO Bool
casADi__GenericType__isIntVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isIntVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a vector of ints?
-}
genericType_isIntVector :: GenericTypeClass a => a -> IO Bool
genericType_isIntVector x = casADi__GenericType__isIntVector (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isDoubleVector" c_CasADi__GenericType__isDoubleVector
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isDoubleVector
  :: GenericType -> IO Bool
casADi__GenericType__isDoubleVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isDoubleVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a vector of doubles?
-}
genericType_isDoubleVector :: GenericTypeClass a => a -> IO Bool
genericType_isDoubleVector x = casADi__GenericType__isDoubleVector (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isStringVector" c_CasADi__GenericType__isStringVector
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isStringVector
  :: GenericType -> IO Bool
casADi__GenericType__isStringVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isStringVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a vector of strings.
-}
genericType_isStringVector :: GenericTypeClass a => a -> IO Bool
genericType_isStringVector x = casADi__GenericType__isStringVector (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isSharedObject" c_CasADi__GenericType__isSharedObject
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isSharedObject
  :: GenericType -> IO Bool
casADi__GenericType__isSharedObject x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isSharedObject x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a shared object?
-}
genericType_isSharedObject :: GenericTypeClass a => a -> IO Bool
genericType_isSharedObject x = casADi__GenericType__isSharedObject (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isDictionary" c_CasADi__GenericType__isDictionary
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isDictionary
  :: GenericType -> IO Bool
casADi__GenericType__isDictionary x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isDictionary x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a shared object?
-}
genericType_isDictionary :: GenericTypeClass a => a -> IO Bool
genericType_isDictionary x = casADi__GenericType__isDictionary (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__isFunction" c_CasADi__GenericType__isFunction
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__isFunction
  :: GenericType -> IO Bool
casADi__GenericType__isFunction x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__isFunction x0' >>= wrapReturn

-- classy wrapper
{-|
>Is a shared object?
-}
genericType_isFunction :: GenericTypeClass a => a -> IO Bool
genericType_isFunction x = casADi__GenericType__isFunction (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__toBool" c_CasADi__GenericType__toBool
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__toBool
  :: GenericType -> IO Bool
casADi__GenericType__toBool x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__toBool x0' >>= wrapReturn

-- classy wrapper
{-|
>Convert to boolean.
-}
genericType_toBool :: GenericTypeClass a => a -> IO Bool
genericType_toBool x = casADi__GenericType__toBool (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__toInt" c_CasADi__GenericType__toInt
  :: Ptr GenericType' -> IO CInt
casADi__GenericType__toInt
  :: GenericType -> IO Int
casADi__GenericType__toInt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__toInt x0' >>= wrapReturn

-- classy wrapper
{-|
>Convert to int.
-}
genericType_toInt :: GenericTypeClass a => a -> IO Int
genericType_toInt x = casADi__GenericType__toInt (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__toDouble" c_CasADi__GenericType__toDouble
  :: Ptr GenericType' -> IO CDouble
casADi__GenericType__toDouble
  :: GenericType -> IO Double
casADi__GenericType__toDouble x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__toDouble x0' >>= wrapReturn

-- classy wrapper
{-|
>Convert to double.
-}
genericType_toDouble :: GenericTypeClass a => a -> IO Double
genericType_toDouble x = casADi__GenericType__toDouble (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__operator_equals" c_CasADi__GenericType__operator_equals
  :: Ptr GenericType' -> Ptr GenericType' -> IO CInt
casADi__GenericType__operator_equals
  :: GenericType -> GenericType -> IO Bool
casADi__GenericType__operator_equals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericType__operator_equals x0' x1' >>= wrapReturn

-- classy wrapper
genericType_operator_equals :: GenericTypeClass a => a -> GenericType -> IO Bool
genericType_operator_equals x = casADi__GenericType__operator_equals (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__operator_nequals" c_CasADi__GenericType__operator_nequals
  :: Ptr GenericType' -> Ptr GenericType' -> IO CInt
casADi__GenericType__operator_nequals
  :: GenericType -> GenericType -> IO Bool
casADi__GenericType__operator_nequals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericType__operator_nequals x0' x1' >>= wrapReturn

-- classy wrapper
genericType_operator_nequals :: GenericTypeClass a => a -> GenericType -> IO Bool
genericType_operator_nequals x = casADi__GenericType__operator_nequals (castGenericType x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType" c_CasADi__GenericType__GenericType
  :: IO (Ptr GenericType')
casADi__GenericType__GenericType
  :: IO GenericType
casADi__GenericType__GenericType  =
  c_CasADi__GenericType__GenericType  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::GenericType::GenericType(void *ptr)
>------------------------------------------------------------------------
>[INTERNAL]
>
>>  CasADi::GenericType::GenericType(NLPSolverCreator ptr)
>------------------------------------------------------------------------
>
>Creator functions.
-}
genericType :: IO GenericType
genericType = casADi__GenericType__GenericType


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC" c_CasADi__GenericType__GenericType_TIC
  :: CInt -> IO (Ptr GenericType')
casADi__GenericType__GenericType'
  :: Bool -> IO GenericType
casADi__GenericType__GenericType' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC x0' >>= wrapReturn

-- classy wrapper
genericType' :: Bool -> IO GenericType
genericType' = casADi__GenericType__GenericType'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC
  :: CInt -> IO (Ptr GenericType')
casADi__GenericType__GenericType''
  :: Int -> IO GenericType
casADi__GenericType__GenericType'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'' :: Int -> IO GenericType
genericType'' = casADi__GenericType__GenericType''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC
  :: CDouble -> IO (Ptr GenericType')
casADi__GenericType__GenericType'''
  :: Double -> IO GenericType
casADi__GenericType__GenericType''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType''' :: Double -> IO GenericType
genericType''' = casADi__GenericType__GenericType'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> IO (Ptr GenericType')
casADi__GenericType__GenericType''''
  :: String -> IO GenericType
casADi__GenericType__GenericType'''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'''' :: String -> IO GenericType
genericType'''' = casADi__GenericType__GenericType''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> IO (Ptr GenericType')
casADi__GenericType__GenericType'''''
  :: Vector Bool -> IO GenericType
casADi__GenericType__GenericType''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType''''' :: Vector Bool -> IO GenericType
genericType''''' = casADi__GenericType__GenericType'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> IO (Ptr GenericType')
casADi__GenericType__GenericType''''''
  :: Vector Int -> IO GenericType
casADi__GenericType__GenericType'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'''''' :: Vector Int -> IO GenericType
genericType'''''' = casADi__GenericType__GenericType''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> IO (Ptr GenericType')
casADi__GenericType__GenericType'''''''
  :: Vector Double -> IO GenericType
casADi__GenericType__GenericType''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType''''''' :: Vector Double -> IO GenericType
genericType''''''' = casADi__GenericType__GenericType'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr StdString')) -> IO (Ptr GenericType')
casADi__GenericType__GenericType''''''''
  :: Vector String -> IO GenericType
casADi__GenericType__GenericType'''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'''''''' :: Vector String -> IO GenericType
genericType'''''''' = casADi__GenericType__GenericType''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr Function' -> IO (Ptr GenericType')
casADi__GenericType__GenericType'''''''''
  :: Function -> IO GenericType
casADi__GenericType__GenericType''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType''''''''' :: Function -> IO GenericType
genericType''''''''' = casADi__GenericType__GenericType'''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SharedObject' -> IO (Ptr GenericType')
casADi__GenericType__GenericType''''''''''
  :: SharedObject -> IO GenericType
casADi__GenericType__GenericType'''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'''''''''' :: SharedObject -> IO GenericType
genericType'''''''''' = casADi__GenericType__GenericType''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr DerivativeGenerator' -> IO (Ptr GenericType')
casADi__GenericType__GenericType'''''''''''
  :: DerivativeGenerator -> IO GenericType
casADi__GenericType__GenericType''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType''''''''''' :: DerivativeGenerator -> IO GenericType
genericType''''''''''' = casADi__GenericType__GenericType'''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr Callback' -> IO (Ptr GenericType')
casADi__GenericType__GenericType''''''''''''
  :: Callback -> IO GenericType
casADi__GenericType__GenericType'''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genericType'''''''''''' :: Callback -> IO GenericType
genericType'''''''''''' = casADi__GenericType__GenericType''''''''''''