node_conddate.c File Reference

Expando Node for a Conditional Date. More...

#include "config.h"
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "mutt/lib.h"
#include "node_conddate.h"
#include "helpers.h"
#include "node.h"
#include "parse.h"
#include "render.h"

Include dependency graph for node_conddate.c:

Go to the source code of this file.

Functions
struct NodeCondDatePrivate *	node_conddate_private_new (int count, char period)
	Create new CondDate private data.
void	node_conddate_private_free (void **ptr)
	Free CondDate private data - Implements ExpandoNode::ndata_free().
time_t	cutoff_number (char period, int count)
	Calculate the cutoff time for n units.
time_t	cutoff_this (char period)
	Calculate the cutoff time of this unit.
int	node_conddate_render (const struct ExpandoNode *node, const struct ExpandoRenderCallback *erc, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render a CondDate Node - Implements ExpandoNode::render() -.
struct ExpandoNode *	node_conddate_new (int count, char period, int did, int uid)
	Create a new CondDate ExpandoNode.
struct ExpandoNode *	node_conddate_parse (const char *str, int did, int uid, const char **parsed_until, struct ExpandoParseError *err)
	Parse a CondDate format string.

Detailed Description

Expando Node for a Conditional Date.

Authors

• Tóth János
• Richard Russon
• Thomas Klausner

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file node_conddate.c.

Function Documentation

node_conddate_private_new()

struct NodeCondDatePrivate * node_conddate_private_new	(	int	count,
		char	period )

Create new CondDate private data.

Parameters

count	Number of 'units' to count
period	Units, e.g. 'd' Day or 'm' Month

Return values

ptr	New CondDate private data

Definition at line 49 of file node_conddate.c.

{
  struct NodeCondDatePrivate *priv = MUTT_MEM_CALLOC(1, struct NodeCondDatePrivate);
 
  priv->count = count;
  priv->period = period;
 
  return priv;
}

Here is the caller graph for this function:

node_conddate_private_free()

void node_conddate_private_free

(

void **

ptr

)

Free CondDate private data - Implements ExpandoNode::ndata_free().

Parameters

ptr	Data to free

Definition at line 63 of file node_conddate.c.

{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}

Here is the caller graph for this function:

cutoff_number()

time_t cutoff_number	(	char	period,
		int	count )

Calculate the cutoff time for n units.

Parameters

period	Time period, from [ymwdHM]
count	Number of time periods

Return values

num	Cutoff time

Calculate the cutoff time for, say, 3 months, or 2 hours.

Definition at line 79 of file node_conddate.c.

{
  time_t t = mutt_date_now();
  struct tm tm = { 0 };
  localtime_r(&t, &tm);
 
  switch (period)
  {
    case 'y':
      tm.tm_year -= count;
      break;
 
    case 'm':
      tm.tm_mon -= count;
      break;
 
    case 'w':
      tm.tm_mday -= (7 * count);
      break;
 
    case 'd':
      tm.tm_mday -= count;
      break;
 
    case 'H':
      tm.tm_hour -= count;
      break;
 
    case 'M':
      tm.tm_min -= count;
      break;
 
    default:
      break;
  }
 
  return mktime(&tm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cutoff_this()

time_t cutoff_this

(

char

period

)

Calculate the cutoff time of this unit.

Parameters

period

Time period, from [ymwdHM]

Return values

num	Cutoff time

Calculate the cutoff time of, say, this day (today), this month.

Definition at line 125 of file node_conddate.c.

{
  time_t t = mutt_date_now();
  struct tm tm = { 0 };
  localtime_r(&t, &tm);
 
  switch (period)
  {
    case 'y':
      tm.tm_mon = 0; // January
      FALLTHROUGH;
 
    case 'm':
      tm.tm_mday = 1; // 1st of the month
      FALLTHROUGH;
 
    case 'd':
      tm.tm_hour = 0; // Beginning of day (Midnight)
      FALLTHROUGH;
 
    case 'H':
      tm.tm_min = 0; // Beginning of hour
      FALLTHROUGH;
 
    case 'M':
      tm.tm_sec = 0; // Beginning of minute
      break;
 
    case 'w':
      tm.tm_hour = 0; // Beginning of day (Midnight)
      tm.tm_min = 0;  // Beginning of hour
      tm.tm_sec = 0;  // Beginning of minute
      int bow = 0;    // Beginning of week
      if (tm.tm_wday == 0)
        bow = 6; // LCOV_EXCL_LINE
      else
        bow = tm.tm_wday - 1; // LCOV_EXCL_LINE
      tm.tm_mday -= bow;
      break;
 
    default:
      break;
  }
 
  return mktime(&tm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_conddate_new()

struct ExpandoNode * node_conddate_new	(	int	count,
		char	period,
		int	did,
		int	uid )

Create a new CondDate ExpandoNode.

Parameters

count	Number of 'units' to count
period	Units, e.g. 'd' Day or 'm' Month
did	Domain ID
uid	Unique ID

Return values

ptr	New CondDate ExpandoNode

Definition at line 205 of file node_conddate.c.

{
  struct ExpandoNode *node = node_new();
  node->type = ENT_CONDDATE;
  node->did = did;
  node->uid = uid;
  node->render = node_conddate_render;
 
  node->ndata = node_conddate_private_new(count, period);
  node->ndata_free = node_conddate_private_free;
 
  return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_conddate_parse()

struct ExpandoNode * node_conddate_parse	(	const char *	str,
		int	did,
		int	uid,
		const char **	parsed_until,
		struct ExpandoParseError *	err )

Parse a CondDate format string.

Parameters

[in]	str	String to parse
[in]	did	Domain ID
[in]	uid	Unique ID
[out]	parsed_until	First character after parsed string
[out]	err	Buffer for errors

Definition at line 227 of file node_conddate.c.

{
  if (!str || (str[0] == '\0') || !parsed_until || !err)
    return NULL;
 
  int count = 0;
  char period = '\0';
 
  str++;
 
  if (mutt_isdigit(*str))
  {
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(str, &number);
 
    // NOTE(g0mb4): str is NOT NUL-terminated
    if (!end_ptr || (number == USHRT_MAX))
    {
      err->position = str;
      snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), str);
      return NULL;
    }
 
    count = number;
    str = end_ptr;
  };
 
  // Allowed periods: year, month, week, day, hour, minute
  if (!strchr("ymwdHM", *str))
  {
    err->position = str;
    snprintf(err->message, sizeof(err->message),
             // L10N: The 'ymwdHM' should not be translated
             _("Invalid time period: '%c', must be one of 'ymwdHM'"), *str);
    return NULL;
  }
 
  period = *str;
  *parsed_until = str + 1;
 
  return node_conddate_new(count, period, did, uid);
}

Here is the call graph for this function:

Here is the caller graph for this function: