icalrecur.h

Go to the documentation of this file.

/*======================================================================
 FILE: icalrecur.h
 CREATOR: eric 20 March 2000
 
 SPDX-FileCopyrightText: 2000, Eric Busboom <eric@civicknowledge.com>
 SPDX-License-Identifier: LGPL-2.1-only OR MPL-2.0
========================================================================*/

 
#ifndef ICALRECUR_H
#define ICALRECUR_H
 
#include "libical_ical_export.h"
#include "icalarray.h"
#include "icaltime.h"
 
#include <stdbool.h>
 
/*
 * Recurrence enumerations
 */
 
typedef enum icalrecurrencetype_frequency
{
    /* These enums are used to index an array, so don't change the
       order or the integers */
 
    ICAL_SECONDLY_RECURRENCE = 0,
    ICAL_MINUTELY_RECURRENCE = 1,
    ICAL_HOURLY_RECURRENCE = 2,
    ICAL_DAILY_RECURRENCE = 3,
    ICAL_WEEKLY_RECURRENCE = 4,
    ICAL_MONTHLY_RECURRENCE = 5,
    ICAL_YEARLY_RECURRENCE = 6,
    ICAL_NO_RECURRENCE = 7
} icalrecurrencetype_frequency;
 
typedef enum icalrecurrencetype_weekday
{
    ICAL_NO_WEEKDAY,
    ICAL_SUNDAY_WEEKDAY,
    ICAL_MONDAY_WEEKDAY,
    ICAL_TUESDAY_WEEKDAY,
    ICAL_WEDNESDAY_WEEKDAY,
    ICAL_THURSDAY_WEEKDAY,
    ICAL_FRIDAY_WEEKDAY,
    ICAL_SATURDAY_WEEKDAY
} icalrecurrencetype_weekday;
 
typedef enum icalrecurrencetype_skip
{
    ICAL_SKIP_BACKWARD = 0,
    ICAL_SKIP_FORWARD,
    ICAL_SKIP_OMIT,
    ICAL_SKIP_UNDEFINED
} icalrecurrencetype_skip;
 
typedef enum icalrecurrencetype_byrule
{
    ICAL_BYRULE_NO_CONTRACTION = -1,
    ICAL_BY_MONTH = 0,
    ICAL_BY_WEEK_NO = 1,
    ICAL_BY_YEAR_DAY = 2,
    ICAL_BY_MONTH_DAY = 3,
    ICAL_BY_DAY = 4,
    ICAL_BY_HOUR = 5,
    ICAL_BY_MINUTE = 6,
    ICAL_BY_SECOND = 7,
    ICAL_BY_SET_POS = 8,
 
    ICAL_BY_NUM_PARTS = 9
} icalrecurrencetype_byrule;
 
/*
 * Recurrence enumerations conversion routines.
 */
 
LIBICAL_ICAL_EXPORT icalrecurrencetype_frequency icalrecur_string_to_freq(const char *str);
LIBICAL_ICAL_EXPORT const char *icalrecur_freq_to_string(icalrecurrencetype_frequency kind);
 
LIBICAL_ICAL_EXPORT icalrecurrencetype_skip icalrecur_string_to_skip(const char *str);
LIBICAL_ICAL_EXPORT const char *icalrecur_skip_to_string(icalrecurrencetype_skip kind);
 
LIBICAL_ICAL_EXPORT const char *icalrecur_weekday_to_string(icalrecurrencetype_weekday kind);
LIBICAL_ICAL_EXPORT icalrecurrencetype_weekday icalrecur_string_to_weekday(const char *str);

 
/* See RFC 5545 Section 3.3.10, RECUR Value, and RFC 7529
 * for an explanation of the values and fields in struct icalrecurrencetype.
 *
 * The maximums below are based on lunisolar leap years (13 months)
 */
#define ICAL_BY_SECOND_SIZE 62                               /* 0 to 60 */
#define ICAL_BY_MINUTE_SIZE 61                               /* 0 to 59 */
#define ICAL_BY_HOUR_SIZE 25                                 /* 0 to 23 */
#define ICAL_BY_MONTH_SIZE 14                                /* 1 to 13 */
#define ICAL_BY_MONTHDAY_SIZE 32                             /* 1 to 31 */
#define ICAL_BY_WEEKNO_SIZE 56                               /* 1 to 55 */
#define ICAL_BY_YEARDAY_SIZE 386                             /* 1 to 385 */
#define ICAL_BY_SETPOS_SIZE ICAL_BY_YEARDAY_SIZE             /* 1 to N */
#define ICAL_BY_DAY_SIZE (7 * (ICAL_BY_WEEKNO_SIZE - 1) + 1) /* 1 to N */
 
typedef struct
{
    short *data;
    short size;
} icalrecurrence_by_data;

struct icalrecurrencetype {
    /* Reference count */
    int refcount;
 
    icalrecurrencetype_frequency freq;
 
    /* until and count are mutually exclusive. */
    struct icaltimetype until;
    int count;
 
    short interval;
 
    icalrecurrencetype_weekday week_start;

    icalrecurrence_by_data by[ICAL_BY_NUM_PARTS];
 
    /* For RSCALE extension (RFC 7529) */
    char *rscale;
    icalrecurrencetype_skip skip;
};

LIBICAL_ICAL_EXPORT struct icalrecurrencetype *icalrecurrencetype_new(void);

LIBICAL_ICAL_EXPORT void icalrecurrencetype_ref(struct icalrecurrencetype *recur);

LIBICAL_ICAL_EXPORT void icalrecurrencetype_unref(struct icalrecurrencetype *recur);
 
LIBICAL_ICAL_EXPORT icalarray *icalrecurrencetype_rscale_supported_calendars(void);

LIBICAL_ICAL_EXPORT struct icalrecurrencetype *icalrecurrencetype_clone(struct icalrecurrencetype *r);

LIBICAL_ICAL_EXPORT bool icalrecur_resize_by(icalrecurrence_by_data *by, short size);
 
/*
 * Routines to decode the day values of the by[ICAL_BY_DAY] array
 */

LIBICAL_ICAL_EXPORT enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day);

LIBICAL_ICAL_EXPORT int icalrecurrencetype_day_position(short day);

LIBICAL_ICAL_EXPORT short icalrecurrencetype_encode_day(enum icalrecurrencetype_weekday weekday,
                                                        int position);
 
/*
 * Routines to decode the 'month' element of the by[ICAL_BY_MONTH] array
 */

LIBICAL_ICAL_EXPORT bool icalrecurrencetype_month_is_leap(short month);
 
LIBICAL_ICAL_EXPORT int icalrecurrencetype_month_month(short month);

LIBICAL_ICAL_EXPORT short icalrecurrencetype_encode_month(int month, bool is_leap);
 
/*
 * Recurrence rule parser
 */

LIBICAL_ICAL_EXPORT struct icalrecurrencetype *icalrecurrencetype_new_from_string(const char *str);
 
LIBICAL_ICAL_EXPORT char *icalrecurrencetype_as_string(struct icalrecurrencetype *recur);
 
LIBICAL_ICAL_EXPORT char *icalrecurrencetype_as_string_r(struct icalrecurrencetype *recur);
 
/*
 * Recurrence iteration routines
 */
 
typedef struct icalrecur_iterator_impl icalrecur_iterator;

LIBICAL_ICAL_EXPORT icalrecur_iterator *icalrecur_iterator_new(struct icalrecurrencetype *rule,
                                                               struct icaltimetype dtstart);

LIBICAL_ICAL_EXPORT bool icalrecur_iterator_set_start(icalrecur_iterator *impl,
                                                      struct icaltimetype start);

LIBICAL_ICAL_EXPORT bool icalrecur_iterator_set_end(icalrecur_iterator *impl,
                                                    struct icaltimetype end);

LIBICAL_ICAL_EXPORT bool icalrecur_iterator_set_range(icalrecur_iterator *impl,
                                                      struct icaltimetype from,
                                                      struct icaltimetype to);

LIBICAL_ICAL_EXPORT struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *);

LIBICAL_ICAL_EXPORT struct icaltimetype icalrecur_iterator_prev(icalrecur_iterator *);

LIBICAL_ICAL_EXPORT void icalrecur_iterator_free(icalrecur_iterator *);

LIBICAL_ICAL_EXPORT bool icalrecur_expand_recurrence(const char *rule, icaltime_t start,
                                                     int count, icaltime_t *array);
 
/* ical_invalid_rrule_handling :
 *    How should the ICAL library handle RRULEs with invalid BYxxx part combos?
 */
typedef enum ical_invalid_rrule_handling
{
    ICAL_RRULE_TREAT_AS_ERROR = 0,
    ICAL_RRULE_IGNORE_INVALID = 1
} ical_invalid_rrule_handling;
 
LIBICAL_ICAL_EXPORT ical_invalid_rrule_handling ical_get_invalid_rrule_handling_setting(void);
 
LIBICAL_ICAL_EXPORT void ical_set_invalid_rrule_handling_setting(
    ical_invalid_rrule_handling newSetting);
 
#endif /* ICALRECUR_H */