parameter.h File Reference

Store attributes associated with a MIME part. More...

#include <stdbool.h>
#include "mutt/lib.h"

Include dependency graph for parameter.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Parameter
	Attribute associated with a MIME part. More...

Functions
	TAILQ_HEAD (ParameterList, Parameter)
bool	mutt_param_cmp_strict (const struct ParameterList *pl1, const struct ParameterList *pl2)
	Strictly compare two ParameterLists.
void	mutt_param_delete (struct ParameterList *pl, const char *attribute)
	Delete a matching Parameter.
void	mutt_param_free (struct ParameterList *pl)
	Free a ParameterList.
void	mutt_param_free_one (struct Parameter **pl)
	Free a Parameter.
char *	mutt_param_get (const struct ParameterList *pl, const char *s)
	Find a matching Parameter.
struct Parameter *	mutt_param_new (void)
	Create a new Parameter.
void	mutt_param_set (struct ParameterList *pl, const char *attribute, const char *value)
	Set a Parameter.

Detailed Description

Store attributes associated with a MIME part.

Authors

• Richard Russon

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 parameter.h.

Function Documentation

TAILQ_HEAD()

TAILQ_HEAD	(	ParameterList	,
		Parameter
	)

mutt_param_cmp_strict()

bool mutt_param_cmp_strict	(	const struct ParameterList *	pl1,
		const struct ParameterList *	pl2
	)

Strictly compare two ParameterLists.

Parameters

pl1	First parameter
pl2	Second parameter

Return values

true	Parameters are strictly identical

Definition at line 166 of file parameter.c.

{
  if (!pl1 && !pl2)
    return false;
 
  if ((pl1 == NULL) ^ (pl2 == NULL))
    return true;
 
  struct Parameter *np1 = TAILQ_FIRST(pl1);
  struct Parameter *np2 = TAILQ_FIRST(pl2);
 
  while (np1 && np2)
  {
    if (!mutt_str_equal(np1->attribute, np2->attribute) ||
        !mutt_str_equal(np1->value, np2->value))
    {
      return false;
    }
 
    np1 = TAILQ_NEXT(np1, entries);
    np2 = TAILQ_NEXT(np2, entries);
  }
 
  if (np1 || np2)
    return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_param_delete()

void mutt_param_delete	(	struct ParameterList *	pl,
		const char *	attribute
	)

Delete a matching Parameter.

Parameters

[in]	pl	ParameterList
[in]	attribute	Attribute to match

Definition at line 143 of file parameter.c.

{
  if (!pl)
    return;
 
  struct Parameter *np = NULL;
  TAILQ_FOREACH(np, pl, entries)
  {
    if (mutt_istr_equal(attribute, np->attribute))
    {
      TAILQ_REMOVE(pl, np, entries);
      mutt_param_free_one(&np);
      return;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_param_free()

void mutt_param_free

(

struct ParameterList *

pl

)

Free a ParameterList.

Parameters

pl	ParameterList to free

Definition at line 62 of file parameter.c.

{
  if (!pl)
    return;
 
  struct Parameter *np = TAILQ_FIRST(pl);
  struct Parameter *next = NULL;
  while (np)
  {
    next = TAILQ_NEXT(np, entries);
    mutt_param_free_one(&np);
    np = next;
  }
  TAILQ_INIT(pl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_param_free_one()

void mutt_param_free_one

(

struct Parameter **

p

)

Free a Parameter.

Parameters

[out]

p

Parameter to free

Definition at line 49 of file parameter.c.

{
  if (!p || !*p)
    return;
  FREE(&(*p)->attribute);
  FREE(&(*p)->value);
  FREE(p);
}

Here is the caller graph for this function:

mutt_param_get()

char * mutt_param_get	(	const struct ParameterList *	pl,
		const char *	s
	)

Find a matching Parameter.

Parameters

pl	ParameterList
s	String to match

Return values

ptr	Matching Parameter
NULL	No match

Definition at line 85 of file parameter.c.

{
  if (!pl)
    return NULL;
 
  struct Parameter *np = NULL;
  TAILQ_FOREACH(np, pl, entries)
  {
    if (mutt_istr_equal(s, np->attribute))
      return np->value;
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_param_new()

struct Parameter * mutt_param_new

(

void

)

Create a new Parameter.

Return values

ptr	Newly allocated Parameter

Definition at line 40 of file parameter.c.

{
  return mutt_mem_calloc(1, sizeof(struct Parameter));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_param_set()

void mutt_param_set	(	struct ParameterList *	pl,
		const char *	attribute,
		const char *	value
	)

Set a Parameter.

Parameters

[in]	pl	ParameterList
[in]	attribute	Attribute to match
[in]	value	Value to set

Note

If value is NULL, the Parameter will be deleted

If a matching Parameter isn't found a new one will be allocated. The new Parameter will be inserted at the front of the list.

Definition at line 111 of file parameter.c.

{
  if (!pl)
    return;
 
  if (!value)
  {
    mutt_param_delete(pl, attribute);
    return;
  }
 
  struct Parameter *np = NULL;
  TAILQ_FOREACH(np, pl, entries)
  {
    if (mutt_istr_equal(attribute, np->attribute))
    {
      mutt_str_replace(&np->value, value);
      return;
    }
  }
 
  np = mutt_param_new();
  np->attribute = mutt_str_dup(attribute);
  np->value = mutt_str_dup(value);
  TAILQ_INSERT_HEAD(pl, np, entries);
}

Here is the call graph for this function:

Here is the caller graph for this function: