{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.Date
(
Date(..) ,
newZeroDate ,
#if defined(ENABLE_OVERLOADING)
ResolveDateMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DateCopyMethodInfo ,
#endif
dateCopy ,
#if defined(ENABLE_OVERLOADING)
DateFreeMethodInfo ,
#endif
dateFree ,
#if defined(ENABLE_OVERLOADING)
DateGetDayMethodInfo ,
#endif
dateGetDay ,
#if defined(ENABLE_OVERLOADING)
DateGetHourMethodInfo ,
#endif
dateGetHour ,
#if defined(ENABLE_OVERLOADING)
DateGetMinuteMethodInfo ,
#endif
dateGetMinute ,
#if defined(ENABLE_OVERLOADING)
DateGetMonthMethodInfo ,
#endif
dateGetMonth ,
#if defined(ENABLE_OVERLOADING)
DateGetOffsetMethodInfo ,
#endif
dateGetOffset ,
#if defined(ENABLE_OVERLOADING)
DateGetSecondMethodInfo ,
#endif
dateGetSecond ,
#if defined(ENABLE_OVERLOADING)
DateGetUtcMethodInfo ,
#endif
dateGetUtc ,
#if defined(ENABLE_OVERLOADING)
DateGetYearMethodInfo ,
#endif
dateGetYear ,
#if defined(ENABLE_OVERLOADING)
DateIsPastMethodInfo ,
#endif
dateIsPast ,
dateNew ,
dateNewFromNow ,
dateNewFromString ,
dateNewFromTimeT ,
#if defined(ENABLE_OVERLOADING)
DateToStringMethodInfo ,
#endif
dateToString ,
#if defined(ENABLE_OVERLOADING)
DateToTimeTMethodInfo ,
#endif
dateToTimeT ,
#if defined(ENABLE_OVERLOADING)
DateToTimevalMethodInfo ,
#endif
dateToTimeval ,
#if defined(ENABLE_OVERLOADING)
date_day ,
#endif
getDateDay ,
setDateDay ,
#if defined(ENABLE_OVERLOADING)
date_hour ,
#endif
getDateHour ,
setDateHour ,
#if defined(ENABLE_OVERLOADING)
date_minute ,
#endif
getDateMinute ,
setDateMinute ,
#if defined(ENABLE_OVERLOADING)
date_month ,
#endif
getDateMonth ,
setDateMonth ,
#if defined(ENABLE_OVERLOADING)
date_offset ,
#endif
getDateOffset ,
setDateOffset ,
#if defined(ENABLE_OVERLOADING)
date_second ,
#endif
getDateSecond ,
setDateSecond ,
#if defined(ENABLE_OVERLOADING)
date_utc ,
#endif
getDateUtc ,
setDateUtc ,
#if defined(ENABLE_OVERLOADING)
date_year ,
#endif
getDateYear ,
setDateYear ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GLib.Structs.TimeVal as GLib.TimeVal
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
newtype Date = Date (SP.ManagedPtr Date)
deriving (Date -> Date -> Bool
(Date -> Date -> Bool) -> (Date -> Date -> Bool) -> Eq Date
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Date -> Date -> Bool
$c/= :: Date -> Date -> Bool
== :: Date -> Date -> Bool
$c== :: Date -> Date -> Bool
Eq)
instance SP.ManagedPtrNewtype Date where
toManagedPtr :: Date -> ManagedPtr Date
toManagedPtr (Date ManagedPtr Date
p) = ManagedPtr Date
p
foreign import ccall "soup_date_get_type" c_soup_date_get_type ::
IO GType
type instance O.ParentTypes Date = '[]
instance O.HasParentTypes Date
instance B.Types.TypedObject Date where
glibType :: IO GType
glibType = IO GType
c_soup_date_get_type
instance B.Types.GBoxed Date
instance B.GValue.IsGValue Date where
toGValue :: Date -> IO GValue
toGValue Date
o = do
GType
gtype <- IO GType
c_soup_date_get_type
Date -> (Ptr Date -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Date
o (GType -> (GValue -> Ptr Date -> IO ()) -> Ptr Date -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Date -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Date
fromGValue GValue
gv = do
Ptr Date
ptr <- GValue -> IO (Ptr Date)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Date)
(ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Date -> Date
Date Ptr Date
ptr
newZeroDate :: MonadIO m => m Date
newZeroDate :: m Date
newZeroDate = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Date)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
32 IO (Ptr Date) -> (Ptr Date -> IO Date) -> IO Date
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date
instance tag ~ 'AttrSet => Constructible Date tag where
new :: (ManagedPtr Date -> Date) -> [AttrOp Date tag] -> m Date
new ManagedPtr Date -> Date
_ [AttrOp Date tag]
attrs = do
Date
o <- m Date
forall (m :: * -> *). MonadIO m => m Date
newZeroDate
Date -> [AttrOp Date 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Date
o [AttrOp Date tag]
[AttrOp Date 'AttrSet]
attrs
Date -> m Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
o
getDateYear :: MonadIO m => Date -> m Int32
getDateYear :: Date -> m Int32
getDateYear Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateYear :: MonadIO m => Date -> Int32 -> m ()
setDateYear :: Date -> Int32 -> m ()
setDateYear Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateYearFieldInfo
instance AttrInfo DateYearFieldInfo where
type AttrBaseTypeConstraint DateYearFieldInfo = (~) Date
type AttrAllowedOps DateYearFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateYearFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateYearFieldInfo = (~)Int32
type AttrTransferType DateYearFieldInfo = Int32
type AttrGetType DateYearFieldInfo = Int32
type AttrLabel DateYearFieldInfo = "year"
type AttrOrigin DateYearFieldInfo = Date
attrGet = getDateYear
attrSet = setDateYear
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_year :: AttrLabelProxy "year"
date_year = AttrLabelProxy
#endif
getDateMonth :: MonadIO m => Date -> m Int32
getDateMonth :: Date -> m Int32
getDateMonth Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateMonth :: MonadIO m => Date -> Int32 -> m ()
setDateMonth :: Date -> Int32 -> m ()
setDateMonth Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateMonthFieldInfo
instance AttrInfo DateMonthFieldInfo where
type AttrBaseTypeConstraint DateMonthFieldInfo = (~) Date
type AttrAllowedOps DateMonthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateMonthFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateMonthFieldInfo = (~)Int32
type AttrTransferType DateMonthFieldInfo = Int32
type AttrGetType DateMonthFieldInfo = Int32
type AttrLabel DateMonthFieldInfo = "month"
type AttrOrigin DateMonthFieldInfo = Date
attrGet = getDateMonth
attrSet = setDateMonth
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_month :: AttrLabelProxy "month"
date_month = AttrLabelProxy
#endif
getDateDay :: MonadIO m => Date -> m Int32
getDateDay :: Date -> m Int32
getDateDay Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateDay :: MonadIO m => Date -> Int32 -> m ()
setDateDay :: Date -> Int32 -> m ()
setDateDay Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateDayFieldInfo
instance AttrInfo DateDayFieldInfo where
type AttrBaseTypeConstraint DateDayFieldInfo = (~) Date
type AttrAllowedOps DateDayFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateDayFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateDayFieldInfo = (~)Int32
type AttrTransferType DateDayFieldInfo = Int32
type AttrGetType DateDayFieldInfo = Int32
type AttrLabel DateDayFieldInfo = "day"
type AttrOrigin DateDayFieldInfo = Date
attrGet = getDateDay
attrSet = setDateDay
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_day :: AttrLabelProxy "day"
date_day = AttrLabelProxy
#endif
getDateHour :: MonadIO m => Date -> m Int32
getDateHour :: Date -> m Int32
getDateHour Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateHour :: MonadIO m => Date -> Int32 -> m ()
setDateHour :: Date -> Int32 -> m ()
setDateHour Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateHourFieldInfo
instance AttrInfo DateHourFieldInfo where
type AttrBaseTypeConstraint DateHourFieldInfo = (~) Date
type AttrAllowedOps DateHourFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateHourFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateHourFieldInfo = (~)Int32
type AttrTransferType DateHourFieldInfo = Int32
type AttrGetType DateHourFieldInfo = Int32
type AttrLabel DateHourFieldInfo = "hour"
type AttrOrigin DateHourFieldInfo = Date
attrGet = getDateHour
attrSet = setDateHour
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_hour :: AttrLabelProxy "hour"
date_hour = AttrLabelProxy
#endif
getDateMinute :: MonadIO m => Date -> m Int32
getDateMinute :: Date -> m Int32
getDateMinute Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateMinute :: MonadIO m => Date -> Int32 -> m ()
setDateMinute :: Date -> Int32 -> m ()
setDateMinute Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateMinuteFieldInfo
instance AttrInfo DateMinuteFieldInfo where
type AttrBaseTypeConstraint DateMinuteFieldInfo = (~) Date
type AttrAllowedOps DateMinuteFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateMinuteFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateMinuteFieldInfo = (~)Int32
type AttrTransferType DateMinuteFieldInfo = Int32
type AttrGetType DateMinuteFieldInfo = Int32
type AttrLabel DateMinuteFieldInfo = "minute"
type AttrOrigin DateMinuteFieldInfo = Date
attrGet = getDateMinute
attrSet = setDateMinute
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_minute :: AttrLabelProxy "minute"
date_minute = AttrLabelProxy
#endif
getDateSecond :: MonadIO m => Date -> m Int32
getDateSecond :: Date -> m Int32
getDateSecond Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateSecond :: MonadIO m => Date -> Int32 -> m ()
setDateSecond :: Date -> Int32 -> m ()
setDateSecond Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateSecondFieldInfo
instance AttrInfo DateSecondFieldInfo where
type AttrBaseTypeConstraint DateSecondFieldInfo = (~) Date
type AttrAllowedOps DateSecondFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateSecondFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateSecondFieldInfo = (~)Int32
type AttrTransferType DateSecondFieldInfo = Int32
type AttrGetType DateSecondFieldInfo = Int32
type AttrLabel DateSecondFieldInfo = "second"
type AttrOrigin DateSecondFieldInfo = Date
attrGet = getDateSecond
attrSet = setDateSecond
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_second :: AttrLabelProxy "second"
date_second = AttrLabelProxy
#endif
getDateUtc :: MonadIO m => Date -> m Bool
getDateUtc :: Date -> m Bool
getDateUtc Date
s = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Bool) -> IO Bool)
-> (Ptr Date -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CInt
let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setDateUtc :: MonadIO m => Date -> Bool -> m ()
setDateUtc :: Date -> Bool -> m ()
setDateUtc Date
s Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data DateUtcFieldInfo
instance AttrInfo DateUtcFieldInfo where
type AttrBaseTypeConstraint DateUtcFieldInfo = (~) Date
type AttrAllowedOps DateUtcFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateUtcFieldInfo = (~) Bool
type AttrTransferTypeConstraint DateUtcFieldInfo = (~)Bool
type AttrTransferType DateUtcFieldInfo = Bool
type AttrGetType DateUtcFieldInfo = Bool
type AttrLabel DateUtcFieldInfo = "utc"
type AttrOrigin DateUtcFieldInfo = Date
attrGet = getDateUtc
attrSet = setDateUtc
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_utc :: AttrLabelProxy "utc"
date_utc = AttrLabelProxy
#endif
getDateOffset :: MonadIO m => Date -> m Int32
getDateOffset :: Date -> m Int32
getDateOffset Date
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO Int32) -> IO Int32)
-> (Ptr Date -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateOffset :: MonadIO m => Date -> Int32 -> m ()
setDateOffset :: Date -> Int32 -> m ()
setDateOffset Date
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Date
s ((Ptr Date -> IO ()) -> IO ()) -> (Ptr Date -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Date
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Date
ptr Ptr Date -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DateOffsetFieldInfo
instance AttrInfo DateOffsetFieldInfo where
type AttrBaseTypeConstraint DateOffsetFieldInfo = (~) Date
type AttrAllowedOps DateOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DateOffsetFieldInfo = (~) Int32
type AttrTransferTypeConstraint DateOffsetFieldInfo = (~)Int32
type AttrTransferType DateOffsetFieldInfo = Int32
type AttrGetType DateOffsetFieldInfo = Int32
type AttrLabel DateOffsetFieldInfo = "offset"
type AttrOrigin DateOffsetFieldInfo = Date
attrGet = getDateOffset
attrSet = setDateOffset
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
date_offset :: AttrLabelProxy "offset"
date_offset = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Date
type instance O.AttributeList Date = DateAttributeList
type DateAttributeList = ('[ '("year", DateYearFieldInfo), '("month", DateMonthFieldInfo), '("day", DateDayFieldInfo), '("hour", DateHourFieldInfo), '("minute", DateMinuteFieldInfo), '("second", DateSecondFieldInfo), '("utc", DateUtcFieldInfo), '("offset", DateOffsetFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_date_new" soup_date_new ::
Int32 ->
Int32 ->
Int32 ->
Int32 ->
Int32 ->
Int32 ->
IO (Ptr Date)
dateNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> m Date
dateNew :: Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> m Date
dateNew Int32
year Int32
month Int32
day Int32
hour Int32
minute Int32
second = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
result <- Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> IO (Ptr Date)
soup_date_new Int32
year Int32
month Int32
day Int32
hour Int32
minute Int32
second
Text -> Ptr Date -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateNew" Ptr Date
result
Date
result' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date) Ptr Date
result
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_date_new_from_now" soup_date_new_from_now ::
Int32 ->
IO (Ptr Date)
dateNewFromNow ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> m Date
dateNewFromNow :: Int32 -> m Date
dateNewFromNow Int32
offsetSeconds = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
result <- Int32 -> IO (Ptr Date)
soup_date_new_from_now Int32
offsetSeconds
Text -> Ptr Date -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateNewFromNow" Ptr Date
result
Date
result' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date) Ptr Date
result
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_date_new_from_string" soup_date_new_from_string ::
CString ->
IO (Ptr Date)
dateNewFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Date)
dateNewFromString :: Text -> m (Maybe Date)
dateNewFromString Text
dateString = IO (Maybe Date) -> m (Maybe Date)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Date) -> m (Maybe Date))
-> IO (Maybe Date) -> m (Maybe Date)
forall a b. (a -> b) -> a -> b
$ do
CString
dateString' <- Text -> IO CString
textToCString Text
dateString
Ptr Date
result <- CString -> IO (Ptr Date)
soup_date_new_from_string CString
dateString'
Maybe Date
maybeResult <- Ptr Date -> (Ptr Date -> IO Date) -> IO (Maybe Date)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Date
result ((Ptr Date -> IO Date) -> IO (Maybe Date))
-> (Ptr Date -> IO Date) -> IO (Maybe Date)
forall a b. (a -> b) -> a -> b
$ \Ptr Date
result' -> do
Date
result'' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date) Ptr Date
result'
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dateString'
Maybe Date -> IO (Maybe Date)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Date
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_date_new_from_time_t" soup_date_new_from_time_t ::
CLong ->
IO (Ptr Date)
dateNewFromTimeT ::
(B.CallStack.HasCallStack, MonadIO m) =>
CLong
-> m Date
dateNewFromTimeT :: CLong -> m Date
dateNewFromTimeT CLong
when_ = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
result <- CLong -> IO (Ptr Date)
soup_date_new_from_time_t CLong
when_
Text -> Ptr Date -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateNewFromTimeT" Ptr Date
result
Date
result' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date) Ptr Date
result
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_date_copy" soup_date_copy ::
Ptr Date ->
IO (Ptr Date)
dateCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Date
dateCopy :: Date -> m Date
dateCopy Date
date = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Ptr Date
result <- Ptr Date -> IO (Ptr Date)
soup_date_copy Ptr Date
date'
Text -> Ptr Date -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateCopy" Ptr Date
result
Date
result' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Date) Ptr Date
result
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
#if defined(ENABLE_OVERLOADING)
data DateCopyMethodInfo
instance (signature ~ (m Date), MonadIO m) => O.MethodInfo DateCopyMethodInfo Date signature where
overloadedMethod = dateCopy
#endif
foreign import ccall "soup_date_free" soup_date_free ::
Ptr Date ->
IO ()
dateFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m ()
dateFree :: Date -> m ()
dateFree Date
date = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Ptr Date -> IO ()
soup_date_free Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DateFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DateFreeMethodInfo Date signature where
overloadedMethod = dateFree
#endif
foreign import ccall "soup_date_get_day" soup_date_get_day ::
Ptr Date ->
IO Int32
dateGetDay ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetDay :: Date -> m Int32
dateGetDay Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_day Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetDayMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetDayMethodInfo Date signature where
overloadedMethod = dateGetDay
#endif
foreign import ccall "soup_date_get_hour" soup_date_get_hour ::
Ptr Date ->
IO Int32
dateGetHour ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetHour :: Date -> m Int32
dateGetHour Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_hour Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetHourMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetHourMethodInfo Date signature where
overloadedMethod = dateGetHour
#endif
foreign import ccall "soup_date_get_minute" soup_date_get_minute ::
Ptr Date ->
IO Int32
dateGetMinute ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetMinute :: Date -> m Int32
dateGetMinute Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_minute Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetMinuteMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetMinuteMethodInfo Date signature where
overloadedMethod = dateGetMinute
#endif
foreign import ccall "soup_date_get_month" soup_date_get_month ::
Ptr Date ->
IO Int32
dateGetMonth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetMonth :: Date -> m Int32
dateGetMonth Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_month Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetMonthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetMonthMethodInfo Date signature where
overloadedMethod = dateGetMonth
#endif
foreign import ccall "soup_date_get_offset" soup_date_get_offset ::
Ptr Date ->
IO Int32
dateGetOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetOffset :: Date -> m Int32
dateGetOffset Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_offset Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetOffsetMethodInfo Date signature where
overloadedMethod = dateGetOffset
#endif
foreign import ccall "soup_date_get_second" soup_date_get_second ::
Ptr Date ->
IO Int32
dateGetSecond ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetSecond :: Date -> m Int32
dateGetSecond Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_second Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetSecondMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetSecondMethodInfo Date signature where
overloadedMethod = dateGetSecond
#endif
foreign import ccall "soup_date_get_utc" soup_date_get_utc ::
Ptr Date ->
IO Int32
dateGetUtc ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetUtc :: Date -> m Int32
dateGetUtc Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_utc Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetUtcMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetUtcMethodInfo Date signature where
overloadedMethod = dateGetUtc
#endif
foreign import ccall "soup_date_get_year" soup_date_get_year ::
Ptr Date ->
IO Int32
dateGetYear ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Int32
dateGetYear :: Date -> m Int32
dateGetYear Date
date = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Int32
result <- Ptr Date -> IO Int32
soup_date_get_year Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetYearMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetYearMethodInfo Date signature where
overloadedMethod = dateGetYear
#endif
foreign import ccall "soup_date_is_past" soup_date_is_past ::
Ptr Date ->
IO CInt
dateIsPast ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m Bool
dateIsPast :: Date -> m Bool
dateIsPast Date
date = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
CInt
result <- Ptr Date -> IO CInt
soup_date_is_past Ptr Date
date'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DateIsPastMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo DateIsPastMethodInfo Date signature where
overloadedMethod = dateIsPast
#endif
foreign import ccall "soup_date_to_string" soup_date_to_string ::
Ptr Date ->
CUInt ->
IO CString
dateToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> Soup.Enums.DateFormat
-> m T.Text
dateToString :: Date -> DateFormat -> m Text
dateToString Date
date DateFormat
format = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (DateFormat -> Int) -> DateFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DateFormat -> Int
forall a. Enum a => a -> Int
fromEnum) DateFormat
format
CString
result <- Ptr Date -> CUInt -> IO CString
soup_date_to_string Ptr Date
date' CUInt
format'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DateToStringMethodInfo
instance (signature ~ (Soup.Enums.DateFormat -> m T.Text), MonadIO m) => O.MethodInfo DateToStringMethodInfo Date signature where
overloadedMethod = dateToString
#endif
foreign import ccall "soup_date_to_time_t" soup_date_to_time_t ::
Ptr Date ->
IO CLong
dateToTimeT ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m CLong
dateToTimeT :: Date -> m CLong
dateToTimeT Date
date = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
CLong
result <- Ptr Date -> IO CLong
soup_date_to_time_t Ptr Date
date'
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result
#if defined(ENABLE_OVERLOADING)
data DateToTimeTMethodInfo
instance (signature ~ (m CLong), MonadIO m) => O.MethodInfo DateToTimeTMethodInfo Date signature where
overloadedMethod = dateToTimeT
#endif
foreign import ccall "soup_date_to_timeval" soup_date_to_timeval ::
Ptr Date ->
Ptr GLib.TimeVal.TimeVal ->
IO ()
{-# DEPRECATED dateToTimeval ["Do not use t'GI.GLib.Structs.TimeVal.TimeVal', as it\\'s not Y2038-safe."] #-}
dateToTimeval ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m (GLib.TimeVal.TimeVal)
dateToTimeval :: Date -> m TimeVal
dateToTimeval Date
date = IO TimeVal -> m TimeVal
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TimeVal -> m TimeVal) -> IO TimeVal -> m TimeVal
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Ptr TimeVal
time <- Int -> IO (Ptr TimeVal)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr GLib.TimeVal.TimeVal)
Ptr Date -> Ptr TimeVal -> IO ()
soup_date_to_timeval Ptr Date
date' Ptr TimeVal
time
TimeVal
time' <- ((ManagedPtr TimeVal -> TimeVal) -> Ptr TimeVal -> IO TimeVal
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TimeVal -> TimeVal
GLib.TimeVal.TimeVal) Ptr TimeVal
time
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
TimeVal -> IO TimeVal
forall (m :: * -> *) a. Monad m => a -> m a
return TimeVal
time'
#if defined(ENABLE_OVERLOADING)
data DateToTimevalMethodInfo
instance (signature ~ (m (GLib.TimeVal.TimeVal)), MonadIO m) => O.MethodInfo DateToTimevalMethodInfo Date signature where
overloadedMethod = dateToTimeval
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDateMethod (t :: Symbol) (o :: *) :: * where
ResolveDateMethod "copy" o = DateCopyMethodInfo
ResolveDateMethod "free" o = DateFreeMethodInfo
ResolveDateMethod "isPast" o = DateIsPastMethodInfo
ResolveDateMethod "toString" o = DateToStringMethodInfo
ResolveDateMethod "toTimeT" o = DateToTimeTMethodInfo
ResolveDateMethod "toTimeval" o = DateToTimevalMethodInfo
ResolveDateMethod "getDay" o = DateGetDayMethodInfo
ResolveDateMethod "getHour" o = DateGetHourMethodInfo
ResolveDateMethod "getMinute" o = DateGetMinuteMethodInfo
ResolveDateMethod "getMonth" o = DateGetMonthMethodInfo
ResolveDateMethod "getOffset" o = DateGetOffsetMethodInfo
ResolveDateMethod "getSecond" o = DateGetSecondMethodInfo
ResolveDateMethod "getUtc" o = DateGetUtcMethodInfo
ResolveDateMethod "getYear" o = DateGetYearMethodInfo
ResolveDateMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDateMethod t Date, O.MethodInfo info Date p) => OL.IsLabel t (Date -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif