{-# 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
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 GHC.Records as R
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
$c== :: Date -> Date -> Bool
== :: Date -> Date -> Bool
$c/= :: Date -> Date -> Bool
/= :: 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 (Maybe Date) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_date_get_type
gvalueSet_ :: Ptr GValue -> Maybe Date -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Date
P.Nothing = Ptr GValue -> Ptr Date -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Date
forall a. Ptr a
FP.nullPtr :: FP.Ptr Date)
gvalueSet_ Ptr GValue
gv (P.Just Date
obj) = Date -> (Ptr Date -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Date
obj (Ptr GValue -> Ptr Date -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Date)
gvalueGet_ Ptr GValue
gv = do
Ptr Date
ptr <- Ptr GValue -> IO (Ptr Date)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Date)
if Ptr Date
ptr Ptr Date -> Ptr Date -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Date
forall a. Ptr a
FP.nullPtr
then Date -> Maybe Date
forall a. a -> Maybe a
P.Just (Date -> Maybe Date) -> IO Date -> IO (Maybe Date)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
else Maybe Date -> IO (Maybe Date)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Date
forall a. Maybe a
P.Nothing
newZeroDate :: MonadIO m => m Date
newZeroDate :: forall (m :: * -> *). MonadIO m => m Date
newZeroDate = IO Date -> m Date
forall a. IO a -> m a
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 a b. IO a -> (a -> IO b) -> IO b
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 :: forall (m :: * -> *).
MonadIO m =>
(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 a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Date
o
getDateYear :: MonadIO m => Date -> m Int32
getDateYear :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateYear Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateYear :: MonadIO m => Date -> Int32 -> m ()
setDateYear :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateYear Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.year"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:year"
})
date_year :: AttrLabelProxy "year"
date_year = AttrLabelProxy
#endif
getDateMonth :: MonadIO m => Date -> m Int32
getDateMonth :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateMonth Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateMonth :: MonadIO m => Date -> Int32 -> m ()
setDateMonth :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateMonth Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.month"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:month"
})
date_month :: AttrLabelProxy "month"
date_month = AttrLabelProxy
#endif
getDateDay :: MonadIO m => Date -> m Int32
getDateDay :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateDay Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateDay :: MonadIO m => Date -> Int32 -> m ()
setDateDay :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateDay Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.day"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:day"
})
date_day :: AttrLabelProxy "day"
date_day = AttrLabelProxy
#endif
getDateHour :: MonadIO m => Date -> m Int32
getDateHour :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateHour Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateHour :: MonadIO m => Date -> Int32 -> m ()
setDateHour :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateHour Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.hour"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:hour"
})
date_hour :: AttrLabelProxy "hour"
date_hour = AttrLabelProxy
#endif
getDateMinute :: MonadIO m => Date -> m Int32
getDateMinute :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateMinute Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateMinute :: MonadIO m => Date -> Int32 -> m ()
setDateMinute :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateMinute Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.minute"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:minute"
})
date_minute :: AttrLabelProxy "minute"
date_minute = AttrLabelProxy
#endif
getDateSecond :: MonadIO m => Date -> m Int32
getDateSecond :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateSecond Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateSecond :: MonadIO m => Date -> Int32 -> m ()
setDateSecond :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateSecond Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.second"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:second"
})
date_second :: AttrLabelProxy "second"
date_second = AttrLabelProxy
#endif
getDateUtc :: MonadIO m => Date -> m Bool
getDateUtc :: forall (m :: * -> *). MonadIO m => Date -> m Bool
getDateUtc Date
s = IO Bool -> m Bool
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setDateUtc :: MonadIO m => Date -> Bool -> m ()
setDateUtc :: forall (m :: * -> *). MonadIO m => Date -> Bool -> m ()
setDateUtc Date
s Bool
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.utc"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:utc"
})
date_utc :: AttrLabelProxy "utc"
date_utc = AttrLabelProxy
#endif
getDateOffset :: MonadIO m => Date -> m Int32
getDateOffset :: forall (m :: * -> *). MonadIO m => Date -> m Int32
getDateOffset Date
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDateOffset :: MonadIO m => Date -> Int32 -> m ()
setDateOffset :: forall (m :: * -> *). MonadIO m => Date -> Int32 -> m ()
setDateOffset Date
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.offset"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#g:attr:offset"
})
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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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 a. IO a -> m a
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 a. a -> IO a
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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Int32 -> m Date
dateNewFromNow Int32
offsetSeconds = IO Date -> m Date
forall a. IO a -> m a
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 a. a -> IO a
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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Date)
dateNewFromString Text
dateString = IO (Maybe Date) -> m (Maybe Date)
forall a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => CLong -> m Date
dateNewFromTimeT CLong
when_ = IO Date -> m Date
forall a. IO a -> m a
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 a. a -> IO a
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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Date
dateCopy Date
date = IO Date -> m Date
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
#if defined(ENABLE_OVERLOADING)
data DateCopyMethodInfo
instance (signature ~ (m Date), MonadIO m) => O.OverloadedMethod DateCopyMethodInfo Date signature where
overloadedMethod = dateCopy
instance O.OverloadedMethodInfo DateCopyMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v:dateCopy"
})
#endif
foreign import ccall "soup_date_free" soup_date_free ::
Ptr Date ->
IO ()
dateFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Date
-> m ()
dateFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m ()
dateFree Date
date = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DateFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DateFreeMethodInfo Date signature where
overloadedMethod = dateFree
instance O.OverloadedMethodInfo DateFreeMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetDay Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetDayMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetDayMethodInfo Date signature where
overloadedMethod = dateGetDay
instance O.OverloadedMethodInfo DateGetDayMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetDay",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetHour Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetHourMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetHourMethodInfo Date signature where
overloadedMethod = dateGetHour
instance O.OverloadedMethodInfo DateGetHourMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetHour",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetMinute Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetMinuteMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetMinuteMethodInfo Date signature where
overloadedMethod = dateGetMinute
instance O.OverloadedMethodInfo DateGetMinuteMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetMinute",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetMonth Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetMonthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetMonthMethodInfo Date signature where
overloadedMethod = dateGetMonth
instance O.OverloadedMethodInfo DateGetMonthMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetMonth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetOffset Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetOffsetMethodInfo Date signature where
overloadedMethod = dateGetOffset
instance O.OverloadedMethodInfo DateGetOffsetMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetSecond Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetSecondMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetSecondMethodInfo Date signature where
overloadedMethod = dateGetSecond
instance O.OverloadedMethodInfo DateGetSecondMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetSecond",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetUtc Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetUtcMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetUtcMethodInfo Date signature where
overloadedMethod = dateGetUtc
instance O.OverloadedMethodInfo DateGetUtcMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetUtc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Int32
dateGetYear Date
date = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data DateGetYearMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod DateGetYearMethodInfo Date signature where
overloadedMethod = dateGetYear
instance O.OverloadedMethodInfo DateGetYearMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateGetYear",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m Bool
dateIsPast Date
date = IO Bool -> m Bool
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DateIsPastMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod DateIsPastMethodInfo Date signature where
overloadedMethod = dateIsPast
instance O.OverloadedMethodInfo DateIsPastMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateIsPast",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Date -> DateFormat -> m Text
dateToString Date
date DateFormat
format = IO Text -> m Text
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod DateToStringMethodInfo Date signature where
overloadedMethod = dateToString
instance O.OverloadedMethodInfo DateToStringMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Date -> m CLong
dateToTimeT Date
date = IO CLong -> m CLong
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result
#if defined(ENABLE_OVERLOADING)
data DateToTimeTMethodInfo
instance (signature ~ (m CLong), MonadIO m) => O.OverloadedMethod DateToTimeTMethodInfo Date signature where
overloadedMethod = dateToTimeT
instance O.OverloadedMethodInfo DateToTimeTMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateToTimeT",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Date -> m TimeVal
dateToTimeval Date
date = IO TimeVal -> m TimeVal
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod DateToTimevalMethodInfo Date signature where
overloadedMethod = dateToTimeval
instance O.OverloadedMethodInfo DateToTimevalMethodInfo Date where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.Date.dateToTimeval",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-Date.html#v: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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDateMethod t Date, O.OverloadedMethod info Date p, R.HasField t Date p) => R.HasField t Date p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDateMethod t Date, O.OverloadedMethodInfo info Date) => OL.IsLabel t (O.MethodProxy info Date) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif