{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A date and time. The date is assumed to be in the (proleptic)
Gregorian calendar. The time is in UTC if /@utc@/ is 'True'. Otherwise,
the time is a local time, and /@offset@/ gives the offset from UTC in
minutes (such that adding /@offset@/ to the time would give the
correct UTC time). If /@utc@/ is 'False' and /@offset@/ is 0, then the
@/SoupDate/@ represents a \"floating\" time with no associated timezone
information.
-}

module GI.Soup.Structs.Date
    ( 

-- * Exported types
    Date(..)                                ,
    newZeroDate                             ,
    noDate                                  ,


 -- * Methods
-- ** copy #method:copy#
    DateCopyMethodInfo                      ,
    dateCopy                                ,


-- ** free #method:free#
    DateFreeMethodInfo                      ,
    dateFree                                ,


-- ** getDay #method:getDay#
    DateGetDayMethodInfo                    ,
    dateGetDay                              ,


-- ** getHour #method:getHour#
    DateGetHourMethodInfo                   ,
    dateGetHour                             ,


-- ** getMinute #method:getMinute#
    DateGetMinuteMethodInfo                 ,
    dateGetMinute                           ,


-- ** getMonth #method:getMonth#
    DateGetMonthMethodInfo                  ,
    dateGetMonth                            ,


-- ** getOffset #method:getOffset#
    DateGetOffsetMethodInfo                 ,
    dateGetOffset                           ,


-- ** getSecond #method:getSecond#
    DateGetSecondMethodInfo                 ,
    dateGetSecond                           ,


-- ** getUtc #method:getUtc#
    DateGetUtcMethodInfo                    ,
    dateGetUtc                              ,


-- ** getYear #method:getYear#
    DateGetYearMethodInfo                   ,
    dateGetYear                             ,


-- ** isPast #method:isPast#
    DateIsPastMethodInfo                    ,
    dateIsPast                              ,


-- ** new #method:new#
    dateNew                                 ,


-- ** newFromNow #method:newFromNow#
    dateNewFromNow                          ,


-- ** newFromString #method:newFromString#
    dateNewFromString                       ,


-- ** newFromTimeT #method:newFromTimeT#
    dateNewFromTimeT                        ,


-- ** toString #method:toString#
    DateToStringMethodInfo                  ,
    dateToString                            ,


-- ** toTimeT #method:toTimeT#
    DateToTimeTMethodInfo                   ,
    dateToTimeT                             ,


-- ** toTimeval #method:toTimeval#
    DateToTimevalMethodInfo                 ,
    dateToTimeval                           ,




 -- * Properties
-- ** day #attr:day#
    date_day                                ,
    getDateDay                              ,
    setDateDay                              ,


-- ** hour #attr:hour#
    date_hour                               ,
    getDateHour                             ,
    setDateHour                             ,


-- ** minute #attr:minute#
    date_minute                             ,
    getDateMinute                           ,
    setDateMinute                           ,


-- ** month #attr:month#
    date_month                              ,
    getDateMonth                            ,
    setDateMonth                            ,


-- ** offset #attr:offset#
    date_offset                             ,
    getDateOffset                           ,
    setDateOffset                           ,


-- ** second #attr:second#
    date_second                             ,
    getDateSecond                           ,
    setDateSecond                           ,


-- ** utc #attr:utc#
    date_utc                                ,
    getDateUtc                              ,
    setDateUtc                              ,


-- ** year #attr:year#
    date_year                               ,
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GLib.Structs.TimeVal as GLib.TimeVal
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums

newtype Date = Date (ManagedPtr Date)
foreign import ccall "soup_date_get_type" c_soup_date_get_type :: 
    IO GType

instance BoxedObject Date where
    boxedType _ = c_soup_date_get_type

-- | Construct a `Date` struct initialized to zero.
newZeroDate :: MonadIO m => m Date
newZeroDate = liftIO $ callocBoxedBytes 32 >>= wrapBoxed Date

instance tag ~ 'AttrSet => Constructible Date tag where
    new _ attrs = do
        o <- newZeroDate
        GI.Attributes.set o attrs
        return o


noDate :: Maybe Date
noDate = Nothing

getDateYear :: MonadIO m => Date -> m Int32
getDateYear s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

setDateYear :: MonadIO m => Date -> Int32 -> m ()
setDateYear s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

data DateYearFieldInfo
instance AttrInfo DateYearFieldInfo where
    type AttrAllowedOps DateYearFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateYearFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateYearFieldInfo = (~) Date
    type AttrGetType DateYearFieldInfo = Int32
    type AttrLabel DateYearFieldInfo = "year"
    type AttrOrigin DateYearFieldInfo = Date
    attrGet _ = getDateYear
    attrSet _ = setDateYear
    attrConstruct = undefined
    attrClear _ = undefined

date_year :: AttrLabelProxy "year"
date_year = AttrLabelProxy


getDateMonth :: MonadIO m => Date -> m Int32
getDateMonth s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Int32
    return val

setDateMonth :: MonadIO m => Date -> Int32 -> m ()
setDateMonth s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 4) (val :: Int32)

data DateMonthFieldInfo
instance AttrInfo DateMonthFieldInfo where
    type AttrAllowedOps DateMonthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateMonthFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateMonthFieldInfo = (~) Date
    type AttrGetType DateMonthFieldInfo = Int32
    type AttrLabel DateMonthFieldInfo = "month"
    type AttrOrigin DateMonthFieldInfo = Date
    attrGet _ = getDateMonth
    attrSet _ = setDateMonth
    attrConstruct = undefined
    attrClear _ = undefined

date_month :: AttrLabelProxy "month"
date_month = AttrLabelProxy


getDateDay :: MonadIO m => Date -> m Int32
getDateDay s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Int32
    return val

setDateDay :: MonadIO m => Date -> Int32 -> m ()
setDateDay s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Int32)

data DateDayFieldInfo
instance AttrInfo DateDayFieldInfo where
    type AttrAllowedOps DateDayFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateDayFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateDayFieldInfo = (~) Date
    type AttrGetType DateDayFieldInfo = Int32
    type AttrLabel DateDayFieldInfo = "day"
    type AttrOrigin DateDayFieldInfo = Date
    attrGet _ = getDateDay
    attrSet _ = setDateDay
    attrConstruct = undefined
    attrClear _ = undefined

date_day :: AttrLabelProxy "day"
date_day = AttrLabelProxy


getDateHour :: MonadIO m => Date -> m Int32
getDateHour s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Int32
    return val

setDateHour :: MonadIO m => Date -> Int32 -> m ()
setDateHour s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Int32)

data DateHourFieldInfo
instance AttrInfo DateHourFieldInfo where
    type AttrAllowedOps DateHourFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateHourFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateHourFieldInfo = (~) Date
    type AttrGetType DateHourFieldInfo = Int32
    type AttrLabel DateHourFieldInfo = "hour"
    type AttrOrigin DateHourFieldInfo = Date
    attrGet _ = getDateHour
    attrSet _ = setDateHour
    attrConstruct = undefined
    attrClear _ = undefined

date_hour :: AttrLabelProxy "hour"
date_hour = AttrLabelProxy


getDateMinute :: MonadIO m => Date -> m Int32
getDateMinute s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Int32
    return val

setDateMinute :: MonadIO m => Date -> Int32 -> m ()
setDateMinute s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Int32)

data DateMinuteFieldInfo
instance AttrInfo DateMinuteFieldInfo where
    type AttrAllowedOps DateMinuteFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateMinuteFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateMinuteFieldInfo = (~) Date
    type AttrGetType DateMinuteFieldInfo = Int32
    type AttrLabel DateMinuteFieldInfo = "minute"
    type AttrOrigin DateMinuteFieldInfo = Date
    attrGet _ = getDateMinute
    attrSet _ = setDateMinute
    attrConstruct = undefined
    attrClear _ = undefined

date_minute :: AttrLabelProxy "minute"
date_minute = AttrLabelProxy


getDateSecond :: MonadIO m => Date -> m Int32
getDateSecond s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Int32
    return val

setDateSecond :: MonadIO m => Date -> Int32 -> m ()
setDateSecond s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 20) (val :: Int32)

data DateSecondFieldInfo
instance AttrInfo DateSecondFieldInfo where
    type AttrAllowedOps DateSecondFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateSecondFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateSecondFieldInfo = (~) Date
    type AttrGetType DateSecondFieldInfo = Int32
    type AttrLabel DateSecondFieldInfo = "second"
    type AttrOrigin DateSecondFieldInfo = Date
    attrGet _ = getDateSecond
    attrSet _ = setDateSecond
    attrConstruct = undefined
    attrClear _ = undefined

date_second :: AttrLabelProxy "second"
date_second = AttrLabelProxy


getDateUtc :: MonadIO m => Date -> m Bool
getDateUtc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CInt
    let val' = (/= 0) val
    return val'

setDateUtc :: MonadIO m => Date -> Bool -> m ()
setDateUtc s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 24) (val' :: CInt)

data DateUtcFieldInfo
instance AttrInfo DateUtcFieldInfo where
    type AttrAllowedOps DateUtcFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateUtcFieldInfo = (~) Bool
    type AttrBaseTypeConstraint DateUtcFieldInfo = (~) Date
    type AttrGetType DateUtcFieldInfo = Bool
    type AttrLabel DateUtcFieldInfo = "utc"
    type AttrOrigin DateUtcFieldInfo = Date
    attrGet _ = getDateUtc
    attrSet _ = setDateUtc
    attrConstruct = undefined
    attrClear _ = undefined

date_utc :: AttrLabelProxy "utc"
date_utc = AttrLabelProxy


getDateOffset :: MonadIO m => Date -> m Int32
getDateOffset s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Int32
    return val

setDateOffset :: MonadIO m => Date -> Int32 -> m ()
setDateOffset s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 28) (val :: Int32)

data DateOffsetFieldInfo
instance AttrInfo DateOffsetFieldInfo where
    type AttrAllowedOps DateOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DateOffsetFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DateOffsetFieldInfo = (~) Date
    type AttrGetType DateOffsetFieldInfo = Int32
    type AttrLabel DateOffsetFieldInfo = "offset"
    type AttrOrigin DateOffsetFieldInfo = Date
    attrGet _ = getDateOffset
    attrSet _ = setDateOffset
    attrConstruct = undefined
    attrClear _ = undefined

date_offset :: AttrLabelProxy "offset"
date_offset = AttrLabelProxy



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, *)])

-- method Date::new
-- method type : Constructor
-- Args : [Arg {argCName = "year", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the year (1-9999)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the month (1-12)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the day of the month (1-31, as appropriate for @month)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hour", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hour (0-23)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minute", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minute (0-59)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "second", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the second (0-59, or up to 61 for leap seconds)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_new" soup_date_new :: 
    Int32 ->                                -- year : TBasicType TInt
    Int32 ->                                -- month : TBasicType TInt
    Int32 ->                                -- day : TBasicType TInt
    Int32 ->                                -- hour : TBasicType TInt
    Int32 ->                                -- minute : TBasicType TInt
    Int32 ->                                -- second : TBasicType TInt
    IO (Ptr Date)

{- |
Creates a 'GI.Soup.Structs.Date.Date' representing the indicated time, UTC.
-}
dateNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    {- ^ /@year@/: the year (1-9999) -}
    -> Int32
    {- ^ /@month@/: the month (1-12) -}
    -> Int32
    {- ^ /@day@/: the day of the month (1-31, as appropriate for /@month@/) -}
    -> Int32
    {- ^ /@hour@/: the hour (0-23) -}
    -> Int32
    {- ^ /@minute@/: the minute (0-59) -}
    -> Int32
    {- ^ /@second@/: the second (0-59, or up to 61 for leap seconds) -}
    -> m Date
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Date.Date' -}
dateNew year month day hour minute second = liftIO $ do
    result <- soup_date_new year month day hour minute second
    checkUnexpectedReturnNULL "dateNew" result
    result' <- (wrapBoxed Date) result
    return result'

-- method Date::new_from_now
-- method type : Constructor
-- Args : [Arg {argCName = "offset_seconds", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset from current time", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_new_from_now" soup_date_new_from_now :: 
    Int32 ->                                -- offset_seconds : TBasicType TInt
    IO (Ptr Date)

{- |
Creates a 'GI.Soup.Structs.Date.Date' representing a time /@offsetSeconds@/ after the
current time (or before it, if /@offsetSeconds@/ is negative). If
offset_seconds is 0, returns the current time.

If /@offsetSeconds@/ would indicate a time not expressible as a
\<type>time_t\<\/type>, the return value will be clamped into range.
-}
dateNewFromNow ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    {- ^ /@offsetSeconds@/: offset from current time -}
    -> m Date
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Date.Date' -}
dateNewFromNow offsetSeconds = liftIO $ do
    result <- soup_date_new_from_now offsetSeconds
    checkUnexpectedReturnNULL "dateNewFromNow" result
    result' <- (wrapBoxed Date) result
    return result'

-- method Date::new_from_string
-- method type : Constructor
-- Args : [Arg {argCName = "date_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the date in some plausible format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_new_from_string" soup_date_new_from_string :: 
    CString ->                              -- date_string : TBasicType TUTF8
    IO (Ptr Date)

{- |
Parses /@dateString@/ and tries to extract a date from it. This
recognizes all of the \"HTTP-date\" formats from RFC 2616, all ISO
8601 formats containing both a time and a date, RFC 2822 dates,
and reasonable approximations thereof. (Eg, it is lenient about
whitespace, leading \"0\"s, etc.)
-}
dateNewFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@dateString@/: the date in some plausible format -}
    -> m (Maybe Date)
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Date.Date', or 'Nothing' if /@dateString@/
could not be parsed. -}
dateNewFromString dateString = liftIO $ do
    dateString' <- textToCString dateString
    result <- soup_date_new_from_string dateString'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Date) result'
        return result''
    freeMem dateString'
    return maybeResult

-- method Date::new_from_time_t
-- method type : Constructor
-- Args : [Arg {argCName = "when", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a <type>time_t</type>", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_new_from_time_t" soup_date_new_from_time_t :: 
    CLong ->                                -- when : TBasicType TLong
    IO (Ptr Date)

{- |
Creates a 'GI.Soup.Structs.Date.Date' corresponding to /@when@/
-}
dateNewFromTimeT ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CLong
    {- ^ /@when@/: a \<type>time_t\<\/type> -}
    -> m Date
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Date.Date' -}
dateNewFromTimeT when_ = liftIO $ do
    result <- soup_date_new_from_time_t when_
    checkUnexpectedReturnNULL "dateNewFromTimeT" result
    result' <- (wrapBoxed Date) result
    return result'

-- method Date::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_copy" soup_date_copy :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO (Ptr Date)

{- |
Copies /@date@/.

@since 2.24
-}
dateCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Date
dateCopy date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_copy date'
    checkUnexpectedReturnNULL "dateCopy" result
    result' <- (wrapBoxed Date) result
    touchManagedPtr date
    return result'

data DateCopyMethodInfo
instance (signature ~ (m Date), MonadIO m) => O.MethodInfo DateCopyMethodInfo Date signature where
    overloadedMethod _ = dateCopy

-- method Date::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_free" soup_date_free :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO ()

{- |
Frees /@date@/.

@since 2.24
-}
dateFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m ()
dateFree date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    soup_date_free date'
    touchManagedPtr date
    return ()

data DateFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DateFreeMethodInfo Date signature where
    overloadedMethod _ = dateFree

-- method Date::get_day
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_day" soup_date_get_day :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s day.

@since 2.32
-}
dateGetDay ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s day -}
dateGetDay date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_day date'
    touchManagedPtr date
    return result

data DateGetDayMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetDayMethodInfo Date signature where
    overloadedMethod _ = dateGetDay

-- method Date::get_hour
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_hour" soup_date_get_hour :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s hour.

@since 2.32
-}
dateGetHour ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s hour -}
dateGetHour date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_hour date'
    touchManagedPtr date
    return result

data DateGetHourMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetHourMethodInfo Date signature where
    overloadedMethod _ = dateGetHour

-- method Date::get_minute
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_minute" soup_date_get_minute :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s minute.

@since 2.32
-}
dateGetMinute ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s minute -}
dateGetMinute date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_minute date'
    touchManagedPtr date
    return result

data DateGetMinuteMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetMinuteMethodInfo Date signature where
    overloadedMethod _ = dateGetMinute

-- method Date::get_month
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_month" soup_date_get_month :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s month.

@since 2.32
-}
dateGetMonth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s month -}
dateGetMonth date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_month date'
    touchManagedPtr date
    return result

data DateGetMonthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetMonthMethodInfo Date signature where
    overloadedMethod _ = dateGetMonth

-- method Date::get_offset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_offset" soup_date_get_offset :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s offset from UTC.

@since 2.32
-}
dateGetOffset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s offset from UTC. If 'GI.Soup.Structs.Date.dateGetUtc'
returns 'False' but 'GI.Soup.Structs.Date.dateGetOffset' returns 0, that means the
date is a \"floating\" time with no associated offset information. -}
dateGetOffset date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_offset date'
    touchManagedPtr date
    return result

data DateGetOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetOffsetMethodInfo Date signature where
    overloadedMethod _ = dateGetOffset

-- method Date::get_second
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_second" soup_date_get_second :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s second.

@since 2.32
-}
dateGetSecond ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s second -}
dateGetSecond date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_second date'
    touchManagedPtr date
    return result

data DateGetSecondMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetSecondMethodInfo Date signature where
    overloadedMethod _ = dateGetSecond

-- method Date::get_utc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_utc" soup_date_get_utc :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s UTC flag

@since 2.32
-}
dateGetUtc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ 'True' if /@date@/ is UTC. -}
dateGetUtc date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_utc date'
    touchManagedPtr date
    return result

data DateGetUtcMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetUtcMethodInfo Date signature where
    overloadedMethod _ = dateGetUtc

-- method Date::get_year
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_get_year" soup_date_get_year :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO Int32

{- |
Gets /@date@/\'s year.

@since 2.32
-}
dateGetYear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Int32
    {- ^ __Returns:__ /@date@/\'s year -}
dateGetYear date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_get_year date'
    touchManagedPtr date
    return result

data DateGetYearMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DateGetYearMethodInfo Date signature where
    overloadedMethod _ = dateGetYear

-- method Date::is_past
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_is_past" soup_date_is_past :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO CInt

{- |
Determines if /@date@/ is in the past.

@since 2.24
-}
dateIsPast ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@date@/ is in the past -}
dateIsPast date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_is_past date'
    let result' = (/= 0) result
    touchManagedPtr date
    return result'

data DateIsPastMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo DateIsPastMethodInfo Date signature where
    overloadedMethod _ = dateIsPast

-- method Date::to_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Soup", name = "DateFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format to generate the date in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_to_string" soup_date_to_string :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Soup", name = "DateFormat"})
    IO CString

{- |
Converts /@date@/ to a string in the format described by /@format@/.
-}
dateToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> Soup.Enums.DateFormat
    {- ^ /@format@/: the format to generate the date in -}
    -> m T.Text
    {- ^ __Returns:__ /@date@/ as a string -}
dateToString date format = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    let format' = (fromIntegral . fromEnum) format
    result <- soup_date_to_string date' format'
    checkUnexpectedReturnNULL "dateToString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr date
    return result'

data DateToStringMethodInfo
instance (signature ~ (Soup.Enums.DateFormat -> m T.Text), MonadIO m) => O.MethodInfo DateToStringMethodInfo Date signature where
    overloadedMethod _ = dateToString

-- method Date::to_time_t
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_to_time_t" soup_date_to_time_t :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    IO CLong

{- |
Converts /@date@/ to a \<type>time_t\<\/type>.

If /@date@/ is not representable as a \<type>time_t\<\/type>, it will be
clamped into range. (In particular, some HTTP cookies have
expiration dates after \"Y2.038k\" (2038-01-19T03:14:07Z).)
-}
dateToTimeT ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m CLong
    {- ^ __Returns:__ /@date@/ as a \<type>time_t\<\/type> -}
dateToTimeT date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    result <- soup_date_to_time_t date'
    touchManagedPtr date
    return result

data DateToTimeTMethodInfo
instance (signature ~ (m CLong), MonadIO m) => O.MethodInfo DateToTimeTMethodInfo Date signature where
    overloadedMethod _ = dateToTimeT

-- method Date::to_timeval
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "date", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupDate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TInterface (Name {namespace = "GLib", name = "TimeVal"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTimeVal structure in which to store the converted time.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_to_timeval" soup_date_to_timeval :: 
    Ptr Date ->                             -- date : TInterface (Name {namespace = "Soup", name = "Date"})
    Ptr GLib.TimeVal.TimeVal ->             -- time : TInterface (Name {namespace = "GLib", name = "TimeVal"})
    IO ()

{- |
Converts /@date@/ to a 'GI.GLib.Structs.TimeVal.TimeVal'.

@since 2.24
-}
dateToTimeval ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Date
    {- ^ /@date@/: a 'GI.Soup.Structs.Date.Date' -}
    -> m (GLib.TimeVal.TimeVal)
dateToTimeval date = liftIO $ do
    date' <- unsafeManagedPtrGetPtr date
    time <- callocBytes 16 :: IO (Ptr GLib.TimeVal.TimeVal)
    soup_date_to_timeval date' time
    time' <- (wrapPtr GLib.TimeVal.TimeVal) time
    touchManagedPtr date
    return time'

data DateToTimevalMethodInfo
instance (signature ~ (m (GLib.TimeVal.TimeVal)), MonadIO m) => O.MethodInfo DateToTimevalMethodInfo Date signature where
    overloadedMethod _ = dateToTimeval

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) => O.IsLabelProxy t (Date -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDateMethod t Date, O.MethodInfo info Date p) => O.IsLabel t (Date -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif