Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

GATPreferences.c Go to the documentation of this file. /** @file GATPreferences.c * Main file for the GATPreferences class. * * A GATPreferences instance represents the user's preferences for * selecting adaptors. Currently this class is a place holder for the user * preferences, the structure of which is in development. * * @date Tue Sep 2 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATPreferences.c,v 1.28 2004/05/10 15:17:32 hartmutkaiser Exp $ * * Copyright (C) Tom Goodale * This file is part of the GAT Engine. * Contributed by Tom Goodale <goodale@aei.mpg.de>. * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATPreferences.c,v 1.28 2004/05/10 15:17:32 hartmutkaiser Exp $"; /* System Header Files */ #include <stdlib.h> #include <strings.h> /* GAT Header Files */ #include "GATType.h" #include "GATTable.h" #include "GATErrors.h" #include "GATInternal.h" #include "regex.h" #include "GATPreferences.h" /* Macros */ /* Structures, unions and enums */ /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATPreferences); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATPreferences); struct GATPreferences_S { GATPreferences_vtable *__vtable; GATTable table; }; /* Static function prototypes */ /* * This function determines if the two NULL terminated * arrays of strings are equivalent as sets. For the * two arrays to be equivalent as sets each string * in the first set must appear in the second set * and each string in the second set must appear * in the first. Equivalence between strings is * determined using strcmp. * * @return 1 if equal 0 otherwise */ static GATBool GATPreferences_Internal_StringSets_Equal( char **this, char **that ); /* File scope variables */ static GATPreferences_vtable GATPreferences__vtable = { GATPreferences_GetType, GATPreferences_Destroy, GATPreferences_Equals, GATPreferences_Clone, GATPreferences_GetInterface, NULL }; /* External functions */ /** * Creates a new GATPreferences instance. * * @return A GATPreferences instance */ GATPreferences GATPreferences_Create(void) { GATPreferences this; this = (GATPreferences) malloc(sizeof(*this)); if(NULL != this) { this->__vtable = &GATPreferences__vtable; this->table = GATTable_Create(); if(!this->table) { free(this); } } return this; } /** * This function returns the type, a #GATType of the passed * #GATPreferences_const. This function will always return * #GATType_GATPreferences. * * @param this The #GATPreferences_const to query * @return The #GATType of the passed @c this */ GATType GATPreferences_GetType(GATPreferences_const this) { GAT_UNUSED_PARAMETER(this); return GATType_GATPreferences; } /** * Tests this #GATPreferences_const for equality with the passed * #GATPreferences_const instance. Two #GATPreferences_const instances * are considered equal if they contain the same set of name/value * pairs. * * @param this The first #GATPreferences_const to compare * @param that The second #GATPreferences_const to compare * @param isequal Result of comparison * @return Completion status */ GATResult GATPreferences_Equals(GATPreferences_const this, GATPreferences_const that, GATBool *isequal) { return GATTable_Equals(this->table, that->table, isequal); } /** * Destroys this GATPreferences instance. * * @param this The GATPreferences to destroy */ void GATPreferences_Destroy(GATPreferences *this) { if( (NULL != this) && (NULL != (*this)) ) { GATTable_Destroy( &((*this)->table) ); free(*this); *this = NULL; } } /** GATResult GATPreferences_GetInterface(GATPreferences_const table, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATPreferences * * The function GATPreferences_GetInterface allows to get a pointer to an * additional interface supported by this GATPreferences. * * @param object The object to be asked for the new interface. * @param iftype The interface the object is to be asked for. * @param ifp The pointer, through which the result is to be returned. * * @return An error type. */ GATResult GATPreferences_GetInterface(GATPreferences_const object, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; GAT_UNUSED_PARAMETER(object); GAT_UNUSED_PARAMETER(iftype); if (NULL != ifp) { *ifp = NULL; retval = GAT_NO_INTERFACE; } return retval; } /** * This adds a name/value pair in which the name is a String and the * value is a String to this GATPreferences instance. * * @param this The GATPreferences to modify * @param name Name of the attribute to add * @param value Value of the attribute to add * @return An int indicating the GATError return code */ GATResult GATPreferences_Add(GATPreferences this, const char *name, const char *value) { return GATTable_Add_String(this->table, name, value); } /** * Removes the name/value pair with the passed name from this * GATPreferences instance. * * @param this The GATPreferences to modify * @param name Name of the name/value to remove. * @return An int indicating the GATError return code */ GATResult GATPreferences_Remove(GATPreferences this, const char *name) { return GATTable_Remove(this->table, name); } /** * Sets the given GATTable of name/value pairs as preferences. * * @param this The GATPreferences to modify * @param preferences Table of name/value pairs to be used as * preferences. * @return An int indicating the GATError return code */ GATResult GATPreferences_Set(GATPreferences this, GATTable preferences) { GATTable tempTable = NULL; GATResult result = GATTable_Clone( preferences, &tempTable ); if(GAT_SUCCESS == result) { GATTable_Destroy( &(this->table) ); this->table = tempTable; } return result; } /** * Gets the current preferences as name/value pairs in a GATTable. * * @param this The GATPreferences to query * @param preferences Table of name/value pairs containing the * current preferences. */ GATTable_const GATPreferences_Get(GATPreferences_const this) { return this->table; } /** * Matches the GATPreferences instance against another GATPreferences * instance expressing criteria. For Match to return true, all keys * present in the criteria table must be present in the original and * must match: a string-valued value in the original table is matched by * a regular expression in the criteria table, and a numeric-valued value * in the original table by a string holding an arithmetical expression * (e.g., "$ < 5 $") in the criteria table. * * @param this The GATPreferences to query * @param criteria Matching criteria. * @param 1 upon match 0 otherwise */ GATBool GATPreferences_Match(GATPreferences_const this, GATPreferences_const criteria) { GATBool match; /* Boolean indicating match */ regex_t fsa; /* Pattern matcher */ int criteriaCounter; /* Counter for looping over criteriaKeyArray */ void **thisKeyArray; /* Array of this->table keys */ char thisValue[1024]; /* Value from this->table */ void **criteriaKeyArray; /* Array of criteria->table keys */ char criteriaValue[1024]; /* Value from this->table */ match = GATFalse; if(! criteria) { match = GATTrue; } else { thisKeyArray = GATTable_GetKeys( this->table ); criteriaKeyArray = GATTable_GetKeys( criteria->table ); if( (NULL == thisKeyArray) && (NULL == criteriaKeyArray) ) { /* No keys match no criteria */ match = GATTrue; } else if( (NULL == thisKeyArray) && (NULL != criteriaKeyArray) ) { /* No keys do not match arbitrary critera */ match = GATFalse; } else if( (NULL != thisKeyArray) && (NULL == criteriaKeyArray) ) { /* Arbitrary keys match no critera */ match = GATTrue; } else if ( GATFalse == GATPreferences_Internal_StringSets_Equal( (char **) thisKeyArray, (char **) criteriaKeyArray ) ) { /* All keys must match */ match = GATFalse; } else { /* Assume match */ match = GATTrue; /* Find matches */ criteriaCounter = 0; while((GATTrue == match) && (NULL != criteriaKeyArray[criteriaCounter])) { /* Determine if type is String and if so, obtain String */ if (0 < GATTable_Get_String(this->table, criteriaKeyArray[criteriaCounter], thisValue, 1024) ) { /* Obtain criteria String */ if( 0 < GATTable_Get_String( criteria->table, criteriaKeyArray[criteriaCounter], criteriaValue, 1024) ) { /* Compile regex */ if( 0 != regcomp( &fsa, criteriaValue, 0) ) { /* Compilation failed we need to flag this as an error !!! */ match = GATFalse; } /* Match with regex */ if( REG_NOMATCH == regexec( &fsa, thisValue, 0, NULL, 0) ) { /* Match failed */ match = GATFalse; } /* We need errors for other results of regexec !!! */ /* Free regex */ regfree(&fsa); } } /* If the type is not String and the doc does not specify enough detail to write code for this case !!! */ criteriaCounter++; } } /* free the returned arrays of keys */ GATTable_ReleaseKeys(this->table, &thisKeyArray); GATTable_ReleaseKeys(criteria->table, &criteriaKeyArray); } return match; } /** * This function returns a "deep clone" of the passed #GATPreferences_const @c this. * This "deep clone" is returned in the variable @c thisClone. Furthermore, * this function returns its completion status, through its return value. * * @param this The #GATPreferences_const to clone * @param thisClone The cloned #GATPreferences_const * @return The completion status of this function */ GATResult GATPreferences_Clone(GATPreferences_const this, GATPreferences *thisClone) { GATResult result = GAT_INVALID_PARAMETER; if( (NULL != this) && (NULL != thisClone) ) { GATPreferences temp = (GATPreferences) malloc( sizeof(struct GATPreferences_S) ); (*thisClone) = NULL; if( NULL != temp ) { temp->__vtable = this->__vtable; result = GATTable_Clone( this->table, &(temp->table) ); if( GAT_SUCCESS != result ) { GATPreferences_Destroy( &temp ); } else { (*thisClone) = temp; result = GAT_SUCCESS; } } else { result = GAT_MEMORYFAILURE; } } return result; } /* Local functions */ /* * This function determines if the two NULL terminated * arrays of strings are equivalent as sets. For the * two arrays to be equivalent as sets each string * in the first set must appear in the second set * and each string in the second set must appear * in the first. Equivalence between strings is * determined using strcmp. * * @return 1 if equal 0 otherwise */ static GATBool GATPreferences_Internal_StringSets_Equal( char **this, char **that ) { int contained; int thisCounter; int thatCounter; /* Count number of strings */ thisCounter = 0; while(NULL != this[thisCounter]) { thisCounter++; } /* Count number of strings */ thatCounter = 0; while(NULL != that[thatCounter]) { thatCounter++; } /* Cardinality must be equal */ if(thisCounter != thatCounter) { return GATFalse; } /* Check details */ thisCounter = 0; while(NULL != this[thisCounter]) { contained = 0; thatCounter = 0; while( (0 == contained) && (NULL != that[thatCounter]) ) { if( 0 == strcmp(this[thisCounter], that[thatCounter]) ) { contained = 1; } thatCounter++; } if(0 == contained) { return GATFalse; } thisCounter++; } return GATTrue; }