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

module Casadi.Wrappers.Classes.Slice
       (
         Slice,
         SliceClass(..),
         slice,
         slice',
         slice'',
         slice''',
         slice'''',
         slice''''',
         slice_getAll,
         slice_getAll',
         slice_isSlice,
         slice_isSlice2,
         slice_operator_equals,
         slice_operator_nequals,
       ) 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 Slice where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__isSlice" c_CasADi__Slice__isSlice
  :: Ptr (CppVec CInt) -> IO CInt
casADi__Slice__isSlice
  :: Vector Int -> IO Bool
casADi__Slice__isSlice x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Slice__isSlice x0' >>= wrapReturn

-- classy wrapper
slice_isSlice :: Vector Int -> IO Bool
slice_isSlice = casADi__Slice__isSlice


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__isSlice2" c_CasADi__Slice__isSlice2
  :: Ptr (CppVec CInt) -> IO CInt
casADi__Slice__isSlice2
  :: Vector Int -> IO Bool
casADi__Slice__isSlice2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Slice__isSlice2 x0' >>= wrapReturn

-- classy wrapper
slice_isSlice2 :: Vector Int -> IO Bool
slice_isSlice2 = casADi__Slice__isSlice2


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__getAll" c_CasADi__Slice__getAll
  :: Ptr Slice' -> CInt -> IO (Ptr (CppVec CInt))
casADi__Slice__getAll
  :: Slice -> Int -> IO (Vector Int)
casADi__Slice__getAll x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Slice__getAll x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  std::vector< int > CasADi::Slice::getAll(int len) const 
>------------------------------------------------------------------------
>
>Get a vector of indices.
>
>>  std::vector< int > CasADi::Slice::getAll(const Slice &outer, int len) const 
>------------------------------------------------------------------------
>
>Get a vector of indices (nested slice)
-}
slice_getAll :: SliceClass a => a -> Int -> IO (Vector Int)
slice_getAll x = casADi__Slice__getAll (castSlice x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__getAll_TIC" c_CasADi__Slice__getAll_TIC
  :: Ptr Slice' -> Ptr Slice' -> CInt -> IO (Ptr (CppVec CInt))
casADi__Slice__getAll'
  :: Slice -> Slice -> Int -> IO (Vector Int)
casADi__Slice__getAll' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Slice__getAll_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
slice_getAll' :: SliceClass a => a -> Slice -> Int -> IO (Vector Int)
slice_getAll' x = casADi__Slice__getAll' (castSlice x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__operator_equals" c_CasADi__Slice__operator_equals
  :: Ptr Slice' -> Ptr Slice' -> IO CInt
casADi__Slice__operator_equals
  :: Slice -> Slice -> IO Bool
casADi__Slice__operator_equals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Slice__operator_equals x0' x1' >>= wrapReturn

-- classy wrapper
slice_operator_equals :: SliceClass a => a -> Slice -> IO Bool
slice_operator_equals x = casADi__Slice__operator_equals (castSlice x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__operator_nequals" c_CasADi__Slice__operator_nequals
  :: Ptr Slice' -> Ptr Slice' -> IO CInt
casADi__Slice__operator_nequals
  :: Slice -> Slice -> IO Bool
casADi__Slice__operator_nequals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Slice__operator_nequals x0' x1' >>= wrapReturn

-- classy wrapper
slice_operator_nequals :: SliceClass a => a -> Slice -> IO Bool
slice_operator_nequals x = casADi__Slice__operator_nequals (castSlice x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice" c_CasADi__Slice__Slice
  :: IO (Ptr Slice')
casADi__Slice__Slice
  :: IO Slice
casADi__Slice__Slice  =
  c_CasADi__Slice__Slice  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::Slice::Slice()
>------------------------------------------------------------------------
>
>Defailt constructor - all elements.
>
>>  CasADi::Slice::Slice(int i)
>------------------------------------------------------------------------
>
>A single element.
>
>>  CasADi::Slice::Slice(int start, int stop, int step=1)
>------------------------------------------------------------------------
>
>A slice.
>
>>  CasADi::Slice::Slice(const std::vector< int > &v)
>------------------------------------------------------------------------
>
>Construct from an index vector (requires isSlice(v) to be true)
>
>>  CasADi::Slice::Slice(const std::vector< int > &v, Slice &outer)
>------------------------------------------------------------------------
>
>Construct nested slices from an index vector (requires isSlice2(v) to be
>true)
-}
slice :: IO Slice
slice = casADi__Slice__Slice


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice_TIC" c_CasADi__Slice__Slice_TIC
  :: CInt -> IO (Ptr Slice')
casADi__Slice__Slice'
  :: Int -> IO Slice
casADi__Slice__Slice' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Slice__Slice_TIC x0' >>= wrapReturn

-- classy wrapper
slice' :: Int -> IO Slice
slice' = casADi__Slice__Slice'


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice_TIC_TIC" c_CasADi__Slice__Slice_TIC_TIC
  :: CInt -> CInt -> CInt -> IO (Ptr Slice')
casADi__Slice__Slice''
  :: Int -> Int -> Int -> IO Slice
casADi__Slice__Slice'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Slice__Slice_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
slice'' :: Int -> Int -> Int -> IO Slice
slice'' = casADi__Slice__Slice''


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice_TIC_TIC_TIC" c_CasADi__Slice__Slice_TIC_TIC_TIC
  :: CInt -> CInt -> IO (Ptr Slice')
casADi__Slice__Slice'''
  :: Int -> Int -> IO Slice
casADi__Slice__Slice''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Slice__Slice_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
slice''' :: Int -> Int -> IO Slice
slice''' = casADi__Slice__Slice'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice_TIC_TIC_TIC_TIC" c_CasADi__Slice__Slice_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> IO (Ptr Slice')
casADi__Slice__Slice''''
  :: Vector Int -> IO Slice
casADi__Slice__Slice'''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Slice__Slice_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
slice'''' :: Vector Int -> IO Slice
slice'''' = casADi__Slice__Slice''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC" c_CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> Ptr Slice' -> IO (Ptr Slice')
casADi__Slice__Slice'''''
  :: Vector Int -> Slice -> IO Slice
casADi__Slice__Slice''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
slice''''' :: Vector Int -> Slice -> IO Slice
slice''''' = casADi__Slice__Slice'''''