validationrule.h

Go to the documentation of this file.

/*==================================================================================================
                    Copyright (c) 2003,2006 Unigraphics Solutions Inc.
                             Unpublished - All rights reserved
====================================================================================================*/
/*  */

#ifndef VALIDATIONRULE_H
#define VALIDATIONRULE_H

#include <tc/tc_startup.h>
#include <validation/libvalidation_exports.h>

typedef struct validation_expression_s {
    char        *name;          
    char        op;             
    char        *value;         
    char        *value_from_log;
} validation_expression_t;

typedef struct validation_events_s {
    char        *class_clause;    
    char        **values;         
    int         num_values; 
    logical     exclude;          
} validation_events_t;

typedef enum validation_run_status_e {
    up_to_date,
    out_of_date,
    out_Of_Date_RequirementChanged,
    verify_parameter_failed,
    missing_report_log,
    not_run,
    not_required
} validation_run_status_t;

typedef struct validation_rule_s {
    tag_t           checker_obj;         
    char            *checker_name;       
    char            **dataset_types;     
    logical         required;            
    validation_expression_t *attributes; 
    validation_expression_t *parameters; 
    validation_events_t    *events;      
    int              num_dataset_types;
    int              num_attrs;
    int              num_paras;
    
} validation_rule_t;

typedef struct  candidate_validation_result_s {
    validation_run_status_t status;
    tag_t                   nx_dataset;   
    tag_t                   result;       
    validation_rule_t       *rule;        
    logical                 check_passed; 
} candidate_validation_result_t;

typedef enum VALIDATIONRULE_parameter_operation_e {
            VALIDATIONRULE_operation_equal = 0,
            VALIDATIONRULE_operation_regular_exp,
            VALIDATIONRULE_operation_not_equal,
            VALIDATIONRULE_operation_less_than,
            VALIDATIONRULE_operation_lessthan_or_euqal,
            VALIDATIONRULE_operation_greater_than,
            VALIDATIONRULE_operation_greaterthan_or_equal,
            VALIDATIONRULE_operation_begins,
            VALIDATIONRULE_operation_contains
}VALIDATIONRULE_parameter_operation_t;

typedef struct VALIDATIONRULE_parameter_s {
    char        *name;                       
    VALIDATIONRULE_parameter_operation_t op; 
    char        *value;                      
    char        *value_from_log;             
} VALIDATIONRULE_parameter_t;

/*
    Validation Target structrue defines the available target types for one rule. 
    Any business object could be a validation target, at the meantime, it is able to limit to
    several sub typs of the specified target type.
*/
typedef struct VALIDATIONRULE_target_s {
    char            *target_type;   /*The target type, could be any POM object, like Dataset, ItemRevision and BOMLine*/
    char           **targets;       /*The sub types of specified target type, like UGMaster, UGPart*/
    int              num_targets;   /*The number of sub types*/
} VALIDATIONRULE_target_t, *VALIDATIONRULE_target_p_t;

typedef struct VALIDATIONRULE_event_s {
    char        *class_clause;    
    char        *application;     
    char        *apply_to;        
    logical      exclude;         
    char       **values;          
    int          num_values;      
} VALIDATIONRULE_event_t;

typedef struct VALIDATIONRULE_rule_s {
    tag_t            checker_obj;            
    char            *checker_name;           
    char            *checker_version;        
    logical          required;               
    VALIDATIONRULE_target_t     *target;     
    VALIDATIONRULE_parameter_t  *attributes; 
    VALIDATIONRULE_parameter_t  *parameters; 
    VALIDATIONRULE_event_t      *events;     
    int              num_events;
    int              num_attrs;
    int              num_paras;
    
} VALIDATIONRULE_rule_t;

/*
    Validation rule set structure.
*/
typedef struct VALIDATIONRULE_rule_set_s {
    char                       *name;       /*The rule set name, TODO:Consider localization*/
    int                         num_rules;  /*The number of rules*/
    VALIDATIONRULE_rule_t      *rules;      /*The validation rule list*/
} VALIDATIONRULE_rule_set_t, *VALIDATIONRULE_rule_set_p_t;

typedef struct  VALIDATIONRULE_candidate_result_s {
    validation_run_status_t status;
    tag_t                   target_obj;   
    tag_t                   result;       
    VALIDATIONRULE_rule_t  *rule;         
    logical                 check_passed; 
} VALIDATIONRULE_candidate_result_t;

#ifdef __cplusplus
extern "C"{
#endif

extern VALIDATION_API int VALIDATIONRULE_get_rules ( 
                  char* rule_item_revision,     
                  char* validation_rule_set,    
                  char* current_event,          
                  validation_rule_t **rules,    
                  int               *num        
                  );

extern VALIDATION_API int VALIDATIONRULE_get_candidate_results(
                  tag_t*    target_obj,                             
                  int       num_target,                             
                  validation_rule_t *rules,                         
                  int       num_rules,                              
                  candidate_validation_result_t **candidates,       
                  int       *num_candidates                         
                  );

extern VALIDATION_API int VALIDATIONRULE_verify_result(
                  candidate_validation_result_t *candidate          
                  );

extern VALIDATION_API void VALIDATIONRULE_free_rules(
                  validation_rule_t *rules,
                  int       num_rules
                  );

extern VALIDATION_API void VALIDATIONRULE_free_results(
                  candidate_validation_result_t *candidates,
                  int       num_candidates
                  );

extern VALIDATION_API int VALIDATIONRULE_check_results(
                  tag_t*    target_obj,       
                  int       num_target,       
                  char* rule_item_revision,   
                  char* validation_rule_set,  
                  char* current_event         
                  );

extern VALIDATION_API int VALIDATIONRULE_get_rules2 ( 
                  tag_t rule_revision,          
                  char* validation_rule_set,    
                  char* current_event,          
                  validation_rule_t **rules,    
                  int               *num        
                  );

extern VALIDATION_API int VALIDATIONRULE_get_rules3 ( 
                  char* rule_item_revision,      
                  char* validation_rule_set,     
                  char* current_event,           
                  VALIDATIONRULE_rule_t **rules, 
                  int               *num         
                  );

extern VALIDATION_API int VALIDATIONRULE_get_rules4 ( 
                  tag_t rule_revision,           
                  char* validation_rule_set,     
                  char* current_event,           
                  VALIDATIONRULE_rule_t **rules, 
                  int               *num         
                  );

extern VALIDATION_API int VALIDATIONRULE_get_candidate_results2(
                  tag_t*    target_obj,                             
                  int       num_target,                             
                  VALIDATIONRULE_rule_t *rules,                     
                  int       num_rules,                              
                  VALIDATIONRULE_candidate_result_t **candidates,   
                  int       *num_candidates                         
                  );

extern VALIDATION_API int VALIDATIONRULE_verify_result2(
                  VALIDATIONRULE_candidate_result_t *candidate          
                  );

extern VALIDATION_API void VALIDATIONRULE_free_rules2(
                  VALIDATIONRULE_rule_t *rules,
                  int       num_rules
                  );

extern VALIDATION_API void VALIDATIONRULE_free_results2(
                  VALIDATIONRULE_candidate_result_t *candidates,
                  int       num_candidates
                  );

#ifdef __cplusplus
}
#endif

#include <validation/libvalidation_undef.h>

#endif