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

GATTime.c Go to the documentation of this file. /** @file GATTime.c * Main file for the GATTime class. * * A GATTime represents a point in time. * * @date $Date: 2004/04/08 09:43:18 $ * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATTime.c,v 1.20 2004/04/08 09:43:18 kdavis Exp $ * * Copyright (C) Kelly Davis * This file is part of the GAT Engine. * Contributed by Kelly Davis <kdavis@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/GATTime.c,v 1.20 2004/04/08 09:43:18 kdavis Exp $"; /* System Header Files */ #include <string.h> #include <stdlib.h> #include <time.h> /* GAT Header Files */ #include "GATType.h" #include "GATTime.h" #include "GATErrors.h" #include "GATInternal.h" #include "GATXdsWrapper.h" /* Macros */ /* Structures, unions and enums */ /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATTime); GATSERIALISABLE_DEFINE_VTABLE(GATTime); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATTime); struct GATTime_S { GATTime_vtable *GATObject__vtable; GATTime_ISerialisable_vtable *GATSerialisable__vtable; GATBool isdirty; GATdouble64 internalTime; }; /* Static function prototypes */ static GATResult GATTime_DeSerialise_Create(GATContext context, GATObject stream, GATdouble64 newtime, GATTime *new_object); /* File scope variables */ static GATTime_vtable GATTime__vtable = { GATTime_GetType, GATTime_Destroy, GATTime_Equals, GATTime_Clone, GATTime_GetInterface, NULL }; static GATTime_ISerialisable_vtable GATTime_ISerialisable__vtable = { GATTime_Serialise, GATTime_DeSerialise, GATTime_GetIsDirty, }; /* External functions */ /** GATTime_Register_GATSerialisable * The GATTime_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 GATTime_Register_GATSerialisable(void) { return GATObject_Register_GATSerialisable(GATType_GATTime, &GATTime_ISerialisable__vtable); } /** * This operation constructs a GATTime * instance corresponding to the passed * time, the number of seconds elapsed * since 00:00 hours, Jan 1, 1970 UTC * from the system clock. * * @param intime The time in seconds this GATTime instance represents. * If the value of this parameter is 0 (zero), then the current time is * used. * @return A GATTime instance */ GATTime GATTime_Create(GATdouble64 intime) { GATTime newobject = (GATTime) malloc(sizeof(struct GATTime_S)); if(NULL != newobject) { memset(newobject, 0, sizeof(sizeof(struct GATTime_S))); newobject->GATObject__vtable = &GATTime__vtable; newobject->GATSerialisable__vtable = &GATTime_ISerialisable__vtable; newobject->isdirty = GATFalse; if (0 == intime) { intime = time(0); } newobject->internalTime = intime; } return newobject; } /** * Destroys the GATTime instance * * @param this The GATTime to * destroy. */ void GATTime_Destroy(GATTime *object) { if( (NULL != object) && (NULL != *object) ) { free(*object); *object = NULL; } } /** * This function returns a "deep clone" of the passed #GATTime_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 #GATTime_const to clone * @param timeClone The cloned #GATTime_const * @return The completion status of this function */ GATResult GATTime_Clone(GATTime_const object, GATTime *timeClone) { GATResult retval = GAT_INVALID_PARAMETER; if( (NULL != object) && (NULL != timeClone) ) { GATTime newGATTime = (GATTime) malloc( sizeof(struct GATTime_S) ); (*timeClone) = NULL; if(NULL != newGATTime) { memset(newGATTime, 0, sizeof(sizeof(struct GATTime_S))); newGATTime->GATObject__vtable = object->GATObject__vtable; newGATTime->GATSerialisable__vtable = &GATTime_ISerialisable__vtable; newGATTime->isdirty = object->isdirty; newGATTime->internalTime = object->internalTime; (*timeClone) = newGATTime; retval = GAT_SUCCESS; } else { retval = GAT_MEMORYFAILURE; } } return retval; } /** * This fucntion returns the type, a #GATType of the passed #GATTime_const. * This function will always return #GATType_GATTime. * * @param this The #GATTime_const to query * @return The #GATType of the passed @c time */ GATType GATTime_GetType(GATTime_const this) { GAT_UNUSED_PARAMETER(this); return GATType_GATTime; } /** GATResult GATTime_GetInterface(GATTime_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATObject * * The function GATTime_GetInterface allows to get a pointer to an * additional interface supported by this GATTime. * * @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 GATTime_GetInterface(GATTime_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 GATTime_Serialise(GATTime object, GATObject stream, GATBool clear_dirty) * @brief Serialise a GATTime object * * The function GATTime_Serialise serialises the given GATTime object into the * given stream. * * @param object The GATTime 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 GATTime_Serialise(GATTime object, GATObject stream, GATBool clear_dirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { retval = GATXds_SerialiseObject(GATTime_ToGATObject(object), stream, clear_dirty, 0, "uint32 double_fmt", GATTIME_VERSION1, "%15.6lf", object->internalTime); if (GAT_SUCCEEDED(retval) && clear_dirty) { object->isdirty = GATFalse; } } return retval; } /** GATTime_VersionCallback * * The function GATTime_VersionCallback is used as a callback function * during the de-serialisation of a GATTime. 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 GATTime_VersionCallback(GATuint32 version) { GATBool retval = GATFalse; if ((version & ~GATTIME_MINOR_MASK) <= GATTIME_LASTVERSION) { retval = GATTrue; } return retval; } /** GATTime_DeSerialiseCallback * * The function GATTime_DeSerialiseCallback is used as a callback function * during the de-serialisation of a GATTime. It should be provided for the * instantiation of the new GATTime 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 * GATTime_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 GATTime_DeSerialiseCallback(GATContext context, GATObject stream, GATObject *new_object, GATuint32 version, va_list args) { /* the version was eaten already */ GATdouble64 *new_time = va_arg (args, GATdouble64 *); GATTime object = NULL; /* construct the new object */ GATResult retval = GATTime_DeSerialise_Create(context, stream, *new_time, &object); // expects seconds GAT_UNUSED_PARAMETER(version); if (GAT_SUCCESS == retval) { if (NULL != object) { *new_object = GATTime_ToGATObject(object); } else { GATTime_Destroy(&object); retval = GAT_INVALID_PARAMETER; } } return retval; } /** GATTime GATTime_DeSerialise(GATContext context, GATObject stream, GATBool clear_dirty) * @brief De-serialise a GATTime object * * The function GATTime_DeSerialise de-serialises a streamed GATTime 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 GATTime object. */ GATTime GATTime_DeSerialise(GATContext context, GATObject stream, GATResult *result) { GAT_USES_STATUS(context, "GATTime_DeSerialise"); GATObject object = NULL; /* the new object will be created here */ /* we must provide all instance data items to be de-serialised for this GATTime object accordingly to the provided format string */ GATuint32 version = 0; GATdouble64 new_time = 0; /* read the data */ GAT_CREATE_STATUS(GATXds_DeSerialiseObject(context, stream, GATTime_DeSerialiseCallback, GATTime_VersionCallback, &object, "uint32 double", &version, &new_time)); if (NULL != result) { *result = GAT_RETURN_STATUS(); } else { GAT_STORE_STATUS(); } return GATObject_ToGATTime(object); } /** GATTime_GetIsDirty * * The function GATTime_GetIsDirty retrieves the status of the dirty flag of * this GATTime object. * * @param file The GATTime object to inspect for its dirty status. * @param isdirty The pointer to a variable, which receives the dirty status. * * @return An error code. */ GATResult GATTime_GetIsDirty(GATTime_const object, GATBool *isdirty) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { if (NULL != isdirty) { *isdirty = object->isdirty; retval = GAT_SUCCESS; } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /* GATTime API functions */ /** * This operation returns the time * this GATTime instance represents * * @param this The #GATTime to query * @return The time this GATTime * instance represents. */ GATdouble64 GATTime_GetTime(GATTime_const this) { return this->internalTime; } /** * Tests this GATTime for equality with * the passed GATTime instance * * If the passed GATTime is deemed equal * if it has a numerically equivalent time * to the passed GATTime instance. * * @param this The first GATTime to compare * @param that The second GATTime to compare * @param isequal Result of comparrison * @return Completion status */ GATResult GATTime_Equals(GATTime_const this, GATTime_const that, GATBool *isequal) { GATResult retval = GAT_INVALID_PARAMETER; if( (NULL != this) && (NULL != that) && (NULL != isequal) ) { (*isequal) = GATFalse; if(0 == this->internalTime - that->internalTime) { (*isequal) = GATTrue; } retval = GAT_SUCCESS; } return retval; } /* Local functions */ /** GATTime_DeSerialise_Create * * The function GATTime_DeSerialise_Create creates a new GATTime object. * * @param context The GAT context to use for creation of the GATTime object. * @param stream The object from which the adaptor should read the streamed * instance data. * @param newtime The time to be used to initialise the new object. * @param new_object The pointer to the variable, which should receive the * newly constructed GATTime object. * * @return An error code. */ static GATResult GATTime_DeSerialise_Create(GATContext context, GATObject stream, GATdouble64 newtime, GATTime *object) { GAT_USES_STATUS(context, "GATTime_DeSerialise_Create"); GATTime new_object = (GATTime) malloc(sizeof(struct GATTime_S)); GAT_UNUSED_PARAMETER(stream); if(NULL != new_object) { memset(new_object, 0, sizeof(struct GATTime_S)); new_object->GATObject__vtable = &GATTime__vtable; new_object->GATSerialisable__vtable = &GATTime_ISerialisable__vtable; new_object->isdirty = GATFalse; new_object->internalTime = newtime; } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (NULL != new_object) { *object = new_object; } else { GATTime_Destroy(&new_object); GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GATTime_Destroy(&new_object); } return GAT_RETURN_STATUS(); }