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

GATLocation.c Go to the documentation of this file. /** @file GATLocation.c * Main file for the GATLocation class. * * A GATLocation represents the location of an abstract or physical resource. * The location is represented as a URI - see RFC 2396 and RFC 2732. * * @date Wed Sep 24 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATLocation.c,v 1.17 2004/04/02 12:31:58 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/GATLocation.c,v 1.17 2004/04/02 12:31:58 hartmutkaiser Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* GAT Header Files */ #include "GATLocation.h" #include "GATInternal.h" #include "GATErrors.h" #include "GATXdsWrapper.h" #include "GATUtil.h" /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATLocation); GATSERIALISABLE_DEFINE_VTABLE(GATLocation); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATLocation); /* Macros */ /* Structures, unions and enums */ struct GATLocation_S { GATLocation_vtable *GATObject__vtable; GATLocation_ISerialisable_vtable *GATSerialisable__vtable; char *uri; }; /* Static function prototypes */ static char *GetSubString(const char *string, int start, int end); static int GATLocation_DeSerialise_Create(GATContext context, GATObject stream, char const *uri, GATLocation *new_object); /* File scope variables */ static GATLocation_vtable GATLocation__vtable = { GATLocation_GetType, GATLocation_Destroy, GATLocation_Equals, GATLocation_Clone, GATLocation_GetInterface, NULL }; static GATLocation_ISerialisable_vtable GATLocation_ISerialisable__vtable = { GATLocation_Serialise, GATLocation_DeSerialise, GATLocation_GetIsDirty, }; /* External functions */ /** GATLocation_Register_GATSerialisable * The GATLocation_Register_GATSerialisable function registers the serialization * vtable with the GAT engine to allow generic object creation. * This function is called by the GAT engine, there is no need to use it * directly. */ GATResult GATLocation_Register_GATSerialisable(void) { return GATObject_Register_GATSerialisable(GATType_GATLocation, &GATLocation_ISerialisable__vtable); } /** GATLocation_Create * The GATLocation constructor. * This is the constructor for GATLocation objects. * * @return A new GATLocation */ GATLocation GATLocation_Create(const char *uri) { GATLocation this; this = (GATLocation)malloc(sizeof(*this)); if(this) { this->GATObject__vtable = &GATLocation__vtable; this->GATSerialisable__vtable = &GATLocation_ISerialisable__vtable; this->uri = GetSubString(uri,0,strlen(uri)); if(!this->uri) { free(this); this = NULL; } } return this; } /** GATLocation_Destroy * The GATLocation destructor. * This is the destructor for GATLocation objects. * * @param this An old GATLocation */ void GATLocation_Destroy(GATLocation *this) { if(NULL != this && NULL != *this) { if((*this)->uri) { free((*this)->uri); } free(*this); *this = NULL; } } /** GATLocation_ToString * Get a copy of the string representation of the location.. * Return the content of the GATLocation as a string. This is * effectively the string given in the constructor. * * @param this The GATLocation * * @return A string containing the URI. */ char *GATLocation_ToString(GATLocation_const this) { char *retval; retval = GetSubString(this->uri,0,strlen(this->uri)); return retval; } /** int GATLocation_GetType(GATLocation_const location) * @brief Return the type of the GATLocation * * The function @c GATLocation_GetType always returns GATType_GATLocation. * * @param object The object to inspect * * @return returns always @c #GATType_GATLocation. */ GATType GATLocation_GetType(GATLocation_const location) { GAT_UNUSED_PARAMETER(location); return GATType_GATLocation; } /** GATLocation_Clone * Makes a deep copy of the GATLocation. * Return a new GATLocation which is equivalent to this one. * * @param this The GATLocation * * @return A string containing the URI. */ int GATLocation_Clone(GATLocation_const this, GATLocation *new_location) { int retval = GAT_INVALID_PARAMETER; GATLocation location = GATLocation_Create(this->uri); if (NULL != location) { if (NULL != new_location) { *new_location = location; retval = GAT_SUCCESS; } } else { retval = GAT_MEMORYFAILURE; } if (GAT_SUCCESS != retval) { GATLocation_Destroy(&location); } return retval; } /** GATLocation_Equals * Compares two GATLocation objects for equality * * @param this The GATLocation * @param that The GATLocation to compare with * * @return 1 upon equality 0 otherwise */ int GATLocation_Equals(GATLocation_const this, GATLocation_const that, GATBool *isequal) { char *this_str = GATLocation_ToString(this); char *that_str = GATLocation_ToString(that); int result = GAT_INVALID_PARAMETER; if (NULL != this_str && NULL != that_str && NULL != isequal) { *isequal = strcmp(this_str, that_str) ? GATFalse : GATTrue; result = GAT_SUCCESS; } free(this_str); free(that_str); return result; } /** GATResult GATLocation_GetInterface(GATLocation_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATObject * * The function GATLocation_GetInterface allows to get a pointer to an * additional interface supported by this GATLocation. * * @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 GATLocation_GetInterface(GATLocation_const object, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != ifp) { *ifp = NULL; if (GATInterface_ISerialisable == iftype) { *ifp = (void const *) &object->GATSerialisable__vtable; retval = GAT_SUCCESS; } else { retval = GAT_NO_INTERFACE; } } return retval; } /* GATAdvertiseable API */ /** GATResult GATLocation_Serialise(GATLocation object, GATObject stream, GATBool clear_dirty) * @brief Serialise a GATLocation object * * The function GATLocation_Serialise serialises the given GATLocation object * into the given stream. * * @param object The GATLocation object to serialise. * @param stream The stream interface to use for the serialisation. * @param clear_dirty If the clear_dirty parameter is set to GATTrue, the * internal dirty flag of this object is to be reset (no used here) * * @return An error code. */ GATResult GATLocation_Serialise(GATLocation object, GATObject stream, GATBool clear_dirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { retval = GATXds_SerialiseObject(GATLocation_ToGATObject(object), stream, clear_dirty, 0, "uint32 string", GATLOCATION_VERSION1, object->uri); } return retval; } /** GATLocation_VersionCallback * * The function GATLocation_VersionCallback is used as a callback function * during the de-serialisation of a GATLocation. It should be provided to test, * whether the de-serialised version matches the expected version. * * @param version The version number, which was de-serialised from the stream. * * @return This function should return GATTrue, if the version matches the * expected value (version is valid), GATFalse otherwise. * * @remark This function is called from the GAT engine, there is no need to * call it directly. */ static GATBool GATLocation_VersionCallback(GATuint32 version) { GATBool retval = GATFalse; if ((version & ~GATLOCATION_MINOR_MASK) <= GATLOCATION_LASTVERSION) { retval = GATTrue; } return retval; } /** GATLocation_DeSerialiseCallback * * The function GATLocation_DeSerialiseCallback is used as a callback function * during the de-serialisation of a GATLocation. It should be provided for the * instantiation of the new GATLocation object based on the already de-serialised * data items and the de-serialisation of the associated CPI provider data for * the given object. * * @param context The GAT context to be used for object construction. * @param stream The stream interface to use for the serialisation. * @param object The pointer to the variable, which should receive the newly * constructed object. * @param version The version of the saved data read from the input stream. * @param args This parameter is the pointer to the va_list containing * pointers to the already de-serialised data items accordingly to the * format string, provided during the call to the * GATLocation_DeSerialise function. * * @return An error code. * * @remark This function is called from the GAT engine, there is no need to * call it directly. */ static GATResult GATLocation_DeSerialiseCallback(GATContext context, GATObject stream, GATObject *new_object, GATuint32 version, va_list args) { /* the version was eaten already */ char const **uri = va_arg(args, char const **); GATLocation object = NULL; /* construct the new object */ GATResult retval = GATLocation_DeSerialise_Create(context, stream, *uri, &object); GAT_UNUSED_PARAMETER(version); if (GAT_SUCCESS == retval) { if (NULL != object) { *new_object = GATLocation_ToGATObject(object); } else { GATLocation_Destroy(&object); retval = GAT_INVALID_PARAMETER; } } return retval; } /** GATLocation GATLocation_DeSerialise(GATContext context, GATObject stream, GATBool clear_dirty) * @brief De-serialise a GATLocation object * * The function GATLocation_DeSerialise de-serialises a streamed GATLocation object * from the given stream It constructs a new instance of the de-serialised * object. * * @param context The GAT context to be used for object construction. * @param stream The stream interface to use for the serialisation. * @param result The pointer to a variable, which receives the status code of * the operation. * * @return The newly constructed GATLocation object. */ GATLocation GATLocation_DeSerialise(GATContext context, GATObject stream, GATResult *result) { GAT_USES_STATUS(context, "GATLocation_DeSerialise"); GATObject object = NULL; /* the new object will be created here */ /* we must provide all instance data items to be de-serialised for this GATLocation object accordingly to the provided format string */ GATuint32 version = 0; char *uri = NULL; /* read the data */ GAT_CREATE_STATUS(GATXds_DeSerialiseObject(context, stream, GATLocation_DeSerialiseCallback, GATLocation_VersionCallback, &object, "uint32 string", &version, &uri)); free(uri); if (NULL != result) { *result = GAT_CURRENT_STATUS(); } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } GAT_STORE_STATUS(); return GATObject_ToGATLocation(object); } /** GATLocation_GetIsDirty * * The function GATLocation_GetIsDirty retrieves the status of the dirty flag of * this GATLocation object. * * @param file The GATLocation object to inspect for its dirty status. * @param isdirty The pointer to a variable, which receives the dirty status. * * @return An error code. */ GATResult GATLocation_GetIsDirty(GATLocation_const object, GATBool *isdirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { if (NULL != isdirty) { *isdirty = GATFalse; /* a GATLocation is never 'dirty' */ retval = GAT_SUCCESS; } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /* Local functions */ /** GATLocation_DeSerialise_Create * * The function GATLocation_DeSerialise_Create creates a new GATLocation object. * * @param context The GAT context to use for creation of the GATLocation object. * @param stream The object from which the adaptor should read the streamed * instance data. TODO: Add the description of your additional parameters here * @param new_object The pointer to the variable, which should receive the * newly constructed GATLocation object. * * @return An error code. */ static GATResult GATLocation_DeSerialise_Create(GATContext context, GATObject stream, char const *uri, GATLocation *object) { GAT_USES_STATUS(context, "GATLocation_DeSerialise_Create"); GATLocation new_object = (GATLocation) malloc(sizeof(struct GATLocation_S)); GAT_UNUSED_PARAMETER(stream); if(NULL != new_object) { memset(new_object, 0, sizeof(struct GATLocation_S)); new_object->GATObject__vtable = &GATLocation__vtable; new_object->GATSerialisable__vtable = &GATLocation_ISerialisable__vtable; new_object->uri = GATUtil_strdup(uri); GAT_CREATE_STATUS_IF(NULL == new_object->uri, GAT_MEMORYFAILURE); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (NULL != new_object) { *object = new_object; } else { GATLocation_Destroy(&new_object); GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GATLocation_Destroy(&new_object); } return GAT_RETURN_STATUS(); } /** GetSubString * Copy a portion of a string. * Creates a new string which is a substring of the old one. * * @param string The original string * @param start Starting location of substring. * @param end End location of substring. * * @return A new string holding the substring. */ static char *GetSubString(const char *string, int start, int end) { char *retval; int length; length = end-start; if(length > 0) { retval = (char *)malloc(length+1); if(retval) { strncpy(retval, string+start, length); retval[length] = 0; } } else { retval = NULL; } return retval; }