QDateTime.hs

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

module Graphics.UI.Qtah.Generated.Core.QDateTime (
  QDateTimeValue (..),
  QDateTimeConstPtr (..),
  addDays,
  addMSecs,
  addMonths,
  addSecs,
  addYears,
  date,
  daysTo,
  isDaylightTime,
  isNull,
  isValid,
  msecsTo,
  offsetFromUtc,
  secsTo,
  time,
  timeSpec,
  timeZone,
  timeZoneAbbreviation,
  toLocalTime,
  toMSecsSinceEpoch,
  toOffsetFromUtc,
  toSecsSinceEpoch,
  toString,
  toStringWithDateFormat,
  toStringWithStringFormat,
  toTimeSpec,
  toTimeZone,
  toUTC,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QDateTimePtr (..),
  setDate,
  setMSecsSinceEpoch,
  setOffsetFromUtc,
  setSecsSinceEpoch,
  setTime,
  setTimeSpec,
  setTimeZone,
  swap,
  aSSIGN,
  currentDateTime,
  currentDateTimeUtc,
  currentMSecsSinceEpoch,
  currentSecsSinceEpoch,
  fromMSecsSinceEpoch,
  fromMSecsSinceEpochWithTimeSpec,
  fromMSecsSinceEpochWithTimeSpecAndOffset,
  fromMSecsSinceEpochWithTimeZone,
  fromSecsSinceEpoch,
  fromSecsSinceEpochWithTimeSpec,
  fromSecsSinceEpochWithTimeSpecAndOffset,
  fromSecsSinceEpochWithTimeZone,
  fromString,
  fromStringWithDateFormat,
  fromStringWithStringFormat,
  QDateTimeConst (..),
  castQDateTimeToConst,
  QDateTime (..),
  castQDateTimeToNonconst,
  new,
  newWithDate,
  newWithDateAndTime,
  newWithDateAndTimeAndTimeSpec,
  newWithDateAndTimeAndTimeSpecAndOffset,
  newWithDateAndTimeAndTimeZone,
  newCopy,
  QDateTimeSuper (..),
  QDateTimeSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Data.Int as HoppyDI
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.QDate as M22
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QTime as M158
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QTimeZone as M164
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QDateTime_new" new' ::  HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newWithDate" newWithDate' ::  HoppyF.Ptr M22.QDateConst -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newWithDateAndTime" newWithDateAndTime' ::  HoppyF.Ptr M22.QDateConst -> HoppyF.Ptr M158.QTimeConst -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newWithDateAndTimeAndTimeSpec" newWithDateAndTimeAndTimeSpec' ::  HoppyF.Ptr M22.QDateConst -> HoppyF.Ptr M158.QTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newWithDateAndTimeAndTimeSpecAndOffset" newWithDateAndTimeAndTimeSpecAndOffset' ::  HoppyF.Ptr M22.QDateConst -> HoppyF.Ptr M158.QTimeConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newWithDateAndTimeAndTimeZone" newWithDateAndTimeAndTimeZone' ::  HoppyF.Ptr M22.QDateConst -> HoppyF.Ptr M158.QTimeConst -> HoppyF.Ptr M164.QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_newCopy" newCopy' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "genpop__QDateTime_addDays" addDays' ::  HoppyF.Ptr QDateTimeConst -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_addMSecs" addMSecs' ::  HoppyF.Ptr QDateTimeConst -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_addMonths" addMonths' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_addSecs" addSecs' ::  HoppyF.Ptr QDateTimeConst -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_addYears" addYears' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_currentDateTime" currentDateTime' ::  HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_currentDateTimeUtc" currentDateTimeUtc' ::  HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_currentMSecsSinceEpoch" currentMSecsSinceEpoch' ::  HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_currentSecsSinceEpoch" currentSecsSinceEpoch' ::  HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_date" date' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M22.QDateConst)
foreign import ccall "genpop__QDateTime_daysTo" daysTo' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_fromMSecsSinceEpoch" fromMSecsSinceEpoch' ::  HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromMSecsSinceEpochWithTimeSpec" fromMSecsSinceEpochWithTimeSpec' ::  HoppyDI.Int64 -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromMSecsSinceEpochWithTimeSpecAndOffset" fromMSecsSinceEpochWithTimeSpecAndOffset' ::  HoppyDI.Int64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromMSecsSinceEpochWithTimeZone" fromMSecsSinceEpochWithTimeZone' ::  HoppyDI.Int64 -> HoppyF.Ptr M164.QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromSecsSinceEpoch" fromSecsSinceEpoch' ::  HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromSecsSinceEpochWithTimeSpec" fromSecsSinceEpochWithTimeSpec' ::  HoppyDI.Int64 -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromSecsSinceEpochWithTimeSpecAndOffset" fromSecsSinceEpochWithTimeSpecAndOffset' ::  HoppyDI.Int64 -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromSecsSinceEpochWithTimeZone" fromSecsSinceEpochWithTimeZone' ::  HoppyDI.Int64 -> HoppyF.Ptr M164.QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromString" fromString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromStringWithDateFormat" fromStringWithDateFormat' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_fromStringWithStringFormat" fromStringWithStringFormat' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_isDaylightTime" isDaylightTime' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_isNull" isNull' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_isValid" isValid' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_msecsTo" msecsTo' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_offsetFromUtc" offsetFromUtc' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDateTime_secsTo" secsTo' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_setDate" setDate' ::  HoppyF.Ptr QDateTime -> HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setMSecsSinceEpoch" setMSecsSinceEpoch' ::  HoppyF.Ptr QDateTime -> HoppyDI.Int64 -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setOffsetFromUtc" setOffsetFromUtc' ::  HoppyF.Ptr QDateTime -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setSecsSinceEpoch" setSecsSinceEpoch' ::  HoppyF.Ptr QDateTime -> HoppyDI.Int64 -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setTime" setTime' ::  HoppyF.Ptr QDateTime -> HoppyF.Ptr M158.QTimeConst -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setTimeSpec" setTimeSpec' ::  HoppyF.Ptr QDateTime -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_setTimeZone" setTimeZone' ::  HoppyF.Ptr QDateTime -> HoppyF.Ptr M164.QTimeZoneConst -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_swap" swap' ::  HoppyF.Ptr QDateTime -> HoppyF.Ptr QDateTime -> HoppyP.IO ()
foreign import ccall "genpop__QDateTime_time" time' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M158.QTimeConst)
foreign import ccall "genpop__QDateTime_timeSpec" timeSpec' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDateTime_timeZone" timeZone' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M164.QTimeZoneConst)
foreign import ccall "genpop__QDateTime_timeZoneAbbreviation" timeZoneAbbreviation' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDateTime_toLocalTime" toLocalTime' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_toMSecsSinceEpoch" toMSecsSinceEpoch' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_toOffsetFromUtc" toOffsetFromUtc' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_toSecsSinceEpoch" toSecsSinceEpoch' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QDateTime_toString" toString' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDateTime_toStringWithDateFormat" toStringWithDateFormat' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDateTime_toStringWithStringFormat" toStringWithStringFormat' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDateTime_toTimeSpec" toTimeSpec' ::  HoppyF.Ptr QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_toTimeZone" toTimeZone' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr M164.QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_toUTC" toUTC' ::  HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr QDateTimeConst)
foreign import ccall "genpop__QDateTime_EQ" eQ' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_NE" nE' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_LT" lT' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_LE" lE' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_GT" gT' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_GE" gE' ::  HoppyF.Ptr QDateTimeConst -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDateTime_ASSIGN" aSSIGN' ::  HoppyF.Ptr QDateTime -> HoppyF.Ptr QDateTimeConst -> HoppyP.IO (HoppyF.Ptr QDateTime)
foreign import ccall "gendel__QDateTime" delete'QDateTime :: HoppyF.Ptr QDateTimeConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDateTime" deletePtr'QDateTime :: HoppyF.FunPtr (HoppyF.Ptr QDateTimeConst -> HoppyP.IO ())

class QDateTimeValue a where
  withQDateTimePtr :: a -> (QDateTimeConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDateTimeConstPtr a => QDateTimeValue a where
  withQDateTimePtr = HoppyP.flip ($) . toQDateTimeConst

class (HoppyFHR.CppPtr this) => QDateTimeConstPtr this where
  toQDateTimeConst :: this -> QDateTimeConst

addDays :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QDateTime)
addDays arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (addDays' arg'1' arg'2')

addMSecs :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QDateTime)
addMSecs arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (addMSecs' arg'1' arg'2')

addMonths :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
addMonths arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (addMonths' arg'1' arg'2')

addSecs :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QDateTime)
addSecs arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (addSecs' arg'1' arg'2')

addYears :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
addYears arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (addYears' arg'1' arg'2')

date :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO M22.QDate)
date arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M22.QDateConst) =<<
  (date' arg'1')

daysTo :: (QDateTimeValue this, QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyDI.Int64)
daysTo arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (daysTo' arg'1' arg'2')

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

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

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

msecsTo :: (QDateTimeValue this, QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyDI.Int64)
msecsTo arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (msecsTo' arg'1' arg'2')

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

secsTo :: (QDateTimeValue this, QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyDI.Int64)
secsTo arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (secsTo' arg'1' arg'2')

time :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO M158.QTime)
time arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M158.QTimeConst) =<<
  (time' arg'1')

timeSpec :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtTimeSpec)
timeSpec arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (timeSpec' arg'1')

timeZone :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO M164.QTimeZone)
timeZone arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M164.QTimeZoneConst) =<<
  (timeZone' arg'1')

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

toLocalTime :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO QDateTime)
toLocalTime arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (toLocalTime' arg'1')

toMSecsSinceEpoch :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
toMSecsSinceEpoch arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toMSecsSinceEpoch' arg'1')

toOffsetFromUtc :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
toOffsetFromUtc arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (toOffsetFromUtc' arg'1' arg'2')

toSecsSinceEpoch :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
toSecsSinceEpoch arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toSecsSinceEpoch' arg'1')

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

toStringWithDateFormat :: (QDateTimeValue this) => (this) {- ^ this -} -> (M190.QtDateFormat) -> (HoppyP.IO QtahP.String)
toStringWithDateFormat arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toStringWithDateFormat' arg'1' arg'2')

toStringWithStringFormat :: (QDateTimeValue this) => (this) {- ^ this -} -> (M190.QtDateFormat) -> (HoppyP.IO QtahP.String)
toStringWithStringFormat arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toStringWithStringFormat' arg'1' arg'2')

toTimeSpec :: (QDateTimeValue this) => (this) {- ^ this -} -> (M190.QtTimeSpec) -> (HoppyP.IO QDateTime)
toTimeSpec arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (toTimeSpec' arg'1' arg'2')

toTimeZone :: (QDateTimeValue this, M164.QTimeZoneValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QDateTime)
toTimeZone arg'1 arg'2 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M164.withQTimeZonePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (toTimeZone' arg'1' arg'2')

toUTC :: (QDateTimeValue this) => (this) {- ^ this -} -> (HoppyP.IO QDateTime)
toUTC arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (toUTC' arg'1')

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

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

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

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

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

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

class (QDateTimeConstPtr this) => QDateTimePtr this where
  toQDateTime :: this -> QDateTime

setDate :: (QDateTimePtr this, M22.QDateValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setDate arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  M22.withQDatePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setDate' arg'1' arg'2')

setMSecsSinceEpoch :: (QDateTimePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO ())
setMSecsSinceEpoch arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setMSecsSinceEpoch' arg'1' arg'2')

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

setSecsSinceEpoch :: (QDateTimePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO ())
setSecsSinceEpoch arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setSecsSinceEpoch' arg'1' arg'2')

setTime :: (QDateTimePtr this, M158.QTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTime arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  M158.withQTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setTime' arg'1' arg'2')

setTimeSpec :: (QDateTimePtr this) => (this) {- ^ this -} -> (M190.QtTimeSpec) -> (HoppyP.IO ())
setTimeSpec arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setTimeSpec' arg'1' arg'2')

setTimeZone :: (QDateTimePtr this, M164.QTimeZoneValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTimeZone arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  M164.withQTimeZonePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setTimeZone' arg'1' arg'2')

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

aSSIGN :: (QDateTimePtr this, QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QDateTime)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDateTime arg'1) $ \arg'1' ->
  withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QDateTime
  (aSSIGN' arg'1' arg'2')

currentDateTime :: (HoppyP.IO QDateTime)
currentDateTime =
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (currentDateTime')

currentDateTimeUtc :: (HoppyP.IO QDateTime)
currentDateTimeUtc =
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (currentDateTimeUtc')

currentMSecsSinceEpoch :: (HoppyP.IO HoppyDI.Int64)
currentMSecsSinceEpoch =
  (currentMSecsSinceEpoch')

currentSecsSinceEpoch :: (HoppyP.IO HoppyDI.Int64)
currentSecsSinceEpoch =
  (currentSecsSinceEpoch')

fromMSecsSinceEpoch :: (HoppyDI.Int64) -> (HoppyP.IO QDateTime)
fromMSecsSinceEpoch arg'1 =
  let arg'1' = arg'1 in
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromMSecsSinceEpoch' arg'1')

fromMSecsSinceEpochWithTimeSpec :: (HoppyDI.Int64) -> (M190.QtTimeSpec) -> (HoppyP.IO QDateTime)
fromMSecsSinceEpochWithTimeSpec arg'1 arg'2 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromMSecsSinceEpochWithTimeSpec' arg'1' arg'2')

fromMSecsSinceEpochWithTimeSpecAndOffset :: (HoppyDI.Int64) -> (M190.QtTimeSpec) -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
fromMSecsSinceEpochWithTimeSpecAndOffset arg'1 arg'2 arg'3 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromMSecsSinceEpochWithTimeSpecAndOffset' arg'1' arg'2' arg'3')

fromMSecsSinceEpochWithTimeZone :: (M164.QTimeZoneValue arg'2) => (HoppyDI.Int64) -> (arg'2) -> (HoppyP.IO QDateTime)
fromMSecsSinceEpochWithTimeZone arg'1 arg'2 =
  let arg'1' = arg'1 in
  M164.withQTimeZonePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromMSecsSinceEpochWithTimeZone' arg'1' arg'2')

fromSecsSinceEpoch :: (HoppyDI.Int64) -> (HoppyP.IO QDateTime)
fromSecsSinceEpoch arg'1 =
  let arg'1' = arg'1 in
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromSecsSinceEpoch' arg'1')

fromSecsSinceEpochWithTimeSpec :: (HoppyDI.Int64) -> (M190.QtTimeSpec) -> (HoppyP.IO QDateTime)
fromSecsSinceEpochWithTimeSpec arg'1 arg'2 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromSecsSinceEpochWithTimeSpec' arg'1' arg'2')

fromSecsSinceEpochWithTimeSpecAndOffset :: (HoppyDI.Int64) -> (M190.QtTimeSpec) -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
fromSecsSinceEpochWithTimeSpecAndOffset arg'1 arg'2 arg'3 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromSecsSinceEpochWithTimeSpecAndOffset' arg'1' arg'2' arg'3')

fromSecsSinceEpochWithTimeZone :: (M164.QTimeZoneValue arg'2) => (HoppyDI.Int64) -> (arg'2) -> (HoppyP.IO QDateTime)
fromSecsSinceEpochWithTimeZone arg'1 arg'2 =
  let arg'1' = arg'1 in
  M164.withQTimeZonePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromSecsSinceEpochWithTimeZone' arg'1' arg'2')

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

fromStringWithDateFormat :: (M142.QStringValue arg'1) => (arg'1) -> (M190.QtDateFormat) -> (HoppyP.IO QDateTime)
fromStringWithDateFormat arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromStringWithDateFormat' arg'1' arg'2')

fromStringWithStringFormat :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDateTime)
fromStringWithStringFormat arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QDateTimeConst) =<<
  (fromStringWithStringFormat' arg'1' arg'2')

data QDateTimeConst =
    QDateTimeConst (HoppyF.Ptr QDateTimeConst)
  | QDateTimeConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDateTimeConst)
  deriving (HoppyP.Show)

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

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

castQDateTimeToConst :: QDateTime -> QDateTimeConst
castQDateTimeToConst (QDateTime ptr') = QDateTimeConst $ HoppyF.castPtr ptr'
castQDateTimeToConst (QDateTimeGc fptr' ptr') = QDateTimeConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QDateTimeConst QDateTime where copy = newCopy

instance QDateTimeConstPtr QDateTimeConst where
  toQDateTimeConst = HoppyP.id

data QDateTime =
    QDateTime (HoppyF.Ptr QDateTime)
  | QDateTimeGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDateTime)
  deriving (HoppyP.Show)

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

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

castQDateTimeToNonconst :: QDateTimeConst -> QDateTime
castQDateTimeToNonconst (QDateTimeConst ptr') = QDateTime $ HoppyF.castPtr ptr'
castQDateTimeToNonconst (QDateTimeConstGc fptr' ptr') = QDateTimeGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QDateTime QDateTime where copy = newCopy

instance QDateTimeConstPtr QDateTime where
  toQDateTimeConst (QDateTime ptr') = QDateTimeConst $ (HoppyF.castPtr :: HoppyF.Ptr QDateTime -> HoppyF.Ptr QDateTimeConst) ptr'
  toQDateTimeConst (QDateTimeGc fptr' ptr') = QDateTimeConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDateTime -> HoppyF.Ptr QDateTimeConst) ptr'

instance QDateTimePtr QDateTime where
  toQDateTime = HoppyP.id

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

newWithDate :: (M22.QDateValue arg'1) => (arg'1) -> (HoppyP.IO QDateTime)
newWithDate arg'1 =
  M22.withQDatePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QDateTime
  (newWithDate' arg'1')

newWithDateAndTime :: (M22.QDateValue arg'1, M158.QTimeValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDateTime)
newWithDateAndTime arg'1 arg'2 =
  M22.withQDatePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M158.withQTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QDateTime
  (newWithDateAndTime' arg'1' arg'2')

newWithDateAndTimeAndTimeSpec :: (M22.QDateValue arg'1, M158.QTimeValue arg'2) => (arg'1) -> (arg'2) -> (M190.QtTimeSpec) -> (HoppyP.IO QDateTime)
newWithDateAndTimeAndTimeSpec arg'1 arg'2 arg'3 =
  M22.withQDatePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M158.withQTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QDateTime
  (newWithDateAndTimeAndTimeSpec' arg'1' arg'2' arg'3')

newWithDateAndTimeAndTimeSpecAndOffset :: (M22.QDateValue arg'1, M158.QTimeValue arg'2) => (arg'1) -> (arg'2) -> (M190.QtTimeSpec) -> (HoppyP.Int) -> (HoppyP.IO QDateTime)
newWithDateAndTimeAndTimeSpecAndOffset arg'1 arg'2 arg'3 arg'4 =
  M22.withQDatePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M158.withQTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QDateTime
  (newWithDateAndTimeAndTimeSpecAndOffset' arg'1' arg'2' arg'3' arg'4')

newWithDateAndTimeAndTimeZone :: (M22.QDateValue arg'1, M158.QTimeValue arg'2, M164.QTimeZoneValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QDateTime)
newWithDateAndTimeAndTimeZone arg'1 arg'2 arg'3 =
  M22.withQDatePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M158.withQTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M164.withQTimeZonePtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QDateTime
  (newWithDateAndTimeAndTimeZone' arg'1' arg'2' arg'3')

newCopy :: (QDateTimeValue arg'1) => (arg'1) -> (HoppyP.IO QDateTime)
newCopy arg'1 =
  withQDateTimePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QDateTime
  (newCopy' arg'1')

class QDateTimeSuper a where
  downToQDateTime :: a -> QDateTime


class QDateTimeSuperConst a where
  downToQDateTimeConst :: a -> QDateTimeConst


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

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

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

instance HoppyFHR.Decodable QDateTime (QDateTime) where
  decode = HoppyFHR.decode . toQDateTimeConst

instance HoppyFHR.Decodable QDateTimeConst (QDateTime) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc