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

module Casadi.Wrappers.Classes.IOInterfaceFunction
       (
         IOInterfaceFunction,
         IOInterfaceFunctionClass(..),
         ioInterfaceFunction_getInput,
         ioInterfaceFunction_getInput',
         ioInterfaceFunction_getInput'',
         ioInterfaceFunction_getInputScheme,
         ioInterfaceFunction_getNumInputs,
         ioInterfaceFunction_getNumOutputs,
         ioInterfaceFunction_getOutput,
         ioInterfaceFunction_getOutput',
         ioInterfaceFunction_getOutput'',
         ioInterfaceFunction_getOutputScheme,
         ioInterfaceFunction_input,
         ioInterfaceFunction_input',
         ioInterfaceFunction_input'',
         ioInterfaceFunction_inputSchemeEntry,
         ioInterfaceFunction_output,
         ioInterfaceFunction_output',
         ioInterfaceFunction_output'',
         ioInterfaceFunction_outputSchemeEntry,
         ioInterfaceFunction_schemeEntry,
         ioInterfaceFunction_setInput,
         ioInterfaceFunction_setInput',
         ioInterfaceFunction_setInput'',
         ioInterfaceFunction_setInput''',
         ioInterfaceFunction_setInput'''',
         ioInterfaceFunction_setInput''''',
         ioInterfaceFunction_setInput'''''',
         ioInterfaceFunction_setInput''''''',
         ioInterfaceFunction_setInput'''''''',
         ioInterfaceFunction_setInputScheme,
         ioInterfaceFunction_setNumInputs,
         ioInterfaceFunction_setNumOutputs,
         ioInterfaceFunction_setOutput,
         ioInterfaceFunction_setOutput',
         ioInterfaceFunction_setOutput'',
         ioInterfaceFunction_setOutput''',
         ioInterfaceFunction_setOutput'''',
         ioInterfaceFunction_setOutput''''',
         ioInterfaceFunction_setOutput'''''',
         ioInterfaceFunction_setOutput''''''',
         ioInterfaceFunction_setOutput'''''''',
         ioInterfaceFunction_setOutputScheme,
       ) 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.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___input" c_CasADi__IOInterface_CasADi__Function___input
  :: Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___input
  :: IOInterfaceFunction -> Int -> IO DMatrix
casADi__IOInterface_CasADi__Function___input x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___input x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[UNSAFE] Obtain reference to inputs
>
>Access input argument
-}
ioInterfaceFunction_input :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_input x = casADi__IOInterface_CasADi__Function___input (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___input_TIC" c_CasADi__IOInterface_CasADi__Function___input_TIC
  :: Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___input'
  :: IOInterfaceFunction -> IO DMatrix
casADi__IOInterface_CasADi__Function___input' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___input_TIC x0' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_input' :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_input' x = casADi__IOInterface_CasADi__Function___input' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___input_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___input_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___input''
  :: IOInterfaceFunction -> String -> IO DMatrix
casADi__IOInterface_CasADi__Function___input'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___input_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_input'' :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_input'' x = casADi__IOInterface_CasADi__Function___input'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___output" c_CasADi__IOInterface_CasADi__Function___output
  :: Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___output
  :: IOInterfaceFunction -> Int -> IO DMatrix
casADi__IOInterface_CasADi__Function___output x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___output x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[UNSAFE] Obtain reference to outputs
>
>Access output argument
-}
ioInterfaceFunction_output :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_output x = casADi__IOInterface_CasADi__Function___output (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___output_TIC" c_CasADi__IOInterface_CasADi__Function___output_TIC
  :: Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___output'
  :: IOInterfaceFunction -> IO DMatrix
casADi__IOInterface_CasADi__Function___output' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___output_TIC x0' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_output' :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_output' x = casADi__IOInterface_CasADi__Function___output' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___output_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___output_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___output''
  :: IOInterfaceFunction -> String -> IO DMatrix
casADi__IOInterface_CasADi__Function___output'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___output_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_output'' :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_output'' x = casADi__IOInterface_CasADi__Function___output'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getNumInputs" c_CasADi__IOInterface_CasADi__Function___getNumInputs
  :: Ptr IOInterfaceFunction' -> IO CInt
casADi__IOInterface_CasADi__Function___getNumInputs
  :: IOInterfaceFunction -> IO Int
casADi__IOInterface_CasADi__Function___getNumInputs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getNumInputs x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of function inputs.
-}
ioInterfaceFunction_getNumInputs :: IOInterfaceFunctionClass a => a -> IO Int
ioInterfaceFunction_getNumInputs x = casADi__IOInterface_CasADi__Function___getNumInputs (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getNumOutputs" c_CasADi__IOInterface_CasADi__Function___getNumOutputs
  :: Ptr IOInterfaceFunction' -> IO CInt
casADi__IOInterface_CasADi__Function___getNumOutputs
  :: IOInterfaceFunction -> IO Int
casADi__IOInterface_CasADi__Function___getNumOutputs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getNumOutputs x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of function outputs.
-}
ioInterfaceFunction_getNumOutputs :: IOInterfaceFunctionClass a => a -> IO Int
ioInterfaceFunction_getNumOutputs x = casADi__IOInterface_CasADi__Function___getNumOutputs (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setNumInputs" c_CasADi__IOInterface_CasADi__Function___setNumInputs
  :: Ptr IOInterfaceFunction' -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setNumInputs
  :: IOInterfaceFunction -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setNumInputs x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setNumInputs x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Set the number of function inputs.
-}
ioInterfaceFunction_setNumInputs :: IOInterfaceFunctionClass a => a -> Int -> IO ()
ioInterfaceFunction_setNumInputs x = casADi__IOInterface_CasADi__Function___setNumInputs (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setNumOutputs" c_CasADi__IOInterface_CasADi__Function___setNumOutputs
  :: Ptr IOInterfaceFunction' -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setNumOutputs
  :: IOInterfaceFunction -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setNumOutputs x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setNumOutputs x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Set the number of function outputs.
-}
ioInterfaceFunction_setNumOutputs :: IOInterfaceFunctionClass a => a -> Int -> IO ()
ioInterfaceFunction_setNumOutputs x = casADi__IOInterface_CasADi__Function___setNumOutputs (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInputScheme" c_CasADi__IOInterface_CasADi__Function___setInputScheme
  :: Ptr IOInterfaceFunction' -> Ptr IOScheme' -> IO ()
casADi__IOInterface_CasADi__Function___setInputScheme
  :: IOInterfaceFunction -> IOScheme -> IO ()
casADi__IOInterface_CasADi__Function___setInputScheme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setInputScheme x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Set input scheme.
-}
ioInterfaceFunction_setInputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO ()
ioInterfaceFunction_setInputScheme x = casADi__IOInterface_CasADi__Function___setInputScheme (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutputScheme" c_CasADi__IOInterface_CasADi__Function___setOutputScheme
  :: Ptr IOInterfaceFunction' -> Ptr IOScheme' -> IO ()
casADi__IOInterface_CasADi__Function___setOutputScheme
  :: IOInterfaceFunction -> IOScheme -> IO ()
casADi__IOInterface_CasADi__Function___setOutputScheme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setOutputScheme x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Set output scheme.
-}
ioInterfaceFunction_setOutputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO ()
ioInterfaceFunction_setOutputScheme x = casADi__IOInterface_CasADi__Function___setOutputScheme (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getInputScheme" c_CasADi__IOInterface_CasADi__Function___getInputScheme
  :: Ptr IOInterfaceFunction' -> IO (Ptr IOScheme')
casADi__IOInterface_CasADi__Function___getInputScheme
  :: IOInterfaceFunction -> IO IOScheme
casADi__IOInterface_CasADi__Function___getInputScheme x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getInputScheme x0' >>= wrapReturn

-- classy wrapper
{-|
>Get input scheme.
-}
ioInterfaceFunction_getInputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme
ioInterfaceFunction_getInputScheme x = casADi__IOInterface_CasADi__Function___getInputScheme (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getOutputScheme" c_CasADi__IOInterface_CasADi__Function___getOutputScheme
  :: Ptr IOInterfaceFunction' -> IO (Ptr IOScheme')
casADi__IOInterface_CasADi__Function___getOutputScheme
  :: IOInterfaceFunction -> IO IOScheme
casADi__IOInterface_CasADi__Function___getOutputScheme x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getOutputScheme x0' >>= wrapReturn

-- classy wrapper
{-|
>Get output scheme.
-}
ioInterfaceFunction_getOutputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme
ioInterfaceFunction_getOutputScheme x = casADi__IOInterface_CasADi__Function___getOutputScheme (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___inputSchemeEntry" c_CasADi__IOInterface_CasADi__Function___inputSchemeEntry
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO CInt
casADi__IOInterface_CasADi__Function___inputSchemeEntry
  :: IOInterfaceFunction -> String -> IO Int
casADi__IOInterface_CasADi__Function___inputSchemeEntry x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___inputSchemeEntry x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Find the index for a string describing a particular entry of an input
>scheme.
>
>example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FunctionInternal
>adheres to SCHEME_NLPINput
-}
ioInterfaceFunction_inputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int
ioInterfaceFunction_inputSchemeEntry x = casADi__IOInterface_CasADi__Function___inputSchemeEntry (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___outputSchemeEntry" c_CasADi__IOInterface_CasADi__Function___outputSchemeEntry
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO CInt
casADi__IOInterface_CasADi__Function___outputSchemeEntry
  :: IOInterfaceFunction -> String -> IO Int
casADi__IOInterface_CasADi__Function___outputSchemeEntry x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___outputSchemeEntry x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Find the index for a string describing a particular entry of an output
>scheme.
>
>example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FunctionInternal
>adheres to SCHEME_NLPINput
-}
ioInterfaceFunction_outputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int
ioInterfaceFunction_outputSchemeEntry x = casADi__IOInterface_CasADi__Function___outputSchemeEntry (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___schemeEntry" c_CasADi__IOInterface_CasADi__Function___schemeEntry
  :: Ptr IOInterfaceFunction' -> Ptr IOScheme' -> Ptr StdString' -> CInt -> IO CInt
casADi__IOInterface_CasADi__Function___schemeEntry
  :: IOInterfaceFunction -> IOScheme -> String -> Bool -> IO Int
casADi__IOInterface_CasADi__Function___schemeEntry x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__IOInterface_CasADi__Function___schemeEntry x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Find
>the index for a string describing a particular entry of a scheme.
>
>example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FunctionInternal
>adheres to SCHEME_NLPINput
-}
ioInterfaceFunction_schemeEntry :: IOInterfaceFunctionClass a => a -> IOScheme -> String -> Bool -> IO Int
ioInterfaceFunction_schemeEntry x = casADi__IOInterface_CasADi__Function___schemeEntry (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getInput" c_CasADi__IOInterface_CasADi__Function___getInput
  :: Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getInput
  :: IOInterfaceFunction -> Int -> IO DMatrix
casADi__IOInterface_CasADi__Function___getInput x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___getInput x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  Matrix<double> CasADi::IOInterface< Derived >::getInput(int iind=0) const 
>------------------------------------------------------------------------
>
>Get an input by index.
>
>Parameters:
>-----------
>
>iind:  index within the range [0.. getNumInputs()-1]
>
>>  Matrix<double> CasADi::IOInterface< Derived >::getInput(const std::string &iname) const 
>------------------------------------------------------------------------
>
>Get an input by name.
>
>Parameters:
>-----------
>
>iname:  input name. Only allowed when an input scheme is set.
>
>>  void CasADi::IOInterface< Derived >::getInput(T val, int iind=0)
>------------------------------------------------------------------------
>[INTERNAL] 
>Get an input by index.
>
>Parameters:
>-----------
>
>val:  can be double&, std::vector<double>&, Matrix<double>&, double *
>
>iind:  index within the range [0.. getNumInputs()-1]
>
>>  void CasADi::IOInterface< Derived >::getInput(T val, const std::string &iname)
>------------------------------------------------------------------------
>[INTERNAL] 
>Get an input by name.
>
>Parameters:
>-----------
>
>val:  can be double&, std::vector<double>&, Matrix<double>&, double *
>
>iname:  input name. Only allowed when an input scheme is set.
-}
ioInterfaceFunction_getInput :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_getInput x = casADi__IOInterface_CasADi__Function___getInput (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getInput_TIC" c_CasADi__IOInterface_CasADi__Function___getInput_TIC
  :: Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getInput'
  :: IOInterfaceFunction -> IO DMatrix
casADi__IOInterface_CasADi__Function___getInput' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getInput_TIC x0' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_getInput' :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_getInput' x = casADi__IOInterface_CasADi__Function___getInput' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getInput''
  :: IOInterfaceFunction -> String -> IO DMatrix
casADi__IOInterface_CasADi__Function___getInput'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_getInput'' :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_getInput'' x = casADi__IOInterface_CasADi__Function___getInput'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getOutput" c_CasADi__IOInterface_CasADi__Function___getOutput
  :: Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getOutput
  :: IOInterfaceFunction -> Int -> IO DMatrix
casADi__IOInterface_CasADi__Function___getOutput x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___getOutput x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  Matrix<double> CasADi::IOInterface< Derived >::getOutput(int oind=0) const 
>------------------------------------------------------------------------
>
>Get an output by index.
>
>Parameters:
>-----------
>
>oind:  index within the range [0.. getNumOutputs()-1]
>
>>  Matrix<double> CasADi::IOInterface< Derived >::getOutput(const std::string &oname) const 
>------------------------------------------------------------------------
>
>Get an output by name.
>
>Parameters:
>-----------
>
>oname:  output name. Only allowed when an output scheme is set.
>
>>  void CasADi::IOInterface< Derived >::getOutput(T val, int oind=0)
>------------------------------------------------------------------------
>[INTERNAL] 
>Get an output by index.
>
>Parameters:
>-----------
>
>val:  can be double&, std::vector<double>&, Matrix<double>&, double *
>
>oind:  index within the range [0.. getNumOutputs()-1]
>
>>  void CasADi::IOInterface< Derived >::getOutput(T val, const std::string &oname)
>------------------------------------------------------------------------
>[INTERNAL] 
>Get an output by name.
>
>Parameters:
>-----------
>
>val:  can be double&, std::vector<double>&, Matrix<double>&, double *
>
>oname:  output name. Only allowed when an output scheme is set.
-}
ioInterfaceFunction_getOutput :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_getOutput x = casADi__IOInterface_CasADi__Function___getOutput (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getOutput_TIC" c_CasADi__IOInterface_CasADi__Function___getOutput_TIC
  :: Ptr IOInterfaceFunction' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getOutput'
  :: IOInterfaceFunction -> IO DMatrix
casADi__IOInterface_CasADi__Function___getOutput' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__IOInterface_CasADi__Function___getOutput_TIC x0' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_getOutput' :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_getOutput' x = casADi__IOInterface_CasADi__Function___getOutput' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr StdString' -> IO (Ptr DMatrix')
casADi__IOInterface_CasADi__Function___getOutput''
  :: IOInterfaceFunction -> String -> IO DMatrix
casADi__IOInterface_CasADi__Function___getOutput'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_getOutput'' :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_getOutput'' x = casADi__IOInterface_CasADi__Function___getOutput'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput" c_CasADi__IOInterface_CasADi__Function___setInput
  :: Ptr IOInterfaceFunction' -> CDouble -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setInput
  :: IOInterfaceFunction -> Double -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setInput x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::IOInterface< Derived >::setInput(T val, int iind=0)
>------------------------------------------------------------------------
>
>Set an input by index.
>
>Parameters:
>-----------
>
>val:  can be double, const std::vector<double>&, const Matrix<double>&,
>double *
>
>iind:  index within the range [0.. getNumInputs()-1]
>
>>  void CasADi::IOInterface< Derived >::setInput(T val, const std::string &iname)
>------------------------------------------------------------------------
>
>Set an input by name.
>
>Parameters:
>-----------
>
>val:  can be double, const std::vector<double>&, const Matrix<double>&,
>double *
>
>iname:  input name. Only allowed when an input scheme is set.
-}
ioInterfaceFunction_setInput :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO ()
ioInterfaceFunction_setInput x = casADi__IOInterface_CasADi__Function___setInput (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC
  :: Ptr IOInterfaceFunction' -> CDouble -> IO ()
casADi__IOInterface_CasADi__Function___setInput'
  :: IOInterfaceFunction -> Double -> IO ()
casADi__IOInterface_CasADi__Function___setInput' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput' :: IOInterfaceFunctionClass a => a -> Double -> IO ()
ioInterfaceFunction_setInput' x = casADi__IOInterface_CasADi__Function___setInput' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput" c_CasADi__IOInterface_CasADi__Function___setOutput
  :: Ptr IOInterfaceFunction' -> CDouble -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setOutput
  :: IOInterfaceFunction -> Double -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setOutput x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::IOInterface< Derived >::setOutput(T val, int oind=0)
>------------------------------------------------------------------------
>
>Set an output by index.
>
>Parameters:
>-----------
>
>val:  can be double, const std::vector<double>&, const Matrix<double>&,
>double *
>
>oind:  index within the range [0.. getNumOutputs()-1]
>
>>  void CasADi::IOInterface< Derived >::setOutput(T val, const std::string &oname)
>------------------------------------------------------------------------
>
>Set an output by name.
>
>Parameters:
>-----------
>
>val:  can be double, const std::vector<double>&, const Matrix<double>&,
>double *
>
>oname:  output name. Only allowed when an output scheme is set.
-}
ioInterfaceFunction_setOutput :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO ()
ioInterfaceFunction_setOutput x = casADi__IOInterface_CasADi__Function___setOutput (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC
  :: Ptr IOInterfaceFunction' -> CDouble -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'
  :: IOInterfaceFunction -> Double -> IO ()
casADi__IOInterface_CasADi__Function___setOutput' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput' :: IOInterfaceFunctionClass a => a -> Double -> IO ()
ioInterfaceFunction_setOutput' x = casADi__IOInterface_CasADi__Function___setOutput' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC
  :: Ptr IOInterfaceFunction' -> CDouble -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setInput''
  :: IOInterfaceFunction -> Double -> String -> IO ()
casADi__IOInterface_CasADi__Function___setInput'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput'' :: IOInterfaceFunctionClass a => a -> Double -> String -> IO ()
ioInterfaceFunction_setInput'' x = casADi__IOInterface_CasADi__Function___setInput'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC
  :: Ptr IOInterfaceFunction' -> CDouble -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''
  :: IOInterfaceFunction -> Double -> String -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput'' :: IOInterfaceFunctionClass a => a -> Double -> String -> IO ()
ioInterfaceFunction_setOutput'' x = casADi__IOInterface_CasADi__Function___setOutput'' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''
  :: IOInterfaceFunction -> Vector Double -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setInput''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput''' :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO ()
ioInterfaceFunction_setInput''' x = casADi__IOInterface_CasADi__Function___setInput''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> IO ()
casADi__IOInterface_CasADi__Function___setInput''''
  :: IOInterfaceFunction -> Vector Double -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput'''' :: IOInterfaceFunctionClass a => a -> Vector Double -> IO ()
ioInterfaceFunction_setInput'''' x = casADi__IOInterface_CasADi__Function___setInput'''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''
  :: IOInterfaceFunction -> Vector Double -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput''' :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO ()
ioInterfaceFunction_setOutput''' x = casADi__IOInterface_CasADi__Function___setOutput''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''''
  :: IOInterfaceFunction -> Vector Double -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput'''' :: IOInterfaceFunctionClass a => a -> Vector Double -> IO ()
ioInterfaceFunction_setOutput'''' x = casADi__IOInterface_CasADi__Function___setOutput'''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''''
  :: IOInterfaceFunction -> Vector Double -> String -> IO ()
casADi__IOInterface_CasADi__Function___setInput''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput''''' :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO ()
ioInterfaceFunction_setInput''''' x = casADi__IOInterface_CasADi__Function___setInput''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr (CppVec CDouble) -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''''
  :: IOInterfaceFunction -> Vector Double -> String -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput''''' :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO ()
ioInterfaceFunction_setOutput''''' x = casADi__IOInterface_CasADi__Function___setOutput''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setInput''''''
  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput'''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
ioInterfaceFunction_setInput'''''' x = casADi__IOInterface_CasADi__Function___setInput'''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''''''
  :: IOInterfaceFunction -> DMatrix -> IO ()
casADi__IOInterface_CasADi__Function___setInput''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput''''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
ioInterfaceFunction_setInput''''''' x = casADi__IOInterface_CasADi__Function___setInput''''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''''''
  :: IOInterfaceFunction -> DMatrix -> Int -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput'''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
ioInterfaceFunction_setOutput'''''' x = casADi__IOInterface_CasADi__Function___setOutput'''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''''''
  :: IOInterfaceFunction -> DMatrix -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput''''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
ioInterfaceFunction_setOutput''''''' x = casADi__IOInterface_CasADi__Function___setOutput''''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setInput''''''''
  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
casADi__IOInterface_CasADi__Function___setInput'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setInput'''''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
ioInterfaceFunction_setInput'''''''' x = casADi__IOInterface_CasADi__Function___setInput'''''''' (castIOInterfaceFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString' -> IO ()
casADi__IOInterface_CasADi__Function___setOutput''''''''
  :: IOInterfaceFunction -> DMatrix -> String -> IO ()
casADi__IOInterface_CasADi__Function___setOutput'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
ioInterfaceFunction_setOutput'''''''' :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
ioInterfaceFunction_setOutput'''''''' x = casADi__IOInterface_CasADi__Function___setOutput'''''''' (castIOInterfaceFunction x)