processing.h

Go to the documentation of this file.

/*
 * XetPan: a libEtPan! based Mail User Agent
 * Copyright (C) 2002 Melvin Hadasht
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef PROCESSING_H
#define PROCESSING_H

#include <chash.h>

#include "cntree.h"

typedef struct XePProcessing_s XePProcessing;
struct XePProcessing_s
{
  chash *rules;        
  chash *conditions;   
  chash *actions;      
};

typedef struct XePProcessingCondition_s XePProcessingCondition;
struct XePProcessingCondition_s
{
  char *id;          
  char *expression;  
  int enabled;       
};

typedef struct XePProcessingAction_s XePProcessingAction;
struct XePProcessingAction_s
{
  char *id;      
  char *command; 
  int enabled;   
};

typedef struct XePProcessingRule_s XePProcessingRule;
struct XePProcessingRule_s
{
  char *id;                          
  XePProcessingCondition *condition; 
  XePProcessingAction *action;       
  char *condition_ref;               
  char *action_ref;                  
  int enabled;                       
};

/*< Used to reference a rule (real folder) or a condition (virtual folder) */
typedef struct XePProcessingRef_s XePProcessingRef;
struct XePProcessingRef_s
{
  char *ref;
  int enabled; 
  int periodicity;
};


XePProcessing *
a_Processing_new(void);

XePProcessingCondition *
a_Processing_condition_new(void);

XePProcessingAction *
a_Processing_action_new(void);

XePProcessingRule *
a_Processing_rule_new(void);

XePProcessingRef *
a_Processing_ref_new(void);

XePProcessingRef *
a_Processing_ref_new_copy(XePProcessingRef *ref);

void
a_Processing_free(XePProcessing *processing);

void
a_Processing_condition_free(XePProcessingCondition *condition);

void
a_Processing_action_free(XePProcessingAction *action);

void
a_Processing_rule_free(XePProcessingRule *action);

void
a_Processing_ref_free(XePProcessingRef *ref);

clist *
a_Processing_ref_list_new(void);

void
a_Processing_ref_list_free(clist *refs);

int
a_Processing_ref_list_copy(clist *source, clist *target);

int
a_Processing_condition_add(XePProcessing *processing,
                           XePProcessingCondition *condition);

int
a_Processing_action_add(XePProcessing *processing,
                        XePProcessingAction *action);
int
a_Processing_rule_add(XePProcessing *processing,
                      XePProcessingRule *rule);

int
a_Processing_create(cntree *ntree, XePProcessing **processing, int op);

int
a_Processing_update_rules_links(XePProcessing *processing);

XePProcessingRule *
a_Processing_rule_get_from_ref(chash *rules, char *ref);

XePProcessingCondition *
a_Processing_condition_get_from_ref(chash *conditions, char *ref);

#endif

---