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

module Graphics.UI.Qtah.Generated.Core.QVersionNumber (
  QVersionNumberValue (..),
  QVersionNumberConstPtr (..),
  isNormalized,
  isNull,
  isPrefixOf,
  majorVersion,
  microVersion,
  minorVersion,
  normalized,
  segmentAt,
  segmentCount,
  segments,
  toString,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QVersionNumberPtr (..),
  aSSIGN,
  commonPrefix,
  compare,
  fromString,
  QVersionNumberConst (..),
  castQVersionNumberToConst,
  QVersionNumber (..),
  castQVersionNumberToNonconst,
  new,
  newWithVector,
  newWithMajor,
  newWithMajorMinor,
  newWithMajorMinorMicro,
  newCopy,
  QVersionNumberSuper (..),
  QVersionNumberSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QVector.Int as M214
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QVersionNumber_new" new' ::  HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_newWithVector" newWithVector' ::  HoppyF.Ptr M214.QVectorInt -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_newWithMajor" newWithMajor' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_newWithMajorMinor" newWithMajorMinor' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_newWithMajorMinorMicro" newWithMajorMinorMicro' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_newCopy" newCopy' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "genpop__QVersionNumber_commonPrefix" commonPrefix' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr QVersionNumberConst)
foreign import ccall "genpop__QVersionNumber_compare" compare' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_fromString" fromString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QVersionNumberConst)
foreign import ccall "genpop__QVersionNumber_isNormalized" isNormalized' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_isNull" isNull' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_isPrefixOf" isPrefixOf' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_majorVersion" majorVersion' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_microVersion" microVersion' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_minorVersion" minorVersion' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_normalized" normalized' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr QVersionNumberConst)
foreign import ccall "genpop__QVersionNumber_segmentAt" segmentAt' ::  HoppyF.Ptr QVersionNumberConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_segmentCount" segmentCount' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVersionNumber_segments" segments' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr M214.QVectorInt)
foreign import ccall "genpop__QVersionNumber_toString" toString' ::  HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVersionNumber_EQ" eQ' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_NE" nE' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_LT" lT' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_LE" lE' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_GT" gT' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_GE" gE' ::  HoppyF.Ptr QVersionNumberConst -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVersionNumber_ASSIGN" aSSIGN' ::  HoppyF.Ptr QVersionNumber -> HoppyF.Ptr QVersionNumberConst -> HoppyP.IO (HoppyF.Ptr QVersionNumber)
foreign import ccall "gendel__QVersionNumber" delete'QVersionNumber :: HoppyF.Ptr QVersionNumberConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVersionNumber" deletePtr'QVersionNumber :: HoppyF.FunPtr (HoppyF.Ptr QVersionNumberConst -> HoppyP.IO ())

class QVersionNumberValue a where
  withQVersionNumberPtr :: a -> (QVersionNumberConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVersionNumberConstPtr a => QVersionNumberValue a where
  withQVersionNumberPtr = HoppyP.flip ($) . toQVersionNumberConst

class (HoppyFHR.CppPtr this) => QVersionNumberConstPtr this where
  toQVersionNumberConst :: this -> QVersionNumberConst

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

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

isPrefixOf :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isPrefixOf arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isPrefixOf' arg'1' arg'2')

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

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

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

normalized :: (QVersionNumberValue this) => (this) {- ^ this -} -> (HoppyP.IO QVersionNumber)
normalized arg'1 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QVersionNumberConst) =<<
  (normalized' arg'1')

segmentAt :: (QVersionNumberValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
segmentAt arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (segmentAt' arg'1' arg'2')

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

segments :: (QVersionNumberValue this) => (this) {- ^ this -} -> (HoppyP.IO M214.QVectorInt)
segments arg'1 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M214.QVectorInt
  (segments' arg'1')

toString :: (QVersionNumberValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toString arg'1 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toString' arg'1')

eQ :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

lT :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lT arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lT' arg'1' arg'2')

lE :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lE arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lE' arg'1' arg'2')

gT :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gT arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gT' arg'1' arg'2')

gE :: (QVersionNumberValue this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gE arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gE' arg'1' arg'2')

class (QVersionNumberConstPtr this) => QVersionNumberPtr this where
  toQVersionNumber :: this -> QVersionNumber

aSSIGN :: (QVersionNumberPtr this, QVersionNumberValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVersionNumber)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVersionNumber arg'1) $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVersionNumber
  (aSSIGN' arg'1' arg'2')

commonPrefix :: (QVersionNumberValue arg'1, QVersionNumberValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QVersionNumber)
commonPrefix arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QVersionNumberConst) =<<
  (commonPrefix' arg'1' arg'2')

compare :: (QVersionNumberValue arg'1, QVersionNumberValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
compare arg'1 arg'2 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVersionNumberPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (compare' arg'1' arg'2')

fromString :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QVersionNumber)
fromString arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QVersionNumberConst) =<<
  (fromString' arg'1')

data QVersionNumberConst =
    QVersionNumberConst (HoppyF.Ptr QVersionNumberConst)
  | QVersionNumberConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVersionNumberConst)
  deriving (HoppyP.Show)

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

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

castQVersionNumberToConst :: QVersionNumber -> QVersionNumberConst
castQVersionNumberToConst (QVersionNumber ptr') = QVersionNumberConst $ HoppyF.castPtr ptr'
castQVersionNumberToConst (QVersionNumberGc fptr' ptr') = QVersionNumberConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVersionNumberConst QVersionNumber where copy = newCopy

instance QVersionNumberConstPtr QVersionNumberConst where
  toQVersionNumberConst = HoppyP.id

data QVersionNumber =
    QVersionNumber (HoppyF.Ptr QVersionNumber)
  | QVersionNumberGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVersionNumber)
  deriving (HoppyP.Show)

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

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

castQVersionNumberToNonconst :: QVersionNumberConst -> QVersionNumber
castQVersionNumberToNonconst (QVersionNumberConst ptr') = QVersionNumber $ HoppyF.castPtr ptr'
castQVersionNumberToNonconst (QVersionNumberConstGc fptr' ptr') = QVersionNumberGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVersionNumber QVersionNumber where copy = newCopy

instance QVersionNumberConstPtr QVersionNumber where
  toQVersionNumberConst (QVersionNumber ptr') = QVersionNumberConst $ (HoppyF.castPtr :: HoppyF.Ptr QVersionNumber -> HoppyF.Ptr QVersionNumberConst) ptr'
  toQVersionNumberConst (QVersionNumberGc fptr' ptr') = QVersionNumberConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVersionNumber -> HoppyF.Ptr QVersionNumberConst) ptr'

instance QVersionNumberPtr QVersionNumber where
  toQVersionNumber = HoppyP.id

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

newWithVector :: (M214.QVectorIntPtr arg'1) => (arg'1) -> (HoppyP.IO QVersionNumber)
newWithVector arg'1 =
  HoppyFHR.withCppPtr (M214.toQVectorInt arg'1) $ \arg'1' ->
  HoppyP.fmap QVersionNumber
  (newWithVector' arg'1')

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

newWithMajorMinor :: (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QVersionNumber)
newWithMajorMinor arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QVersionNumber
  (newWithMajorMinor' arg'1' arg'2')

newWithMajorMinorMicro :: (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QVersionNumber)
newWithMajorMinorMicro arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QVersionNumber
  (newWithMajorMinorMicro' arg'1' arg'2' arg'3')

newCopy :: (QVersionNumberValue arg'1) => (arg'1) -> (HoppyP.IO QVersionNumber)
newCopy arg'1 =
  withQVersionNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVersionNumber
  (newCopy' arg'1')

class QVersionNumberSuper a where
  downToQVersionNumber :: a -> QVersionNumber


class QVersionNumberSuperConst a where
  downToQVersionNumberConst :: a -> QVersionNumberConst


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

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

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

instance HoppyFHR.Decodable QVersionNumber (QVersionNumber) where
  decode = HoppyFHR.decode . toQVersionNumberConst

instance HoppyFHR.Decodable QVersionNumberConst (QVersionNumber) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc