| |
| /* |
| * File Name: consistent.c |
| * Purpose: Determines if either the two key or non-key values are |
| * consistent. Key values are consistent if the two |
| * hyper-cubes intersect. Non-key values are consistent if the |
| * first non-key character string completely constains the |
| * second non-key character string. |
| * |
| * Revision History: |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| #include <assert.h> /* for assert() */ |
| #include <string.h> /* for strstr() definition */ |
| #include "dataManagement.h" /* for primitive type definitions */ |
| #include "indexKey.h" /* for IndexKey definition */ |
| |
| /* |
| * |
| * Name: consistentKey |
| * Input: index key, A |
| * index key, B |
| * Output: flag indicating intersection |
| * Return: integer, TRUE or FALSE |
| * Description: Returns boolean value indicating if two input index keys |
| * intersect. The routine is communative, i.e., |
| * consistent(A,B) == consistent(B,A). |
| * Calls: |
| * System: |
| * Author: M.L.Rivas |
| * |
| * Revision History: |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| Boolean consistentKey( IndexKey *A, IndexKey *B ) |
| { /* beginning of consistentKey() */ |
| Boolean flag; /* flag indicating consistency */ |
| |
| assert( A ); |
| assert( B ); |
| |
| /* |
| * Check each dimension for intersection. If any dimension fails, then no |
| * intersection can occur, set flag and return. |
| */ |
| flag = TRUE; |
| if ( A->lower.T > B->upper.T || B->lower.T > A->upper.T ) { |
| flag = FALSE; |
| } /* end of bounds check on T */ |
| else { |
| if ( A->lower.X > B->upper.X || B->lower.X > A->upper.X ) { |
| flag = FALSE; |
| } /* end of bounds check on X */ |
| else { |
| if ( A->lower.Y > B->upper.Y || B->lower.Y > A->upper.Y ) { |
| flag = FALSE; |
| } /* end of bounds check on Y */ |
| else { |
| if ( A->lower.Z > B->upper.Z || B->lower.Z > A->upper.Z ) { |
| flag = FALSE; |
| } /* end of bounds check on Z */ |
| } /* end of check on Y */ |
| } /* end of check on X */ |
| } /* end of check on T */ |
| |
| return ( flag ); |
| } /* end of consistentKey() */ |
| |
| /* |
| * |
| * Name: consistentNonKey |
| * Input: character string, A |
| * character string, B |
| * Output: flag indicating intersection |
| * Return: integer, TRUE or FALSE |
| * Description: Returns boolean value indicating if two input character |
| * strings are consistent. The check is true if string A |
| * entirely contains string B. The routine is NOT communative, |
| * i.e., consistent(A,B) != consistent(B,A) in general. |
| * Calls: |
| * System: strstr() |
| * Author: M.L.Rivas |
| * |
| * Revision History: |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| Boolean consistentNonKey( Char *A, Char *B ) |
| { /* beginning of consistentNonKey() */ |
| Boolean flag; /* flag indicating consistency */ |
| |
| assert( A ); |
| assert( B ); |
| |
| /* |
| * Check for string B inside string A using library |
| * routine. |
| */ |
| if ( strstr( A, B ) != NULL ) { |
| flag = TRUE; |
| } /* end of if strstr != NULL */ |
| else { |
| flag = FALSE; |
| } /* end of if strstr == NULL */ |
| |
| return ( flag ); |
| } /* end of consistentNonKey() */ |
