QTimeZone.hs

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

module Graphics.UI.Qtah.Generated.Core.QTimeZone (
  QTimeZoneValue (..),
  QTimeZoneConstPtr (..),
  abbreviation,
  comment,
  daylightTimeOffset,
  displayNameWithDateTime,
  displayNameWithDateTimeAndNameType,
  displayNameWithTimeType,
  displayNameWithTimeTypeAndNameType,
  hasDaylightTime,
  hasTransitions,
  id,
  isDaylightTime,
  isValid,
  offsetFromUtc,
  standardTimeOffset,
  QTimeZonePtr (..),
  swap,
  aSSIGN,
  availableTimeZoneIds,
  availableTimeZoneIdsWithOffset,
  ianaIdToWindowsId,
  isTimeZoneIdAvailable,
  systemTimeZone,
  systemTimeZoneId,
  utc,
  windowsIdToDefaultIanaId,
  windowsIdToIanaIds,
  QTimeZoneConst (..),
  castQTimeZoneToConst,
  QTimeZone (..),
  castQTimeZoneToNonconst,
  new,
  newFull1,
  newWithOffset,
  newWithByteArray,
  newCopy,
  QTimeZoneSuper (..),
  QTimeZoneSuperConst (..),
  QTimeZoneNameType (..),
  QTimeZoneTimeType (..),
  ) where

import Control.Monad ((>=>))
import qualified Data.ByteString as QtahDBS
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.QByteArray as M12
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QDateTime as M24
import qualified Graphics.UI.Qtah.Generated.Core.QList.QByteArray as M196
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QTimeZone_new" new' ::  HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "genpop__QTimeZone_newFull1" newFull1' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "genpop__QTimeZone_newWithOffset" newWithOffset' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "genpop__QTimeZone_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "genpop__QTimeZone_newCopy" newCopy' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "genpop__QTimeZone_abbreviation" abbreviation' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_availableTimeZoneIds" availableTimeZoneIds' ::  HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QTimeZone_availableTimeZoneIdsWithOffset" availableTimeZoneIdsWithOffset' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QTimeZone_comment" comment' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_daylightTimeOffset" daylightTimeOffset' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QTimeZone_displayNameWithDateTime" displayNameWithDateTime' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_displayNameWithDateTimeAndNameType" displayNameWithDateTimeAndNameType' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_displayNameWithTimeType" displayNameWithTimeType' ::  HoppyF.Ptr QTimeZoneConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_displayNameWithTimeTypeAndNameType" displayNameWithTimeTypeAndNameType' ::  HoppyF.Ptr QTimeZoneConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTimeZone_hasDaylightTime" hasDaylightTime' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTimeZone_hasTransitions" hasTransitions' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTimeZone_ianaIdToWindowsId" ianaIdToWindowsId' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTimeZone_id" id' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTimeZone_isDaylightTime" isDaylightTime' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTimeZone_isTimeZoneIdAvailable" isTimeZoneIdAvailable' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTimeZone_isValid" isValid' ::  HoppyF.Ptr QTimeZoneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTimeZone_offsetFromUtc" offsetFromUtc' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QTimeZone_standardTimeOffset" standardTimeOffset' ::  HoppyF.Ptr QTimeZoneConst -> HoppyF.Ptr M24.QDateTimeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QTimeZone_swap" swap' ::  HoppyF.Ptr QTimeZone -> HoppyF.Ptr QTimeZone -> HoppyP.IO ()
foreign import ccall "genpop__QTimeZone_systemTimeZone" systemTimeZone' ::  HoppyP.IO (HoppyF.Ptr QTimeZoneConst)
foreign import ccall "genpop__QTimeZone_systemTimeZoneId" systemTimeZoneId' ::  HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTimeZone_utc" utc' ::  HoppyP.IO (HoppyF.Ptr QTimeZoneConst)
foreign import ccall "genpop__QTimeZone_windowsIdToDefaultIanaId" windowsIdToDefaultIanaId' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTimeZone_windowsIdToIanaIds" windowsIdToIanaIds' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QTimeZone_ASSIGN" aSSIGN' ::  HoppyF.Ptr QTimeZone -> HoppyF.Ptr QTimeZoneConst -> HoppyP.IO (HoppyF.Ptr QTimeZone)
foreign import ccall "gendel__QTimeZone" delete'QTimeZone :: HoppyF.Ptr QTimeZoneConst -> HoppyP.IO ()
foreign import ccall "&gendel__QTimeZone" deletePtr'QTimeZone :: HoppyF.FunPtr (HoppyF.Ptr QTimeZoneConst -> HoppyP.IO ())

class QTimeZoneValue a where
  withQTimeZonePtr :: a -> (QTimeZoneConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QTimeZoneConstPtr a => QTimeZoneValue a where
  withQTimeZonePtr = HoppyP.flip ($) . toQTimeZoneConst

class (HoppyFHR.CppPtr this) => QTimeZoneConstPtr this where
  toQTimeZoneConst :: this -> QTimeZoneConst

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

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

daylightTimeOffset :: (QTimeZoneValue this, M24.QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
daylightTimeOffset arg'1 arg'2 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M24.withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (daylightTimeOffset' arg'1' arg'2')

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

displayNameWithDateTimeAndNameType :: (QTimeZoneValue this, M24.QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QTimeZoneNameType) -> (HoppyP.IO QtahP.String)
displayNameWithDateTimeAndNameType arg'1 arg'2 arg'3 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M24.withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (displayNameWithDateTimeAndNameType' arg'1' arg'2' arg'3')

displayNameWithTimeType :: (QTimeZoneValue this) => (this) {- ^ this -} -> (QTimeZoneTimeType) -> (HoppyP.IO QtahP.String)
displayNameWithTimeType arg'1 arg'2 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (displayNameWithTimeType' arg'1' arg'2')

displayNameWithTimeTypeAndNameType :: (QTimeZoneValue this) => (this) {- ^ this -} -> (QTimeZoneTimeType) -> (QTimeZoneNameType) -> (HoppyP.IO QtahP.String)
displayNameWithTimeTypeAndNameType arg'1 arg'2 arg'3 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (displayNameWithTimeTypeAndNameType' arg'1' arg'2' arg'3')

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

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

id :: (QTimeZoneValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
id arg'1 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (id' arg'1')

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

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

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

standardTimeOffset :: (QTimeZoneValue this, M24.QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
standardTimeOffset arg'1 arg'2 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M24.withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (standardTimeOffset' arg'1' arg'2')

class (QTimeZoneConstPtr this) => QTimeZonePtr this where
  toQTimeZone :: this -> QTimeZone

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

aSSIGN :: (QTimeZonePtr this, QTimeZoneValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QTimeZone)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQTimeZone arg'1) $ \arg'1' ->
  withQTimeZonePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QTimeZone
  (aSSIGN' arg'1' arg'2')

availableTimeZoneIds :: (HoppyP.IO [QtahDBS.ByteString])
availableTimeZoneIds =
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (availableTimeZoneIds')

availableTimeZoneIdsWithOffset :: (HoppyP.Int) -> (HoppyP.IO [QtahDBS.ByteString])
availableTimeZoneIdsWithOffset arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (availableTimeZoneIdsWithOffset' arg'1')

ianaIdToWindowsId :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QtahDBS.ByteString)
ianaIdToWindowsId arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (ianaIdToWindowsId' arg'1')

isTimeZoneIdAvailable :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
isTimeZoneIdAvailable arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isTimeZoneIdAvailable' arg'1')

systemTimeZone :: (HoppyP.IO QTimeZone)
systemTimeZone =
  (HoppyFHR.decodeAndDelete . QTimeZoneConst) =<<
  (systemTimeZone')

systemTimeZoneId :: (HoppyP.IO QtahDBS.ByteString)
systemTimeZoneId =
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (systemTimeZoneId')

utc :: (HoppyP.IO QTimeZone)
utc =
  (HoppyFHR.decodeAndDelete . QTimeZoneConst) =<<
  (utc')

windowsIdToDefaultIanaId :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QtahDBS.ByteString)
windowsIdToDefaultIanaId arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (windowsIdToDefaultIanaId' arg'1')

windowsIdToIanaIds :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO [QtahDBS.ByteString])
windowsIdToIanaIds arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (windowsIdToIanaIds' arg'1')

data QTimeZoneConst =
    QTimeZoneConst (HoppyF.Ptr QTimeZoneConst)
  | QTimeZoneConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTimeZoneConst)
  deriving (HoppyP.Show)

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

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

castQTimeZoneToConst :: QTimeZone -> QTimeZoneConst
castQTimeZoneToConst (QTimeZone ptr') = QTimeZoneConst $ HoppyF.castPtr ptr'
castQTimeZoneToConst (QTimeZoneGc fptr' ptr') = QTimeZoneConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QTimeZoneConst QTimeZone where copy = newCopy

instance QTimeZoneConstPtr QTimeZoneConst where
  toQTimeZoneConst = HoppyP.id

data QTimeZone =
    QTimeZone (HoppyF.Ptr QTimeZone)
  | QTimeZoneGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTimeZone)
  deriving (HoppyP.Show)

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

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

castQTimeZoneToNonconst :: QTimeZoneConst -> QTimeZone
castQTimeZoneToNonconst (QTimeZoneConst ptr') = QTimeZone $ HoppyF.castPtr ptr'
castQTimeZoneToNonconst (QTimeZoneConstGc fptr' ptr') = QTimeZoneGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QTimeZone QTimeZone where copy = newCopy

instance QTimeZoneConstPtr QTimeZone where
  toQTimeZoneConst (QTimeZone ptr') = QTimeZoneConst $ (HoppyF.castPtr :: HoppyF.Ptr QTimeZone -> HoppyF.Ptr QTimeZoneConst) ptr'
  toQTimeZoneConst (QTimeZoneGc fptr' ptr') = QTimeZoneConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QTimeZone -> HoppyF.Ptr QTimeZoneConst) ptr'

instance QTimeZonePtr QTimeZone where
  toQTimeZone = HoppyP.id

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

newFull1 :: (M12.QByteArrayValue arg'1, M142.QStringValue arg'3, M142.QStringValue arg'4) => (arg'1) -> (HoppyP.Int) -> (arg'3) -> (arg'4) -> (HoppyP.IO QTimeZone)
newFull1 arg'1 arg'2 arg'3 arg'4 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap QTimeZone
  (newFull1' arg'1' arg'2' arg'3' arg'4')

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

newWithByteArray :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QTimeZone)
newWithByteArray arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QTimeZone
  (newWithByteArray' arg'1')

newCopy :: (QTimeZoneValue arg'1) => (arg'1) -> (HoppyP.IO QTimeZone)
newCopy arg'1 =
  withQTimeZonePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QTimeZone
  (newCopy' arg'1')

class QTimeZoneSuper a where
  downToQTimeZone :: a -> QTimeZone


class QTimeZoneSuperConst a where
  downToQTimeZoneConst :: a -> QTimeZoneConst


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

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

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

instance HoppyFHR.Decodable QTimeZone (QTimeZone) where
  decode = HoppyFHR.decode . toQTimeZoneConst

instance HoppyFHR.Decodable QTimeZoneConst (QTimeZone) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QTimeZoneNameType =
  DefaultName
  | LongName
  | ShortName
  | OffsetName
  | UnknownQTimeZoneNameType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QTimeZoneNameType where
  fromCppEnum DefaultName = 0
  fromCppEnum LongName = 1
  fromCppEnum ShortName = 2
  fromCppEnum OffsetName = 3
  fromCppEnum (UnknownQTimeZoneNameType n) = n
  
  toCppEnum (0) = DefaultName
  toCppEnum (1) = LongName
  toCppEnum (2) = ShortName
  toCppEnum (3) = OffsetName
  toCppEnum n = UnknownQTimeZoneNameType n

instance HoppyP.Eq QTimeZoneNameType where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QTimeZoneNameType where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

data QTimeZoneTimeType =
  StandardTime
  | DaylightTime
  | GenericTime
  | UnknownQTimeZoneTimeType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QTimeZoneTimeType where
  fromCppEnum StandardTime = 0
  fromCppEnum DaylightTime = 1
  fromCppEnum GenericTime = 2
  fromCppEnum (UnknownQTimeZoneTimeType n) = n
  
  toCppEnum (0) = StandardTime
  toCppEnum (1) = DaylightTime
  toCppEnum (2) = GenericTime
  toCppEnum n = UnknownQTimeZoneTimeType n

instance HoppyP.Eq QTimeZoneTimeType where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QTimeZoneTimeType where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)