Date and Time Functions

Функции даты и времени

Date and Time Functions — календарные вычисления и различный материал времени.

Краткое описание



#include <glib.h>


#define     G_USEC_PER_SEC
            GTimeVal;
void        g_get_current_time              (GTimeVal *result);
void        g_usleep                        (gulong microseconds);
void        g_time_val_add                  (GTimeVal *time_,
                                             glong microseconds);
gboolean    g_time_val_from_iso8601         (const gchar *iso_date,
                                             GTimeVal *time_);
gchar*      g_time_val_to_iso8601           (GTimeVal *time_);

            GDate;
typedef     GTime;
enum        GDateDMY;
typedef     GDateDay;
enum        GDateMonth;
typedef     GDateYear;
enum        GDateWeekday;

#define     G_DATE_BAD_DAY
#define     G_DATE_BAD_JULIAN
#define     G_DATE_BAD_YEAR

GDate*      g_date_new                      (void);
GDate*      g_date_new_dmy                  (GDateDay day,
                                             GDateMonth month,
                                             GDateYear year);
GDate*      g_date_new_julian               (guint32 julian_day);
void        g_date_clear                    (GDate *date,
                                             guint n_dates);
void        g_date_free                     (GDate *date);

void        g_date_set_day                  (GDate *date,
                                             GDateDay day);
void        g_date_set_month                (GDate *date,
                                             GDateMonth month);
void        g_date_set_year                 (GDate *date,
                                             GDateYear year);
void        g_date_set_dmy                  (GDate *date,
                                             GDateDay day,
                                             GDateMonth month,
                                             GDateYear y);
void        g_date_set_julian               (GDate *date,
                                             guint32 julian_date);
void        g_date_set_time                 (GDate *date,
                                             GTime time_);
void        g_date_set_time_t               (GDate *date,
                                             time_t timet);
void        g_date_set_time_val             (GDate *date,
                                             GTimeVal *timeval);
void        g_date_set_parse                (GDate *date,
                                             const gchar *str);

void        g_date_add_days                 (GDate *date,
                                             guint n_days);
void        g_date_subtract_days            (GDate *date,
                                             guint n_days);
void        g_date_add_months               (GDate *date,
                                             guint n_months);
void        g_date_subtract_months          (GDate *date,
                                             guint n_months);
void        g_date_add_years                (GDate *date,
                                             guint n_years);
void        g_date_subtract_years           (GDate *date,
                                             guint n_years);
gint        g_date_days_between             (const GDate *date1,
                                             const GDate *date2);
gint        g_date_compare                  (const GDate *lhs,
                                             const GDate *rhs);
void        g_date_clamp                    (GDate *date,
                                             const GDate *min_date,
                                             const GDate *max_date);
void        g_date_order                    (GDate *date1,
                                             GDate *date2);

GDateDay    g_date_get_day                  (const GDate *date);
GDateMonth  g_date_get_month                (const GDate *date);
GDateYear   g_date_get_year                 (const GDate *date);
guint32     g_date_get_julian               (const GDate *date);
GDateWeekday g_date_get_weekday             (const GDate *date);
guint       g_date_get_day_of_year          (const GDate *date);

guint8      g_date_get_days_in_month        (GDateMonth month,
                                             GDateYear year);
gboolean    g_date_is_first_of_month        (const GDate *date);
gboolean    g_date_is_last_of_month         (const GDate *date);
gboolean    g_date_is_leap_year             (GDateYear year);
guint       g_date_get_monday_week_of_year  (const GDate *date);
guint8      g_date_get_monday_weeks_in_year (GDateYear year);
guint       g_date_get_sunday_week_of_year  (const GDate *date);
guint8      g_date_get_sunday_weeks_in_year (GDateYear year);
guint       g_date_get_iso8601_week_of_year (const GDate *date);

gsize       g_date_strftime                 (gchar *s,
                                             gsize slen,
                                             const gchar *format,
                                             const GDate *date);
void        g_date_to_struct_tm             (const GDate *date,
                                             struct tm *tm);

gboolean    g_date_valid                    (const GDate *date);
gboolean    g_date_valid_day                (GDateDay day);
gboolean    g_date_valid_month              (GDateMonth month);
gboolean    g_date_valid_year               (GDateYear year);
gboolean    g_date_valid_dmy                (GDateDay day,
                                             GDateMonth month,
                                             GDateYear year);
gboolean    g_date_valid_julian             (guint32 julian_date);
gboolean    g_date_valid_weekday            (GDateWeekday weekday);

Описание

Структура данных GDate представляет день между 1 Января (January 1), 1 Года (Year 1), и несколькими тысячами лет в будущем (в данный момент это составляет приблизительно 65535 лет, но g_date_set_parse() анализирует только до 8000 года приблизительно - простой счёт в "несколько тысяч"). GDate предназначена для представления ежедневных дат, не астрономических дат, не исторических дат, не ISO временных интервалов (timestamps) и не подобных им. Она экстраполирует текущий Григорианский календарь вперёд и назад во времени; не производится никаких попыток изменить календарь для соответствия временным периодам или месту расположения. GDate не хранит информацию о времени; она представляет day.

GDate реализация имеет несколько прекрасных особенностей; она является 64-битной структурой, поэтому хранение большого количества дат очень эффективно. Она может принимать оба вида представления даты и Юлианское и день-месяц-год, так как некоторые расчёты более просты либо с одним представлением даты либо с другим. Юлианское представление - это просто подсчёт дней с некоторой фиксированной даты в прошлом; для GDate фиксированным днём является 1 Января, 1 года нашей эры (1 AD). ("Юлианские" даты в GDate API не являются фактическими Юлианскими датами в техническом смысле; технически, Юлианские даты подсчитываются начиная с Юлианского периода, 1 Января 4713 год до нашей эры (Julian period, Jan 1, 4713 BC)).

GDate проста в использовании. Сначала вам потребуется пустая дата ("blank" date); вы можете получить динамически распределяемую дату из g_date_new(), или вы можете объявить автоматическую переменную или массив и инициализировать его в нормальное состояние вызвав g_date_clear(). Очищенная дата это нормально; это безопасно для вызова g_date_set_dmy() и других функций мутаторов для инициализации значения очищенной даты. Однако, очищенная дата первоначально недоступна, это значит что она представляет день которого не существует. Она не определена для вызова любых подпрограмм расчёта даты. Если вы определяете дату от пользователя или другого непредсказуемого источника, вы должны проверять правильность даты с помощью g_date_valid(). g_date_valid() также используется для проверки ошибок g_date_set_parse() и других функций которые могут завершиться неудачно. Даты могут быть очищены снова с помощью вызова g_date_clear().

Очень важно использовать API для доступа к GDatestruct. Зачастую правильным является только представление день-месяц-год (day-month-year) или Юлианское. Иногда не одно из этих представлений неправильно. Используйте API.

GLib не содержит функций манипулирования временем; однако, есть GTime typedef и GTimeVal структура которые представляют более точное время (в микросекундах). Вы можете запросить текущее время как GTimeVal с помощью g_get_current_time().

Детали

G_USEC_PER_SEC

#define G_USEC_PER_SEC 1000000

Количество микросекунд в одной секунде (1 миллион). Этот макрос обеспечивает удобочитаемость кода.

GTimeVal

typedef struct {
  glong tv_sec;
  glong tv_usec;
} GTimeVal;

Представляет точное время, с секундами и микросекундами. Похоже на возврат struct timeval вызова the gettimeofday() UNIX.

glong `tv_sec`;	секунды.
glong `tv_usec`;	микросекунды.

g_get_current_time ()

void g_get_current_time (GTimeVal *result);

Аналог UNIX функции gettimeofday(), но переносимый.

result : GTimeVal структура в которой хранится текущее время.

g_usleep ()

void g_usleep (gulong microseconds);

Приостанавливает текущий поток на определённое количество микросекунд. В секунде есть 1 миллион микросекунд (представляется с помощью макроса G_USEC_PER_SEC). g_usleep() может иметь ограниченную точность, зависит от аппаратуры и операционной системы; не полагайтесь на точную длину паузы.

microseconds : количество микросекунд для паузы.

g_time_val_add ()

