| Copyright | Will Thompson and Iñaki García Etxebarria |
|---|---|
| License | LGPL-2.1 |
| Maintainer | Iñaki García Etxebarria |
| Safe Haskell | None |
| Language | Haskell2010 |
GI.GLib.Structs.Date
Contents
- Exported types
- Methods
- addDays
- addMonths
- addYears
- clamp
- clear
- compare
- copy
- daysBetween
- free
- getDay
- getDayOfYear
- getDaysInMonth
- getIso8601WeekOfYear
- getJulian
- getMondayWeekOfYear
- getMondayWeeksInYear
- getMonth
- getSundayWeekOfYear
- getSundayWeeksInYear
- getWeekOfYear
- getWeekday
- getWeeksInYear
- getYear
- isFirstOfMonth
- isLastOfMonth
- isLeapYear
- new
- newDmy
- newJulian
- order
- setDay
- setDmy
- setJulian
- setMonth
- setParse
- setTime
- setTimeT
- setTimeVal
- setYear
- strftime
- subtractDays
- subtractMonths
- subtractYears
- toStructTm
- valid
- validDay
- validDmy
- validJulian
- validMonth
- validWeekday
- validYear
- Properties
Description
GDate is a struct for calendrical calculations.
The GDate data structure represents a day between January 1, Year 1,
and sometime a few thousand years in the future (right now it will go
to the year 65535 or so, but dateSetParse only parses up to the
year 8000 or so - just count on "a few thousand"). GDate is meant to
represent everyday dates, not astronomical dates or historical dates
or ISO timestamps or the like. It extrapolates the current Gregorian
calendar forward and backward in time; there is no attempt to change
the calendar to match time periods or locations. GDate does not store
time information; it represents a day.
The GDate implementation has several nice features; it is only a
64-bit struct, so storing large numbers of dates is very efficient. It
can keep both a Julian and day-month-year representation of the date,
since some calculations are much easier with one representation or the
other. A Julian representation is simply a count of days since some
fixed day in the past; for Date the fixed day is January 1, 1 AD.
("Julian" dates in the Date API aren't really Julian dates in the
technical sense; technically, Julian dates count from the start of the
Julian period, Jan 1, 4713 BC).
GDate is simple to use. First you need a "blank" date; you can get a
dynamically allocated date from dateNew, or you can declare an
automatic variable or array and initialize it by calling dateClear.
A cleared date is safe; it's safe to call dateSetDmy and the other
mutator functions to initialize the value of a cleared date. However, a cleared date
is initially invalid, meaning that it doesn't represent a day that exists.
It is undefined to call any of the date calculation routines on an invalid date.
If you obtain a date from a user or other unpredictable source, you should check
its validity with the dateValid predicate. dateValid
is also used to check for errors with dateSetParse and other functions
that can fail. Dates can be invalidated by calling dateClear again.
It is very important to use the API to access the GDate struct. Often only the
day-month-year or only the Julian representation is valid. Sometimes neither is valid.
Use the API.
GLib also features GDateTime which represents a precise time.
Synopsis
- newtype Date = Date (ManagedPtr Date)
- newZeroDate :: MonadIO m => m Date
- type family ResolveDateMethod (t :: Symbol) o where ...
- data DateAddDaysMethodInfo
- dateAddDays :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateAddMonthsMethodInfo
- dateAddMonths :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateAddYearsMethodInfo
- dateAddYears :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateClampMethodInfo
- dateClamp :: (HasCallStack, MonadIO m) => Date -> Date -> Date -> m ()
- data DateClearMethodInfo
- dateClear :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateCompareMethodInfo
- dateCompare :: (HasCallStack, MonadIO m) => Date -> Date -> m Int32
- data DateCopyMethodInfo
- dateCopy :: (HasCallStack, MonadIO m) => Date -> m Date
- data DateDaysBetweenMethodInfo
- dateDaysBetween :: (HasCallStack, MonadIO m) => Date -> Date -> m Int32
- data DateFreeMethodInfo
- dateFree :: (HasCallStack, MonadIO m) => Date -> m ()
- data DateGetDayMethodInfo
- dateGetDay :: (HasCallStack, MonadIO m) => Date -> m Word8
- data DateGetDayOfYearMethodInfo
- dateGetDayOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32
- dateGetDaysInMonth :: (HasCallStack, MonadIO m) => DateMonth -> Word16 -> m Word8
- data DateGetIso8601WeekOfYearMethodInfo
- dateGetIso8601WeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32
- data DateGetJulianMethodInfo
- dateGetJulian :: (HasCallStack, MonadIO m) => Date -> m Word32
- data DateGetMondayWeekOfYearMethodInfo
- dateGetMondayWeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32
- dateGetMondayWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> m Word8
- data DateGetMonthMethodInfo
- dateGetMonth :: (HasCallStack, MonadIO m) => Date -> m DateMonth
- data DateGetSundayWeekOfYearMethodInfo
- dateGetSundayWeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32
- dateGetSundayWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> m Word8
- data DateGetWeekOfYearMethodInfo
- dateGetWeekOfYear :: (HasCallStack, MonadIO m) => Date -> DateWeekday -> m Word32
- data DateGetWeekdayMethodInfo
- dateGetWeekday :: (HasCallStack, MonadIO m) => Date -> m DateWeekday
- dateGetWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> DateWeekday -> m Word8
- data DateGetYearMethodInfo
- dateGetYear :: (HasCallStack, MonadIO m) => Date -> m Word16
- data DateIsFirstOfMonthMethodInfo
- dateIsFirstOfMonth :: (HasCallStack, MonadIO m) => Date -> m Bool
- data DateIsLastOfMonthMethodInfo
- dateIsLastOfMonth :: (HasCallStack, MonadIO m) => Date -> m Bool
- dateIsLeapYear :: (HasCallStack, MonadIO m) => Word16 -> m Bool
- dateNew :: (HasCallStack, MonadIO m) => m Date
- dateNewDmy :: (HasCallStack, MonadIO m) => Word8 -> DateMonth -> Word16 -> m Date
- dateNewJulian :: (HasCallStack, MonadIO m) => Word32 -> m Date
- data DateOrderMethodInfo
- dateOrder :: (HasCallStack, MonadIO m) => Date -> Date -> m ()
- data DateSetDayMethodInfo
- dateSetDay :: (HasCallStack, MonadIO m) => Date -> Word8 -> m ()
- data DateSetDmyMethodInfo
- dateSetDmy :: (HasCallStack, MonadIO m) => Date -> Word8 -> DateMonth -> Word16 -> m ()
- data DateSetJulianMethodInfo
- dateSetJulian :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateSetMonthMethodInfo
- dateSetMonth :: (HasCallStack, MonadIO m) => Date -> DateMonth -> m ()
- data DateSetParseMethodInfo
- dateSetParse :: (HasCallStack, MonadIO m) => Date -> Text -> m ()
- data DateSetTimeMethodInfo
- dateSetTime :: (HasCallStack, MonadIO m) => Date -> Int32 -> m ()
- data DateSetTimeTMethodInfo
- dateSetTimeT :: (HasCallStack, MonadIO m) => Date -> CTime -> m ()
- data DateSetTimeValMethodInfo
- dateSetTimeVal :: (HasCallStack, MonadIO m) => Date -> TimeVal -> m ()
- data DateSetYearMethodInfo
- dateSetYear :: (HasCallStack, MonadIO m) => Date -> Word16 -> m ()
- dateStrftime :: (HasCallStack, MonadIO m) => Text -> CSize -> Text -> Date -> m CSize
- data DateSubtractDaysMethodInfo
- dateSubtractDays :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateSubtractMonthsMethodInfo
- dateSubtractMonths :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateSubtractYearsMethodInfo
- dateSubtractYears :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()
- data DateToStructTmMethodInfo
- dateToStructTm :: (HasCallStack, MonadIO m) => Date -> Ptr () -> m ()
- data DateValidMethodInfo
- dateValid :: (HasCallStack, MonadIO m) => Date -> m Bool
- dateValidDay :: (HasCallStack, MonadIO m) => Word8 -> m Bool
- dateValidDmy :: (HasCallStack, MonadIO m) => Word8 -> DateMonth -> Word16 -> m Bool
- dateValidJulian :: (HasCallStack, MonadIO m) => Word32 -> m Bool
- dateValidMonth :: (HasCallStack, MonadIO m) => DateMonth -> m Bool
- dateValidWeekday :: (HasCallStack, MonadIO m) => DateWeekday -> m Bool
- dateValidYear :: (HasCallStack, MonadIO m) => Word16 -> m Bool
- date_day :: AttrLabelProxy "day"
- getDateDay :: MonadIO m => Date -> m Word32
- setDateDay :: MonadIO m => Date -> Word32 -> m ()
- date_dmy :: AttrLabelProxy "dmy"
- getDateDmy :: MonadIO m => Date -> m Word32
- setDateDmy :: MonadIO m => Date -> Word32 -> m ()
- date_julian :: AttrLabelProxy "julian"
- getDateJulian :: MonadIO m => Date -> m Word32
- setDateJulian :: MonadIO m => Date -> Word32 -> m ()
- date_julianDays :: AttrLabelProxy "julianDays"
- getDateJulianDays :: MonadIO m => Date -> m Word32
- setDateJulianDays :: MonadIO m => Date -> Word32 -> m ()
- date_month :: AttrLabelProxy "month"
- getDateMonth :: MonadIO m => Date -> m Word32
- setDateMonth :: MonadIO m => Date -> Word32 -> m ()
- date_year :: AttrLabelProxy "year"
- getDateYear :: MonadIO m => Date -> m Word32
- setDateYear :: MonadIO m => Date -> Word32 -> m ()
Exported types
Memory-managed wrapper type.
Constructors
| Date (ManagedPtr Date) |
Instances
Methods
Click to display all available methods, including inherited ones
Methods
addDays, addMonths, addYears, clamp, clear, compare, copy, daysBetween, free, isFirstOfMonth, isLastOfMonth, order, subtractDays, subtractMonths, subtractYears, toStructTm, valid.
Getters
getDay, getDayOfYear, getIso8601WeekOfYear, getJulian, getMondayWeekOfYear, getMonth, getSundayWeekOfYear, getWeekOfYear, getWeekday, getYear.
Setters
setDay, setDmy, setJulian, setMonth, setParse, setTime, setTimeT, setTimeVal, setYear.
type family ResolveDateMethod (t :: Symbol) o where ... Source #
Equations
addDays
data DateAddDaysMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateAddDaysMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateAddDaysMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Increments a date some number of days. To move forward by weeks, add weeks*7 days. The date must be valid.
addMonths
data DateAddMonthsMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateAddMonthsMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateAddMonthsMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Increments a date by some number of months. If the day of the month is greater than 28, this routine may change the day of the month (because the destination month may not have the current day in it). The date must be valid.
addYears
data DateAddYearsMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateAddYearsMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateAddYearsMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Increments a date by some number of years. If the date is February 29, and the destination year is not a leap year, the date will be changed to February 28. The date must be valid.
clamp
data DateClampMethodInfo Source #
Instances
| (signature ~ (Date -> Date -> m ()), MonadIO m) => OverloadedMethod DateClampMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateClampMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
clear
data DateClearMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateClearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateClearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
compare
data DateCompareMethodInfo Source #
Instances
| (signature ~ (Date -> m Int32), MonadIO m) => OverloadedMethod DateCompareMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateCompareMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Date |
|
| -> m Int32 | Returns: 0 for equal, less than zero if |
qsort()-style comparison function for dates.
Both dates must be valid.
copy
data DateCopyMethodInfo Source #
Instances
| (signature ~ m Date, MonadIO m) => OverloadedMethod DateCopyMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateCopyMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Date | Returns: a newly-allocated |
Copies a GDate to a newly-allocated GDate. If the input was invalid
(as determined by dateValid), the invalid state will be copied
as is into the new object.
Since: 2.56
daysBetween
data DateDaysBetweenMethodInfo Source #
Instances
| (signature ~ (Date -> m Int32), MonadIO m) => OverloadedMethod DateDaysBetweenMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateDaysBetweenMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Date |
|
| -> m Int32 | Returns: the number of days between |
Computes the number of days between two dates.
If date2 is prior to date1, the returned value is negative.
Both dates must be valid.
free
data DateFreeMethodInfo Source #
Instances
| (signature ~ m (), MonadIO m) => OverloadedMethod DateFreeMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateFreeMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m () |
getDay
data DateGetDayMethodInfo Source #
Instances
| (signature ~ m Word8, MonadIO m) => OverloadedMethod DateGetDayMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetDayMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word8 | Returns: day of the month |
Returns the day of the month. The date must be valid.
getDayOfYear
data DateGetDayOfYearMethodInfo Source #
Instances
| (signature ~ m Word32, MonadIO m) => OverloadedMethod DateGetDayOfYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetDayOfYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word32 | Returns: day of the year |
Returns the day of the year, where Jan 1 is the first day of the year. The date must be valid.
getDaysInMonth
Arguments
| :: (HasCallStack, MonadIO m) | |
| => DateMonth |
|
| -> Word16 |
|
| -> m Word8 | Returns: number of days in |
Returns the number of days in a month, taking leap years into account.
getIso8601WeekOfYear
data DateGetIso8601WeekOfYearMethodInfo Source #
Instances
| (signature ~ m Word32, MonadIO m) => OverloadedMethod DateGetIso8601WeekOfYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetIso8601WeekOfYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
dateGetIso8601WeekOfYear Source #
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word32 | Returns: ISO 8601 week number of the year. |
Returns the week of the year, where weeks are interpreted according to ISO 8601.
Since: 2.6
getJulian
data DateGetJulianMethodInfo Source #
Instances
| (signature ~ m Word32, MonadIO m) => OverloadedMethod DateGetJulianMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetJulianMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word32 | Returns: Julian day |
Returns the Julian day or "serial number" of the Date. The
Julian day is simply the number of days since January 1, Year 1; i.e.,
January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,
etc. The date must be valid.
getMondayWeekOfYear
data DateGetMondayWeekOfYearMethodInfo Source #
Instances
| (signature ~ m Word32, MonadIO m) => OverloadedMethod DateGetMondayWeekOfYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetMondayWeekOfYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
dateGetMondayWeekOfYear Source #
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word32 | Returns: week of the year |
Returns the week of the year, where weeks are understood to start on Monday. If the date is before the first Monday of the year, return 0. The date must be valid.
getMondayWeeksInYear
dateGetMondayWeeksInYear Source #
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word16 |
|
| -> m Word8 | Returns: number of Mondays in the year |
Returns the number of weeks in the year, where weeks are taken to start on Monday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Mondays are in the year, i.e. there are 53 Mondays if one of the extra days happens to be a Monday.)
getMonth
data DateGetMonthMethodInfo Source #
Instances
| (signature ~ m DateMonth, MonadIO m) => OverloadedMethod DateGetMonthMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetMonthMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m DateMonth | Returns: month of the year as a |
Returns the month of the year. The date must be valid.
getSundayWeekOfYear
data DateGetSundayWeekOfYearMethodInfo Source #
Instances
| (signature ~ m Word32, MonadIO m) => OverloadedMethod DateGetSundayWeekOfYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetSundayWeekOfYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
dateGetSundayWeekOfYear Source #
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word32 | Returns: week number |
Returns the week of the year during which this date falls, if weeks are understood to begin on Sunday. The date must be valid. Can return 0 if the day is before the first Sunday of the year.
getSundayWeeksInYear
dateGetSundayWeeksInYear Source #
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word16 |
|
| -> m Word8 | Returns: the number of weeks in |
Returns the number of weeks in the year, where weeks are taken to start on Sunday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Sundays are in the year, i.e. there are 53 Sundays if one of the extra days happens to be a Sunday.)
getWeekOfYear
data DateGetWeekOfYearMethodInfo Source #
Instances
| (signature ~ (DateWeekday -> m Word32), MonadIO m) => OverloadedMethod DateGetWeekOfYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetWeekOfYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> DateWeekday |
|
| -> m Word32 | Returns: week number (starting from 1), or |
Calculates the week of the year during which this date falls.
The result depends on which day is considered the first day of the week,
which varies by locale. Both date and first_day_of_week must be valid.
If date is before the start of the first week of the year (for example,
before the first Monday in January if firstDayOfWeek is
DateWeekdayMonday) then zero will be returned.
Since: 2.86
getWeekday
data DateGetWeekdayMethodInfo Source #
Instances
| (signature ~ m DateWeekday, MonadIO m) => OverloadedMethod DateGetWeekdayMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetWeekdayMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m DateWeekday | Returns: day of the week as a |
Returns the day of the week for a Date. The date must be valid.
getWeeksInYear
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word16 |
|
| -> DateWeekday |
|
| -> m Word8 | Returns: the number of weeks in |
Calculates the number of weeks in the year.
The result depends on which day is considered the first day of the week,
which varies by locale. first_day_of_week must be valid.
The result will be either 52 or 53. Years always have 52 seven-day periods,
plus one or two extra days depending on whether it’s a leap year. This
function effectively calculates how many firstDayOfWeek days there are in
the year.
Since: 2.86
getYear
data DateGetYearMethodInfo Source #
Instances
| (signature ~ m Word16, MonadIO m) => OverloadedMethod DateGetYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateGetYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Word16 | Returns: year in which the date falls |
Returns the year of a Date. The date must be valid.
isFirstOfMonth
data DateIsFirstOfMonthMethodInfo Source #
Instances
| (signature ~ m Bool, MonadIO m) => OverloadedMethod DateIsFirstOfMonthMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateIsFirstOfMonthMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Bool | Returns: |
Returns True if the date is on the first of a month.
The date must be valid.
isLastOfMonth
data DateIsLastOfMonthMethodInfo Source #
Instances
| (signature ~ m Bool, MonadIO m) => OverloadedMethod DateIsLastOfMonthMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateIsLastOfMonthMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Bool | Returns: |
Returns True if the date is the last day of the month.
The date must be valid.
isLeapYear
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word16 |
|
| -> m Bool | Returns: |
Returns True if the year is a leap year.
For the purposes of this function, leap year is every year divisible by 4 unless that year is divisible by 100. If it is divisible by 100 it would be a leap year only if that year is also divisible by 400.
new
Arguments
| :: (HasCallStack, MonadIO m) | |
| => m Date | Returns: a newly-allocated |
newDmy
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word8 |
|
| -> DateMonth |
|
| -> Word16 |
|
| -> m Date | Returns: a newly-allocated |
Create a new Date representing the given day-month-year triplet.
The triplet you pass in must represent a valid date. Use dateValidDmy
if needed to validate it. The returned Date is guaranteed to be non-Nothing
and valid.
newJulian
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word32 |
|
| -> m Date | Returns: a newly-allocated |
Create a new Date representing the given Julian date.
The julianDay you pass in must be valid. Use dateValidJulian if
needed to validate it. The returned Date is guaranteed to be non-Nothing and
valid.
order
data DateOrderMethodInfo Source #
Instances
| (signature ~ (Date -> m ()), MonadIO m) => OverloadedMethod DateOrderMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateOrderMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Date |
|
| -> m () |
Checks if date1 is less than or equal to date2,
and swap the values if this is not the case.
setDay
data DateSetDayMethodInfo Source #
Instances
| (signature ~ (Word8 -> m ()), MonadIO m) => OverloadedMethod DateSetDayMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetDayMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word8 |
|
| -> m () |
Sets the day of the month for a Date. If the resulting
day-month-year triplet is invalid, the date will be invalid.
setDmy
data DateSetDmyMethodInfo Source #
Instances
| (signature ~ (Word8 -> DateMonth -> Word16 -> m ()), MonadIO m) => OverloadedMethod DateSetDmyMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetDmyMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word8 |
|
| -> DateMonth |
|
| -> Word16 |
|
| -> m () |
Sets the value of a Date from a day, month, and year.
The day-month-year triplet must be valid; if you aren't
sure it is, call dateValidDmy to check before you
set it.
setJulian
data DateSetJulianMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateSetJulianMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetJulianMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Sets the value of a Date from a Julian day number.
setMonth
data DateSetMonthMethodInfo Source #
Instances
| (signature ~ (DateMonth -> m ()), MonadIO m) => OverloadedMethod DateSetMonthMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetMonthMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> DateMonth |
|
| -> m () |
Sets the month of the year for a Date. If the resulting
day-month-year triplet is invalid, the date will be invalid.
setParse
data DateSetParseMethodInfo Source #
Instances
| (signature ~ (Text -> m ()), MonadIO m) => OverloadedMethod DateSetParseMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetParseMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Text |
|
| -> m () |
Parses a user-inputted string str, and try to figure out what date it
represents, taking the current locale
into account. If the string is successfully parsed, the date will be
valid after the call. Otherwise, it will be invalid. You should check
using dateValid to see whether the parsing succeeded.
This function is not appropriate for file formats and the like; it isn't very precise, and its exact behavior varies with the locale. It's intended to be a heuristic routine that guesses what the user means by a given string (and it does work pretty well in that capacity).
setTime
data DateSetTimeMethodInfo Source #
Instances
| (signature ~ (Int32 -> m ()), MonadIO m) => OverloadedMethod DateSetTimeMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetTimeMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Int32 |
|
| -> m () |
Deprecated: (Since version 2.10)Use dateSetTimeT instead.
Sets the value of a date from a GTime value.
The time to date conversion is done using the user's current timezone.
setTimeT
data DateSetTimeTMethodInfo Source #
Instances
| (signature ~ (CTime -> m ()), MonadIO m) => OverloadedMethod DateSetTimeTMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetTimeTMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> CTime |
|
| -> m () |
Sets the value of a date to the date corresponding to a time specified as a time_t. The time to date conversion is done using the user's current timezone.
To set the value of a date to the current day, you could write:
C code
time_t now = time (NULL); if (now == (time_t) -1) // handle the error g_date_set_time_t (date, now);
Since: 2.10
setTimeVal
data DateSetTimeValMethodInfo Source #
Instances
| (signature ~ (TimeVal -> m ()), MonadIO m) => OverloadedMethod DateSetTimeValMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetTimeValMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> TimeVal |
|
| -> m () |
Deprecated: (Since version 2.62)TimeVal is not year-2038-safe. Use dateSetTimeTinstead.
Sets the value of a date from a TimeVal value. Note that the
tvUsec member is ignored, because Date can't make use of the
additional precision.
The time to date conversion is done using the user's current timezone.
Since: 2.10
setYear
data DateSetYearMethodInfo Source #
Instances
| (signature ~ (Word16 -> m ()), MonadIO m) => OverloadedMethod DateSetYearMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSetYearMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word16 |
|
| -> m () |
Sets the year for a Date. If the resulting day-month-year
triplet is invalid, the date will be invalid.
strftime
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Text |
|
| -> CSize |
|
| -> Text |
|
| -> Date |
|
| -> m CSize | Returns: number of characters written to the buffer, or |
Generates a printed representation of the date, in a
locale-specific way.
Works just like the platform's C library strftime() function,
but only accepts date-related formats; time-related formats
give undefined results. Date must be valid. Unlike strftime()
(which uses the locale encoding), works on a UTF-8 format
string and stores a UTF-8 result.
This function does not provide any conversion specifiers in
addition to those implemented by the platform's C library.
For example, don't expect that using dateStrftime would
make the %F provided by the C99 strftime() work on Windows
where the C library only complies to C89.
subtractDays
data DateSubtractDaysMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateSubtractDaysMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSubtractDaysMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Moves a date some number of days into the past. To move by weeks, just move by weeks*7 days. The date must be valid.
subtractMonths
data DateSubtractMonthsMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateSubtractMonthsMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSubtractMonthsMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Moves a date some number of months into the past. If the current day of the month doesn't exist in the destination month, the day of the month may change. The date must be valid.
subtractYears
data DateSubtractYearsMethodInfo Source #
Instances
| (signature ~ (Word32 -> m ()), MonadIO m) => OverloadedMethod DateSubtractYearsMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateSubtractYearsMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Word32 |
|
| -> m () |
Moves a date some number of years into the past. If the current day doesn't exist in the destination year (i.e. it's February 29 and you move to a non-leap-year) then the day is changed to February 29. The date must be valid.
toStructTm
data DateToStructTmMethodInfo Source #
Instances
| (signature ~ (Ptr () -> m ()), MonadIO m) => OverloadedMethod DateToStructTmMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateToStructTmMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> Ptr () |
|
| -> m () |
Fills in the date-related bits of a struct tm using the date value.
Initializes the non-date parts with something safe but meaningless.
valid
data DateValidMethodInfo Source #
Instances
| (signature ~ m Bool, MonadIO m) => OverloadedMethod DateValidMethodInfo Date signature Source # | |
Defined in GI.GLib.Structs.Date Methods overloadedMethod :: Date -> signature # | |
| OverloadedMethodInfo DateValidMethodInfo Date Source # | |
Defined in GI.GLib.Structs.Date Methods | |
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Date |
|
| -> m Bool | Returns: Whether the date is valid |
validDay
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word8 |
|
| -> m Bool | Returns: |
Returns True if the day of the month is valid (a day is valid if it's
between 1 and 31 inclusive).
validDmy
validJulian
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word32 |
|
| -> m Bool | Returns: |
Returns True if the Julian day is valid. Anything greater than zero
is basically a valid Julian, though there is a 32-bit limit.
validMonth
Arguments
| :: (HasCallStack, MonadIO m) | |
| => DateMonth |
|
| -> m Bool | Returns: |
validWeekday
Arguments
| :: (HasCallStack, MonadIO m) | |
| => DateWeekday |
|
| -> m Bool | Returns: |
Returns True if the weekday is valid. The seven DateWeekday enumeration
values are the only valid weekdays.
validYear
Arguments
| :: (HasCallStack, MonadIO m) | |
| => Word16 |
|
| -> m Bool | Returns: |
Properties
day
the day of the day-month-year representation of the date, as a number between 1 and 31
date_day :: AttrLabelProxy "day" Source #
getDateDay :: MonadIO m => Date -> m Word32 Source #
Get the value of the “day” field.
When overloading is enabled, this is equivalent to
get date #day
setDateDay :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “day” field.
When overloading is enabled, this is equivalent to
setdate [ #day:=value ]
dmy
this is set if day, month and year are valid
date_dmy :: AttrLabelProxy "dmy" Source #
getDateDmy :: MonadIO m => Date -> m Word32 Source #
Get the value of the “dmy” field.
When overloading is enabled, this is equivalent to
get date #dmy
setDateDmy :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “dmy” field.
When overloading is enabled, this is equivalent to
setdate [ #dmy:=value ]
julian
this bit is set if julianDays is valid
date_julian :: AttrLabelProxy "julian" Source #
getDateJulian :: MonadIO m => Date -> m Word32 Source #
Get the value of the “julian” field.
When overloading is enabled, this is equivalent to
get date #julian
setDateJulian :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “julian” field.
When overloading is enabled, this is equivalent to
setdate [ #julian:=value ]
julianDays
the Julian representation of the date
date_julianDays :: AttrLabelProxy "julianDays" Source #
getDateJulianDays :: MonadIO m => Date -> m Word32 Source #
Get the value of the “julian_days” field.
When overloading is enabled, this is equivalent to
get date #julianDays
setDateJulianDays :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “julian_days” field.
When overloading is enabled, this is equivalent to
setdate [ #julianDays:=value ]
month
the month of the day-month-year representation of the date, as a number between 1 and 12
date_month :: AttrLabelProxy "month" Source #
getDateMonth :: MonadIO m => Date -> m Word32 Source #
Get the value of the “month” field.
When overloading is enabled, this is equivalent to
get date #month
setDateMonth :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “month” field.
When overloading is enabled, this is equivalent to
setdate [ #month:=value ]
year
the year of the day-month-year representation of the date
date_year :: AttrLabelProxy "year" Source #
getDateYear :: MonadIO m => Date -> m Word32 Source #
Get the value of the “year” field.
When overloading is enabled, this is equivalent to
get date #year
setDateYear :: MonadIO m => Date -> Word32 -> m () Source #
Set the value of the “year” field.
When overloading is enabled, this is equivalent to
setdate [ #year:=value ]