{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Core.QVector.QPointF (
  QVectorQPointFValue (..),
  QVectorQPointFConstPtr (..),
  atConst,
  capacity,
  contains,
  count,
  arrayConst,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QVectorQPointFPtr (..),
  append,
  appendVector,
  at,
  clear,
  array,
  fill,
  fillResize,
  first,
  insert,
  insertMany,
  last,
  prepend,
  remove,
  removeMany,
  removeAll,
  removeFirst,
  removeLast,
  removeOne,
  replace,
  reserve,
  resize,
  squeeze,
  swap,
  takeAt,
  takeFirst,
  takeLast,
  aSSIGN,
  QVectorQPointFConst (..),
  castQVectorQPointFToConst,
  QVectorQPointF (..),
  castQVectorQPointFToNonconst,
  new,
  newWithSize,
  newWithSizeAndValue,
  newCopy,
  QVectorQPointFSuper (..),
  QVectorQPointFSuperConst (..),
  ) where

import Control.Monad ((<=<))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Core.HPointF as HPointF
import qualified Graphics.UI.Qtah.Generated.Core.QPointF as M116
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QVectorQPointF_new" new' ::  HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_newWithSize" newWithSize' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_newWithSizeAndValue" newWithSizeAndValue' ::  HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_newCopy" newCopy' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_append" append' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_appendVector" appendVector' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_at" at' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M116.QPointF)
foreign import ccall "genpop__QVectorQPointF_atConst" atConst' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_capacity" capacity' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_clear" clear' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_contains" contains' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQPointF_count" count' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_array" array' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO (HoppyF.Ptr M116.QPointF)
foreign import ccall "genpop__QVectorQPointF_arrayConst" arrayConst' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_endsWith" endsWith' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQPointF_fill" fill' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_fillResize" fillResize' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_first" first' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO (HoppyF.Ptr M116.QPointF)
foreign import ccall "genpop__QVectorQPointF_firstConst" firstConst' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_get" get' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_indexOf" indexOf' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_insert" insert' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_insertMany" insertMany' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_isEmpty" isEmpty' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQPointF_last" last' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO (HoppyF.Ptr M116.QPointF)
foreign import ccall "genpop__QVectorQPointF_lastConst" lastConst' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_mid" mid' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_midLength" midLength' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_prepend" prepend' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_remove" remove' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_removeMany" removeMany' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_removeAll" removeAll' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_removeFirst" removeFirst' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_removeLast" removeLast' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_removeOne" removeOne' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQPointF_replace" replace' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_reserve" reserve' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_resize" resize' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_size" size' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQPointF_squeeze" squeeze' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_startsWith" startsWith' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQPointF_swap" swap' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr QVectorQPointF -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQPointF_takeAt" takeAt' ::  HoppyF.Ptr QVectorQPointF -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_takeFirst" takeFirst' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_takeLast" takeLast' ::  HoppyF.Ptr QVectorQPointF -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_value" value' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_valueOr" valueOr' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVectorQPointF_ADD" aDD' ::  HoppyF.Ptr QVectorQPointFConst -> HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "genpop__QVectorQPointF_ASSIGN" aSSIGN' ::  HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr QVectorQPointF)
foreign import ccall "gendel__QVectorQPointF" delete'QVectorQPointF :: HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVectorQPointF" deletePtr'QVectorQPointF :: HoppyF.FunPtr (HoppyF.Ptr QVectorQPointFConst -> HoppyP.IO ())

class QVectorQPointFValue a where
  withQVectorQPointFPtr :: a -> (QVectorQPointFConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVectorQPointFConstPtr a => QVectorQPointFValue a where
  withQVectorQPointFPtr = HoppyP.flip ($) . toQVectorQPointFConst

class (HoppyFHR.CppPtr this) => QVectorQPointFConstPtr this where
  toQVectorQPointFConst :: this -> QVectorQPointFConst

atConst :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M116.QPointFConst)
atConst arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M116.QPointFConst
  (atConst' arg'1' arg'2')

capacity :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
capacity arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (capacity' arg'1')

contains :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

count :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

arrayConst :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointFConst)
arrayConst arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M116.QPointFConst
  (arrayConst' arg'1')

endsWith :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWith arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWith' arg'1' arg'2')

firstConst :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointFConst)
firstConst arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M116.QPointFConst
  (firstConst' arg'1')

get :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HPointF.HPointF)
get arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfFrom' arg'1' arg'2' arg'3')

isEmpty :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isEmpty arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEmpty' arg'1')

lastConst :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointFConst)
lastConst arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M116.QPointFConst
  (lastConst' arg'1')

lastIndexOf :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfFrom' arg'1' arg'2' arg'3')

mid :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QVectorQPointF)
mid arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QVectorQPointF
  (mid' arg'1' arg'2')

midLength :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QVectorQPointF)
midLength arg'1 arg'2 arg'3 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QVectorQPointF
  (midLength' arg'1' arg'2' arg'3')

size :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
size arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (size' arg'1')

startsWith :: (QVectorQPointFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWith arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWith' arg'1' arg'2')

value :: (QVectorQPointFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HPointF.HPointF)
value arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QVectorQPointFValue this, M116.QPointFValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO HPointF.HPointF)
valueOr arg'1 arg'2 arg'3 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M116.withQPointFPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

aDD :: (QVectorQPointFValue this, QVectorQPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVectorQPointF)
aDD arg'1 arg'2 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVectorQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QVectorQPointF
  (aDD' arg'1' arg'2')

class (QVectorQPointFConstPtr this) => QVectorQPointFPtr this where
  toQVectorQPointF :: this -> QVectorQPointF

append :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (append' arg'1' arg'2')

appendVector :: (QVectorQPointFPtr this, QVectorQPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendVector arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  withQVectorQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendVector' arg'1' arg'2')

at :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M116.QPointF)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M116.QPointF
  (at' arg'1' arg'2')

clear :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (clear' arg'1')

array :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointF)
array arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  HoppyP.fmap M116.QPointF
  (array' arg'1')

fill :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
fill arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (fill' arg'1' arg'2')

fillResize :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
fillResize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (fillResize' arg'1' arg'2' arg'3')

first :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointF)
first arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  HoppyP.fmap M116.QPointF
  (first' arg'1')

insert :: (QVectorQPointFPtr this, M116.QPointFValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M116.withQPointFPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

insertMany :: (QVectorQPointFPtr this, M116.QPointFValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
insertMany arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M116.withQPointFPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (insertMany' arg'1' arg'2' arg'3' arg'4')

last :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO M116.QPointF)
last arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  HoppyP.fmap M116.QPointF
  (last' arg'1')

prepend :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (prepend' arg'1' arg'2')

remove :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
remove arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (remove' arg'1' arg'2')

removeMany :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
removeMany arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (removeMany' arg'1' arg'2' arg'3')

removeAll :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

removeFirst :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
removeFirst arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (removeFirst' arg'1')

removeLast :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
removeLast arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (removeLast' arg'1')

removeOne :: (QVectorQPointFPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removeOne arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removeOne' arg'1' arg'2')

replace :: (QVectorQPointFPtr this, M116.QPointFValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M116.withQPointFPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

reserve :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
reserve arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (reserve' arg'1' arg'2')

resize :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
resize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (resize' arg'1' arg'2')

squeeze :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
squeeze arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (squeeze' arg'1')

swap :: (QVectorQPointFPtr this, QVectorQPointFPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQVectorQPointF arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

takeAt :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HPointF.HPointF)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (takeFirst' arg'1')

takeLast :: (QVectorQPointFPtr this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QVectorQPointFPtr this, QVectorQPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVectorQPointF)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQPointF arg'1) $ \arg'1' ->
  withQVectorQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQPointF
  (aSSIGN' arg'1' arg'2')

data QVectorQPointFConst =
    QVectorQPointFConst (HoppyF.Ptr QVectorQPointFConst)
  | QVectorQPointFConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQPointFConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QVectorQPointFConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QVectorQPointFConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQVectorQPointFToConst :: QVectorQPointF -> QVectorQPointFConst
castQVectorQPointFToConst (QVectorQPointF ptr') = QVectorQPointFConst $ HoppyF.castPtr ptr'
castQVectorQPointFToConst (QVectorQPointFGc fptr' ptr') = QVectorQPointFConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QVectorQPointFConst where
  nullptr = QVectorQPointFConst HoppyF.nullPtr
  
  withCppPtr (QVectorQPointFConst ptr') f' = f' ptr'
  withCppPtr (QVectorQPointFConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QVectorQPointFConst ptr') = ptr'
  toPtr (QVectorQPointFConstGc _ ptr') = ptr'
  
  touchCppPtr (QVectorQPointFConst _) = HoppyP.return ()
  touchCppPtr (QVectorQPointFConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QVectorQPointFConst where
  delete (QVectorQPointFConst ptr') = delete'QVectorQPointF ptr'
  delete (QVectorQPointFConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QVectorQPointFConst", " object."]
  
  toGc this'@(QVectorQPointFConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QVectorQPointFConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QVectorQPointF :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QVectorQPointFConstGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QVectorQPointFConst QVectorQPointF where copy = newCopy

instance QVectorQPointFConstPtr QVectorQPointFConst where
  toQVectorQPointFConst = HoppyP.id

data QVectorQPointF =
    QVectorQPointF (HoppyF.Ptr QVectorQPointF)
  | QVectorQPointFGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQPointF)
  deriving (HoppyP.Show)

instance HoppyP.Eq QVectorQPointF where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QVectorQPointF where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQVectorQPointFToNonconst :: QVectorQPointFConst -> QVectorQPointF
castQVectorQPointFToNonconst (QVectorQPointFConst ptr') = QVectorQPointF $ HoppyF.castPtr ptr'
castQVectorQPointFToNonconst (QVectorQPointFConstGc fptr' ptr') = QVectorQPointFGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QVectorQPointF where
  nullptr = QVectorQPointF HoppyF.nullPtr
  
  withCppPtr (QVectorQPointF ptr') f' = f' ptr'
  withCppPtr (QVectorQPointFGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QVectorQPointF ptr') = ptr'
  toPtr (QVectorQPointFGc _ ptr') = ptr'
  
  touchCppPtr (QVectorQPointF _) = HoppyP.return ()
  touchCppPtr (QVectorQPointFGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QVectorQPointF where
  delete (QVectorQPointF ptr') = delete'QVectorQPointF $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QVectorQPointFConst)
  delete (QVectorQPointFGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QVectorQPointF", " object."]
  
  toGc this'@(QVectorQPointF ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QVectorQPointFGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QVectorQPointF :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QVectorQPointFGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QVectorQPointF QVectorQPointF where copy = newCopy

instance QVectorQPointFConstPtr QVectorQPointF where
  toQVectorQPointFConst (QVectorQPointF ptr') = QVectorQPointFConst $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr QVectorQPointFConst) ptr'
  toQVectorQPointFConst (QVectorQPointFGc fptr' ptr') = QVectorQPointFConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQPointF -> HoppyF.Ptr QVectorQPointFConst) ptr'

instance QVectorQPointFPtr QVectorQPointF where
  toQVectorQPointF = HoppyP.id

new :: (HoppyP.IO QVectorQPointF)
new =
  HoppyP.fmap QVectorQPointF
  (new')

newWithSize :: (HoppyP.Int) -> (HoppyP.IO QVectorQPointF)
newWithSize arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVectorQPointF
  (newWithSize' arg'1')

newWithSizeAndValue :: (M116.QPointFValue arg'2) => (HoppyP.Int) -> (arg'2) -> (HoppyP.IO QVectorQPointF)
newWithSizeAndValue arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQPointF
  (newWithSizeAndValue' arg'1' arg'2')

newCopy :: (QVectorQPointFValue arg'1) => (arg'1) -> (HoppyP.IO QVectorQPointF)
newCopy arg'1 =
  withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVectorQPointF
  (newCopy' arg'1')

class QVectorQPointFSuper a where
  downToQVectorQPointF :: a -> QVectorQPointF


class QVectorQPointFSuperConst a where
  downToQVectorQPointFConst :: a -> QVectorQPointFConst


instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QVectorQPointF)) QVectorQPointF where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance QVectorQPointFValue a => HoppyFHR.Assignable QVectorQPointF a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QVectorQPointF)) QVectorQPointF where
  decode = HoppyP.fmap QVectorQPointF . HoppyF.peek

instance QtahFHR.HasContents QVectorQPointFConst (HPointF.HPointF) where
  toContents this' = do
    size' <- size this'
    QtahP.mapM (QtahFHR.decode <=< atConst this') [0..size'-1]

instance QtahFHR.HasContents QVectorQPointF (HPointF.HPointF) where
  toContents this' = do
    size' <- size this'
    QtahP.mapM (QtahFHR.decode <=< at this') [0..size'-1]

instance QtahFHR.FromContents QVectorQPointF (HPointF.HPointF) where
  fromContents values' = do
    vector' <- new
    reserve vector' $ QtahFHR.coerceIntegral $ QtahP.length values'
    QtahP.mapM_ (append vector') values'
    QtahP.return vector'