void        g_time_val_add                  (GTimeVal *time_,
                                             glong microseconds);

Добавляет полученное количество микросекунд к time_. microseconds может быть также отрицательным для уменьшения значения time_.

`time_` :	GTimeVal
`microseconds` :	количество микросекунд для добавления к `time`

g_time_val_from_iso8601 ()

gboolean    g_time_val_from_iso8601         (const gchar *iso_date,
                                             GTimeVal *time_);

Конвертирует строку содержащую код даты и времени ISO 8601 в GTimeVal и помещает её в time_.

`iso_date` :	строка кода даты ISO 8601
`time_` :	GTimeVal
Возвращает :	`TRUE` если конвертация прошла успешно.

Начиная с версии 2.12

g_time_val_to_iso8601 ()

gchar* g_time_val_to_iso8601 (GTimeVal *time_);

Конвертирует time_ в строку кода ISO 8601, относительно Coordinated Universal Time (UTC).

`time_` :	GTimeVal
Возвращает :	вновь распределённая строка содержащая дату ISO 8601

Начиная с версии 2.12

GDate

typedef struct {
  guint julian_days : 32; /* julian days representation - we use a
                           *  bitfield hoping that 64 bit platforms
                           *  will pack this whole struct in one big
                           *  int
                           */

  guint julian : 1;    /* julian is valid */
  guint dmy    : 1;    /* dmy is valid */

  /* DMY representation */
  guint day    : 6;
  guint month  : 4;
  guint year   : 16;
} GDate;

Представляет день между 1 Января 1 Года и и несколькими тысячами лет будущего. Ни к одному из членов не нужно обращаться непосредственно. Если GDate определена из g_date_new(), она будет безопасна для изменений, но недоступна и поэтому не безопасна для календарных расчётов. Если это объявить в стеке, он будет содержать мусор поэтому должен быть инициализирован с помощью g_date_clear(). g_date_clear() делает дату недопустимой но нормальной. Недопустимая дата не представляет день, она "пустая". Дата становится допустимой после того, как вы установите её в Юлианский день или день, месяц и год.

guint `julian_days` : 32;	Юлианское представление даты
guint `julian` : 1;	этот бит устанавливается если `julian_days` допустим
guint `dmy` : 1;	это устанавливается если `day`, `month` и `year` являются допустимыми
guint `day` : 6;	день в преставлении даты в виде день-месяц-год, как число между 1 и 31
guint `month` : 4;	месяц в представлении даты в виде день-месяц-год, как число между 1 и 12
guint `year` : 16;	год в представлении даты как день-месяц-год

GTime

typedef gint32  GTime;

Просто замена для time_t. Она устарела так как не является эквивалентом для time_t на 64-битных платформах с 64-битной time_t. Несвязана с GTimer.

Помните что GTime определяется всегда как 32bit целочисленное, в отличие от time_t которая может быть 64bit на некоторых системах. Поэтому, GTime переполнится в 2038 году, и вы не сможете использовать адрес переменной GTime как аргумент для UNIX функции time(). Вместо этого сделайте следующее:


time_t ttime;
GTime gtime;

time (&ttime);
gtime = (GTime)ttime;

enum GDateDMY

typedef enum
{
  G_DATE_DAY   = 0,
  G_DATE_MONTH = 1,
  G_DATE_YEAR  = 2
} GDateDMY;

Это перечисление не используется в API, но может быть полезно если вам необходимо маркировать номер как день, месяц, или год.

`G_DATE_DAY`	день
`G_DATE_MONTH`	месяц
`G_DATE_YEAR`	год

GDateDay

typedef guint8  GDateDay;   /* day of the month */

Целочисленное представляющее день в месяце; между 1 и 31. G_DATE_BAD_DAY представляет недопустимый день в месяце.

enum GDateMonth

typedef enum
{
  G_DATE_BAD_MONTH = 0,
  G_DATE_JANUARY   = 1,
  G_DATE_FEBRUARY  = 2,
  G_DATE_MARCH     = 3,
  G_DATE_APRIL     = 4,
  G_DATE_MAY       = 5,
  G_DATE_JUNE      = 6,
  G_DATE_JULY      = 7,
  G_DATE_AUGUST    = 8,
  G_DATE_SEPTEMBER = 9,
  G_DATE_OCTOBER   = 10,
  G_DATE_NOVEMBER  = 11,
  G_DATE_DECEMBER  = 12
} GDateMonth;

Перечисление представляющее месяц; значениями являются G_DATE_JANUARY, G_DATE_FEBRUARY, и т.д.. G_DATE_BAD_MONTH представляет недопустимое значение.

`G_DATE_BAD_MONTH`	недопустимое значение.
`G_DATE_JANUARY`	Январь (January).
`G_DATE_FEBRUARY`	Февраль (February).
`G_DATE_MARCH`	Март (March).
`G_DATE_APRIL`	Апрель (April).
`G_DATE_MAY`	Май (May).
`G_DATE_JUNE`	Июнь (June).
`G_DATE_JULY`	Июль (July).
`G_DATE_AUGUST`	Август (August).
`G_DATE_SEPTEMBER`	Сентябрь (September).
`G_DATE_OCTOBER`	Октябрь (October).
`G_DATE_NOVEMBER`	Ноябрь (November).
`G_DATE_DECEMBER`	Декабрь (December).

GDateYear

typedef guint16 GDateYear;

Целочисленное представляющее год; G_DATE_BAD_YEAR представляет недопустимое значение. Год должен быть 1 или больше; отрицательное значение недопустимо. Год представляется четырьмя цифрами.

enum GDateWeekday

typedef enum
{
  G_DATE_BAD_WEEKDAY  = 0,
  G_DATE_MONDAY       = 1,
  G_DATE_TUESDAY      = 2,
  G_DATE_WEDNESDAY    = 3,
  G_DATE_THURSDAY     = 4,
  G_DATE_FRIDAY       = 5,
  G_DATE_SATURDAY     = 6,
  G_DATE_SUNDAY       = 7
} GDateWeekday;

Перечисление представляющее день в неделе; G_DATE_MONDAY, G_DATE_TUESDAY, и т.д.. G_DATE_BAD_WEEKDAY недопустимый день недели.

`G_DATE_BAD_WEEKDAY`	недопустимое значение.
`G_DATE_MONDAY`	Понедельник (Monday).
`G_DATE_TUESDAY`	Вторник (Tuesday).
`G_DATE_WEDNESDAY`	Среда (Wednesday).
`G_DATE_THURSDAY`	Четверг (Thursday).
`G_DATE_FRIDAY`	Пятница (Friday).
`G_DATE_SATURDAY`	Суббота (Saturday).
`G_DATE_SUNDAY`	Воскресенье (Sunday).

G_DATE_BAD_DAY

#define G_DATE_BAD_DAY    0U

Представляет недопустимую GDateDay.

G_DATE_BAD_JULIAN

#define G_DATE_BAD_JULIAN 0U

Представляет недопустимый номер дня в Юлианском представлении.

G_DATE_BAD_YEAR

#define G_DATE_BAD_YEAR   0U

Представляет недопустимый год.

g_date_new ()

GDate* g_date_new (void);

Распределяет GDate и инициализирует её до нормального сотсояния. Новая дата будет очищена (как если бы вы вызвали g_date_clear()) но недопустима (она не будет представлять существующий день). Возвращаемое значение освобождается с помощью g_date_free().

Возвращает :

вновь распределённая GDate.

g_date_new_dmy ()

GDate*      g_date_new_dmy                  (GDateDay day,
                                             GDateMonth month,
                                             GDateYear year);

Аналогична g_date_new(), но также устанавливает значение даты. Допустим вы помещаете в тройку день-месяц-год существующий день, тогда возвращаемая дата будет допустимой.

`day` :	день месяца.
`month` :	месяц в году.
`year` :	год
Возвращает :	вновь распределённая GDate инициализированная с помощью `дня`, `месяца` и `года`.

g_date_new_julian ()

GDate* g_date_new_julian (guint32 julian_day);

Аналогична g_date_new(), но так же устанавливает значение даты. Допустим вы поместили допустимый Юлианский номер дня (больше чем 0, меньше чем разумно большое число), возвращаемая дата будет допустимой.

`julian_day` :	день начиная с 1 Января 1 Года (January 1, Year 1).
Возвращает :	вновь распределённая GDate инициализированная `julian_day`.

g_date_clear ()

void        g_date_clear                    (GDate *date,
                                             guint n_dates);

Инициализирует одну или больше структур GDate до нормального, но недопустимого состояния. Очищенные даты не будут представлять существующие даты, но не будут содержать мусор. Полезно для инициализации дат объявленных в стеке. Допустимость может быть проверена с помощью g_date_valid().

`date` :	указатель на одну или более дат для очистки.
`n_dates` :	количество дат для очистки.

g_date_free ()

void g_date_free (GDate *date);

Освобождает GDate возвращаемую из g_date_new().

date : GDate.

g_date_set_day ()

void        g_date_set_day                  (GDate *date,
                                             GDateDay day);

Устанавливает день месяца для GDate. Если результат тройки день-месяц-год недопустим, дата будет недопустимой.

`date` :	GDate.
`day` :	день для установки.

g_date_set_month ()

void        g_date_set_month                (GDate *date,
                                             GDateMonth month);

Устанавливает месяц в году для GDate. Если результат тройки день-месяц-год недопустим, дата будет недопустимой.

`date` :	GDate.
`month` :	месяц для установки.

g_date_set_year ()

void        g_date_set_year                 (GDate *date,
                                             GDateYear year);

Устанавливает год для GDate. Если результат тройки день-месяц-год недопустим, дата будет недопустимой.

`date` :	GDate.
`year` :	год для установки.

g_date_set_dmy ()

void        g_date_set_dmy                  (GDate *date,
                                             GDateDay day,
                                             GDateMonth month,
                                             GDateYear y);

Устанавливает значение GDate из дня, месяца и года. Тройка день-месяц-год должна быть допустимой; если вы не уверены в этом, вызовите g_date_valid_dmy() для проверки перед установкой.

`date` :	GDate.
`day` :	день.
`month` :	месяц.
`y` :	год.

g_date_set_julian ()

void        g_date_set_julian               (GDate *date,
                                             guint32 julian_date);

Устанавливает значение GDate от Юлианского номера дня.

`date` :	GDate.
`julian_date` :	Юлианский номер дня (день начиная с 1 Января 1 Года).

g_date_set_time ()

void        g_date_set_time                 (GDate *date,
                                             GTime time_);

Внимание

g_date_set_time устарела и не должна использоваться во вновь создаваемом коде.

Устанавливает значение даты из значения GTime.

Устаревшее:2.10: Вместо неё используйте g_date_set_time_t().

`date` :	GDate.
`time_` :	GTime значение для установки.

g_date_set_time_t ()

void        g_date_set_time_t               (GDate *date,
                                             time_t timet);

Устанавливает значение даты из значения time_t.

Для установки значения даты текущего дня, вы должны написать:

 
 g_date_set_time_t (date, time (NULL));

`date` :	GDate
`timet` :	time_t значение для установки

Начиная с версии 2.10

g_date_set_time_val ()

void        g_date_set_time_val             (GDate *date,
                                             GTimeVal *timeval);

Устанавливает значение даты из значения GTimeVal. Помните что tv_usec член игнорируется, потомучто GDate не может использовать дополнительную точность.

`date` :	GDate
`timeval` :	GTimeVal значение для установки

Начиная с версии 2.10

g_date_set_parse ()

void        g_date_set_parse                (GDate *date,
                                             const gchar *str);

Анализирует строку пользовательского ввода str, и пытается выяснить какую дату она представляет, принимая во внимание текущую локаль. Если строка полностью проанализирована, дата будет доступна после вызова. Иначе, она будет недоступна. С помощью g_date_valid() вы должны проверить выполнен ли анализ строки успешно.

Эта функция не является соответствующей для форматированных файлов и т.п.; она не очень точна и точность её поведения изменяется в зависимости от локали. Она предназначена для эвристической подпрограммы которая предполагает что пользователь подразумевает данной строкой (в этом смысле она работает вполне прилично).

`date` :	GDate для заполнения.
`str` :	строка для анализа.

g_date_add_days ()

void        g_date_add_days                 (GDate *date,
                                             guint n_days);

Увеличивает дату некоторым количеством дней. Для перемещения понедельно, добавьте weeks*7 days. Дата должна быть допустимой.

`date` :	GDate для увеличения.
`n_days` :	количество дней для перемещения даты вперёд.

g_date_subtract_days ()

void        g_date_subtract_days            (GDate *date,
                                             guint n_days);

Перемещение даты на некоторое количество дней в прошлое. Для понедельного перемещения, просто используйте weeks*7 days. Дата должна быть допустимой.

`date` :	GDate для уменьшения.
`n_days` :	количество дней для перемещения.

g_date_add_months ()

void        g_date_add_months               (GDate *date,
                                             guint n_months);

Увеличивает дату на некоторое количество месяцев. Если день месяца больше чем 28, эта подпрограмма может изменить день месяца (потомучто месяц назначения может не иметь такого текущего дня). Дата должна быть допустимой.

`date` :	GDate для увеличения.
`n_months` :	количество месяцев для перемещения вперёд.

g_date_subtract_months ()

void        g_date_subtract_months          (GDate *date,
                                             guint n_months);

Перемещает дату на некоторое количество месяцев в прошлое. Если текущий день месяца не существует в месяце назначения, день месяца может быть изменён. Дата должна быть допустимой.

`date` :	GDate для уменьшения.
`n_months` :	количество месяцев для перемещения.

g_date_add_years ()

void        g_date_add_years                (GDate *date,
                                             guint n_years);

Увеличивает дату некоторым количеством лет. Если датой является 29 Февраля, а год назначения не является високосным, дата будет изменена на 28 Февраля. Дата должна быть допустимой.

`date` :	GDate для увеличения.
`n_years` :	количество лет для перемещения вперёд.

g_date_subtract_years ()

void        g_date_subtract_years           (GDate *date,
                                             guint n_years);

Перемещает дату на некоторое число лет в прощлое. Если текущий день не существует в году назначения (то есть это 29 Февраля и вы перемещаетесь не в високосный год) то день изменяется на 28 Февраля. Дата должна быть допустимой.

`date` :	GDate для уменьшения.
`n_years` :	число лет для перемещения.

g_date_days_between ()

gint        g_date_days_between             (const GDate *date1,
                                             const GDate *date2);

Расчитывает число дней между двумя датами. Если date2 находится перед date1, возвращается негативное значение. Обе даты должны быть допустимыми.

`date1` :	первая дата.
`date2` :	вторая дата.
Возвращает :	количество дней между `date1` и `date2`.

g_date_compare ()

gint        g_date_compare                  (const GDate *lhs,
                                             const GDate *rhs);

qsort()-style функции для сравнения дат. Обе даты должны быть допустимыми.

`lhs` :	первая дата для сравнения.
`rhs` :	вторая дата для сравнения.
Возвращает :	0 если даты равны, меньше нуля если `lhs` меньше чем `rhs`, больше нуля если `lhs` больше чем `rhs`.

g_date_clamp ()

void        g_date_clamp                    (GDate *date,
                                             const GDate *min_date,
                                             const GDate *max_date);

Если date находится перед min_date, устанавливает date как эквивалент min_date. Если date расположена после max_date, устанавливает date как эквивалент max_date. Любой параметр min_date и max_date может быть NULL. Все не-NULL даты должны быть допустимыми.

`date` :	GDate для сопоставления.
`min_date` :	минимально применимое значение для `date`.
`max_date` :	максимально применимое значение для `date`.

g_date_order ()

void        g_date_order                    (GDate *date1,
                                             GDate *date2);

Проверяет меньше ли date1 или эквивалентна date2, и сбрасывает значение если это не так.

`date1` :	первая дата.
`date2` :	вторая дата.

g_date_get_day ()

GDateDay g_date_get_day (const GDate *date);

Возвращает день месяца. Дата должна быть допустимой.

`date` :	GDate для извлечения дня месяца.
Возвращает :	день месяца.

g_date_get_month ()

GDateMonth g_date_get_month (const GDate *date);

Возвращает месяц в году. Дата должна быть допустимой.

`date` :	GDate для извлечения месяца.
Возвращает :	месяц в году как GDateMonth.

g_date_get_year ()

GDateYear g_date_get_year (const GDate *date);

Возвращает год из GDate. Дата должна быть допустимой.

`date` :	GDate.
Возвращает :	год на который выпадает дата.

g_date_get_julian ()

guint32 g_date_get_julian (const GDate *date);

Возвращает Юлианский день или "серийный номер" из GDate. Юлианский день - это просто номер дня начиная с 1 Января 1 Года; то есть, 1 Января 1 Года является 1 Юлианским днём; 2 Января 2 Года является 2 Юлианским днём, и т.д.. Дата должна быть допустимой.

`date` :	GDate для извлечения Юлианского дня.
Возвращает :	Юлианский день.

g_date_get_weekday ()

GDateWeekday g_date_get_weekday (const GDate *date);

Возвращает день недели для GDate. Дата должна быть допустимой.

`date` :	GDate.
Возвращает :	день недели как GDateWeekday.

g_date_get_day_of_year ()

guint g_date_get_day_of_year (const GDate *date);

Возвращаемый день в году, где 1 Января является первым днём года. Дата должна быть допустимой.

`date` :	GDate для извлечения дня в году.
Возвращает :	день в году.

g_date_get_days_in_month ()

guint8      g_date_get_days_in_month        (GDateMonth month,
                                             GDateYear year);

Возвращает число дней в месяце, принимая во внимание високосные годы.

`month` :	месяц.
`year` :	год.
Возвращает :	количество дней в `month` в течении `year`.

g_date_is_first_of_month ()

gboolean g_date_is_first_of_month (const GDate *date);

Возвращает TRUE если дата является первым днём месяца. Дата должна быть допустимой.

`date` :	GDate для проверки.
Возвращает :	`TRUE` если дата является первым днём месяца.

g_date_is_last_of_month ()

gboolean g_date_is_last_of_month (const GDate *date);

Возвращает TRUE если дата является последним днём месяца. Дата должна быть допустимой.

`date` :	GDate для проверки.
Возвращает :	`TRUE` если дата является последним днём месяца.

g_date_is_leap_year ()

gboolean g_date_is_leap_year (GDateYear year);

Возвращает TRUE если год является високосным.

`year` :	год для проверки.
Возвращает :	`TRUE` если год високосный.

g_date_get_monday_week_of_year ()

guint g_date_get_monday_week_of_year (const GDate *date);

Возвращает неделю в году, где недели начинаются с понедельника. Если дата перед первым понедельником в году, возвращается 0. Дата должна быть допустимой.

`date` :	GDate.
Возвращает :	неделя в году.

g_date_get_monday_weeks_in_year ()

guint8 g_date_get_monday_weeks_in_year (GDateYear year);

Возвращает количество недель в году, где недели начинаются с понедельника. Будет либо 52 либо 53. Дата должна быть допустимой. (Года всегда имеют 52 периода по 7-дней, плюс 1 или 2 дополнительных дня в зависимости от того, является ли год високосным. Эта функция в основном сообщает сколько понедельников находится в году, то есть 53 понедельника будет если один из дополнительных дней окажется понедельником.)

`year` :	год.
Возвращает :	количество понедельников в году.

g_date_get_sunday_week_of_year ()

guint g_date_get_sunday_week_of_year (const GDate *date);

Возвращает неделю года на которую выпадает дата, если недели начинаются с воскресенья. Дата должна быть допустимой. Может вернуть 0 если день находится перед первым воскресеньем в году.

`date` :	GDate.
Возвращает :	номер недели.

g_date_get_sunday_weeks_in_year ()

guint8 g_date_get_sunday_weeks_in_year (GDateYear year);

Возвращает количество недель в году, где недели начинаются с воскресенья. Будет либо 52 либо 53. Дата должна быть допустимой. (Годы всегда имеют 52 периода по 7-дней, плюс 1 или 2 дополнительных дня в зависимости от того, является ли год високосным. Эта функция в основном сообщает вам сколько воскресений в году, то есть является ли 53 воскресенье дополнительным днём года.)

`year` :	год для подсчёта недель.
Возвращает :	количество недель.

g_date_get_iso8601_week_of_year ()

guint g_date_get_iso8601_week_of_year (const GDate *date);

Возвращает неделю года, где недели интерпретируются согласно ISO 8601.

`date` :	допустимая GDate
Возвращает :	ISO 8601 число недель в году.

Начиная с версии 2.6

g_date_strftime ()

gsize       g_date_strftime                 (gchar *s,
                                             gsize slen,
                                             const gchar *format,
                                             const GDate *date);

Генерирует печатное представление даты, локале-зависимым способом. Работает просто как платформенная C библиотечная функция strftime(), но принимает только дата-зависимые форматы; время-зависимые форматы выдают неопределённый результат. Дата должна быть допустимой. В отличие от strftime() (которая использует локальную кодировку), эта функция работает со строками в кодировке UTF-8 и сохраняет результат в кодировке UTF-8.

Эта функция не обеспечивает никаких дополнительных спецификаторов конвертирования для платформенной реализации библиотеки C. Например, не ждите что использование g_date_strftime() сделает F обеспечив C99 strftime() работая на Windows где библиотека C скомпилирована только для C89.

`s` :	буфер назначения.
`slen` :	размер буфера.
`format` :	строка формата.
`date` :	допустимая GDate.
Возвращает :	количество символов записанных в буфер, или 0 если буфер слишком маленький.

g_date_to_struct_tm ()

void        g_date_to_struct_tm             (const GDate *date,
                                             struct tm *tm);

Заполняет дата-зависимый бит в struct tm используя значение date. Инициализирует non-date пары с чем то нормальным но бессмысленным.

`date` :	GDate для установки struct tm.
`tm` :	struct tm для заполнения.

g_date_valid ()

gboolean g_date_valid (const GDate *date);

Возвращает TRUE если GDate представляет существующий день. Дата не должна содержать мусор; она должна быть инициализирована с помощью g_date_clear() если она не была распределена одним из вариантов g_date_new().

`date` :	GDate для проверки.
Возвращает :	является ли дата допустимой.

g_date_valid_day ()

gboolean g_date_valid_day (GDateDay day);

Возвращает TRUE если день месяца допустим (день допустим если он находится в промежутке чисел от 1 до 31 включительно).

`day` :	день для проверки.
Возвращает :	`TRUE` если день допустим.

g_date_valid_month ()

gboolean g_date_valid_month (GDateMonth month);

Возвращает TRUE если значение месяца допустимо. Только 12 значений в перечислении GDateMonth являются допустимыми.

`month` :	месяц.
Возвращает :	`TRUE` если месяц допустим.

g_date_valid_year ()

gboolean g_date_valid_year (GDateYear year);

Возвращает TRUE если год допустим. Допустимым является год только больше 0, однако есть 16-битный предел того что может понять GDate.

`year` :	год.
Возвращает :	`TRUE` если год допустим.

g_date_valid_dmy ()

gboolean    g_date_valid_dmy                (GDateDay day,
                                             GDateMonth month,
                                             GDateYear year);

Возвращает TRUE если форма триплёта день-месяц-год допустима, существует понятный день в диапазоне дней GDate (1 год или больше, но не больше нескольких тысяч лет в будущее).

`day` :	день.
`month` :	месяц.
`year` :	год.
Возвращает :	`TRUE` если дата допустима.

g_date_valid_julian ()

gboolean g_date_valid_julian (guint32 julian_date);

Возвращает TRUE ели Юлианский день допустим. Число больше нуля в основном является допустимым Юлианским днём, однако есть 32-битный предел.

`julian_date` :	Юлианский день для проверки.
Возвращает :	`TRUE` если Юлианский день допустим.

g_date_valid_weekday ()

gboolean g_date_valid_weekday (GDateWeekday weekday);

Возвращает TRUE если день недели допустим. Только 7 значений в перечислении GDateWeekday являются допустимыми.

`weekday` :	день недели.
Возвращает :	`TRUE` если день недели допустим.

			Справочное описание GLib
Начало \| Описание