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

GATMetric.c Go to the documentation of this file. /** @file GATMetric.c * Source file for the GATMetric class. * * @date Tue Nov 4 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATMetric.c,v 1.13 2004/04/02 12:31:58 hartmutkaiser Exp $ * * Copyright (C) Hartmut Kaiser * This file is part of the GAT Engine. * Contributed by Hartmut Kaiser <hartmutkaiser [at] t-online [dot] 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/GATMetric.c,v 1.13 2004/04/02 12:31:58 hartmutkaiser Exp $"; /* System Header objects */ #include <stdlib.h> #include <string.h> /* GAT Header objects */ #include "GAT.h" #include "GATInternal.h" #include "GATUtil.h" /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATMetric); /* define the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATMetric) /* Macros */ /* Structures, unions and enums */ struct GATMetric_S { /* supported interfaces */ GATMetric_vtable *GATObject__vtable; /* instance data */ char const *name; /* metric name */ GATTable parameters; /* metric parameters */ GATMeasurementType measurement_type; /* metric measurement type */ GATType data_type; /* metric data type */ char const *unit; /* metric unit */ }; /* Static function prototypes */ /* object scope variables */ GATMetric_vtable GATMetric__vtable = { GATMetric_GetType, GATMetric_Destroy, GATMetric_Equals, GATMetric_Clone, GATMetric_GetInterface, NULL }; /* External functions */ /** GATMetric_Create * @brief Create a new GATMetric object * * The function @c GATMetric_Create creates a new GATMetric object. * * @return Returns a handle to the newly created GATMetric object. * Returns 0 (zero) if an error occurs. */ GATMetric GATMetric_Create(char const *name, GATTable parameters, GATMeasurementType type, GATType datatype, char const *unit) { GATResult err_code = GAT_MEMORYFAILURE; GATMetric retval = (GATMetric) malloc(sizeof(struct GATMetric_S)); if (NULL != retval) { memset(retval, 0, sizeof(struct GATMetric_S)); retval->GATObject__vtable = &GATMetric__vtable; retval->measurement_type = type; retval->data_type = datatype; err_code = GATTable_Clone(parameters, &retval->parameters); if (GAT_SUCCESS == err_code) { retval->name = GATUtil_strdup(name); retval->unit = GATUtil_strdup(unit); if (NULL == retval->name || NULL == retval->unit) { err_code = GAT_MEMORYFAILURE; } } } /* error handling */ if (GAT_SUCCESS != err_code) { /* FIXME: GATStatus(err_code) */ if (NULL != retval) { GATMetric_Destroy(&retval); } } return retval; } /** void GATMetric_Destroy(GATMetric *resource) * * The function GATMetric_Destroy is the destructor used to * free all the memory allocated by an GATMetric instance. * * @param description The pointer to the GATMetric to destroy */ void GATMetric_Destroy(GATMetric *object) { if (NULL != object && NULL != *object) { GATTable_Destroy(&(*object)->parameters); free((char *) (*object)->name); free((char *) (*object)->unit); free(*object); *object = NULL; } } /** GATMetric_Equals * @brief Compare two GATMetric objects * * The function @c GATMetric_Equals compares two objects of the * @c GATMetric type. * * @param lhs The first list to compare * @param rhs The second list to compare * @param isequal The pointer to the location, where the outcome of the * function has to be stored. * * @return An error code. */ GATResult GATMetric_Equals(GATMetric_const lhs, GATMetric_const rhs, GATBool *isequal) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != lhs && NULL != rhs) { if (NULL != isequal) { *isequal = GATFalse; retval = GAT_SUCCESS; if (!strcmp(lhs->name, rhs->name)) { retval = GATTable_Equals(lhs->parameters, rhs->parameters, isequal); } } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /** GATMetric_Clone * @brief Clone the given GATMetric * * The function @c GATMetric_Clone generates a (deep) copy of * the given GATMetric. * * @param description The object to clone * @param new_object The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATMetric_Clone(GATMetric_const handle, GATMetric *new_handle) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != handle) { if (NULL == new_handle) { retval = GAT_INVALID_PARAMETER; } else { GATMetric new_object = (GATMetric) malloc(sizeof(struct GATMetric_S)); *new_handle = NULL; if (NULL == new_object) { retval = GAT_MEMORYFAILURE; } else { memset(new_object, 0, sizeof(struct GATMetric_S)); new_object->GATObject__vtable = &GATMetric__vtable; new_object->measurement_type = handle->measurement_type; new_object->data_type = handle->data_type; retval = GATTable_Clone(handle->parameters, &new_object->parameters); if (GAT_SUCCESS == retval) { new_object->name = GATUtil_strdup(handle->name); new_object->unit = GATUtil_strdup(handle->unit); if (NULL == new_object->name || NULL == new_object->unit) { retval = GAT_MEMORYFAILURE; } } if (GAT_SUCCESS == retval) { *new_handle = new_object; } else { GATMetric_Destroy(&new_object); } } } } return retval; } /** GATType GATMetric_GetType(GATMetric_const resource) * @brief Return the type of the GATMetric * * The function @c GATMetric_GetType always returns * @c #GATType_GATMetric. * * @param object The object to inspect * * @return Returns always @c #GATType_GATMetric. */ GATType GATMetric_GetType(GATMetric_const description) { GAT_UNUSED_PARAMETER(description); return GATType_GATMetric; } /** int GATMetric_GetInterface(GATMetric_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATObject * * The function GATMetric_GetInterface allows to get a pointer to an * additional interface supported by this GATMetric. * * @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 GATMetric_GetInterface(GATMetric_const metric, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; GAT_UNUSED_PARAMETER(metric); GAT_UNUSED_PARAMETER(iftype); if (NULL != ifp) { *ifp = NULL; retval = GAT_NO_INTERFACE; } return retval; } /** GATMetric_i_GetTypeSize * * @return The size of the internal representation of the GATMetric type. * * @remark This is an internal function, do not use it directly. */ GATuint32 GATMetric_i_GetTypeSize(void) { return sizeof(struct GATMetric_S); } /* GATMetric API functions */ /** GATMetric_GetName * * The function GATMetric_GetName gets the name associated with this * GATMetric. * * @param metric The metric to ask for its name. * * @return The name associated with this metric. */ char const * GATMetric_GetName(GATMetric_const metric) { char const *name = NULL; if (NULL != metric) { name = metric->name; } return name; } /** GATMetric_GetUnit * * The function GATMetric_GetUnit gets the measurement unit * associated with this GATMetric. * * @param metric The metric to ask for its measurement unit. * * @return The unit associated with this metric. */ char const * GATMetric_GetUnit(GATMetric_const metric) { char const *unit = NULL; if (NULL != metric) { unit = metric->unit; } return unit; } /** GATMetric_GetValueType * * The function GATMetric_GetValueType gets the data type of the value * provided by this GATMetric. * * @param metric The metric to ask for its data value type. * * @return The data value type associated with this metric. */ GATType GATMetric_GetValueType(GATMetric_const metric) { GATType type = GATType_NoType; if (NULL != metric) { type = metric->data_type; } return type; } /** GATMetric_GetParameters * * The function GATMetric_GetParameters gets the GATMetric parameter * value associated with the passed GATMetric parameter name. Ther is returned * a 0 (zero) if there is no GATMetric parameter value with the passed name. * * @param metric The metric to ask for its name. * @param table The pointer to a variable, which receives the returned * parameter table. * * @return An error code. */ GATResult GATMetric_GetParameters(GATMetric_const metric, GATTable *table) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != metric) { retval = GATTable_Clone(metric->parameters, table); } return retval; } /** GATMetric_GetParameterTypeByName * * The function GATMetric_GetParameterTypeByName gets the type of the * GATMetric parameter value associated with the passed GATMetric parameter * name. * * @param metric The metric to ask for its name. * @param name The name of the parameter to query for. * * @return The type of the associated value. */ GATType GATMetric_GetParameterTypeByName(GATMetric_const metric, char const *name) { GATType type = GATType_NoType; if (NULL != metric) { type = GATTable_Get_ElementType(metric->parameters, name); } return type; } /** GATMetric_GetParameterByName * * The function GATMetric_GetParameterByName gets the GATMetric * parameter value associated with the passed GATMetric parameter name. There * is returned a 0 (zero) if there is no GATMetric parameter value with the * passed name. * * @param metric The metric to ask for its name. * @param name The name of the parameter to query for. * @param buffer The buffer, where the retrieved value should be returned to. * @param size The size of the buffer. * * @return An error code. */ GATResult GATMetric_GetParameterByName(GATMetric_const metric, char const *name, GATType type, void *buffer, GATuint32 size) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != metric) { switch(type) { case GATType_GATint16: retval = GATTable_Get_short(metric->parameters, name, (GATint16 *) buffer); break; case GATType_GATint32: retval = GATTable_Get_int(metric->parameters, name, (GATint32 *) buffer); break; case GATType_GATfloat32: retval = GATTable_Get_float(metric->parameters, name, (GATfloat32 *) buffer); break; case GATType_GATdouble64: retval = GATTable_Get_double(metric->parameters, name, (GATdouble64 *) buffer); break; case GATType_String: retval = GATTable_Get_String(metric->parameters, name, (char *) buffer, size); break; case GATType_GATObject: retval = GATTable_Get_GATObject(metric->parameters, name, (GATObject_const *) buffer); break; default: retval = GAT_KEY_TYPE_ERROR; break; } } return retval; } /** GATMetric_GetMeasurementType * * The functions GATMetric_GetMeasurementType returns the measurment type of * the value associated with the given metric. * * @param metric The metric to ask for its values measurement type. * * @return The requested measurement type. */ GATMeasurementType GATMetric_GetMeasurementType(GATMetric_const metric) { GATMeasurementType retval = GATMeasurementType_Unknown; if (NULL != metric) { retval = metric->measurement_type; } return retval; } /** GATMetric_CreateMetric * * The function GATMetric_CreateMetric creates a GATMetric object from a given * static metric data. This is a pure helper function for adaptor writers. * * @param data The address of the static metric data. * @param metric The pointer to the variable, which receives the resulting * metric. * * @return An error code. */ GATResult GATMetric_CreateMetric(GATStaticMetric const *data, GATMetric *metric) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != data && NULL != metric) { /* create an fill the parameters table */ GATTable parameters = GATTable_Create(); *metric = NULL; if (NULL == parameters) { retval = GAT_MEMORYFAILURE; } else { GATuint32 j = 0; GATStaticParameter *p = data->parameters; retval = GAT_SUCCESS; /* no parameters is ok too */ for (/**/; j < data->parameter_count; ++j, ++p) { switch(p->type) { case GATType_GATint16: retval = GATTable_Add_short(parameters, p->key, p->d.int16_data); break; case GATType_GATint32: retval = GATTable_Add_int(parameters, p->key, p->d.int32_data); break; case GATType_GATfloat32: retval = GATTable_Add_float(parameters, p->key, p->d.float_data); break; case GATType_GATdouble64: retval = GATTable_Add_double(parameters, p->key, p->d.double_data); break; case GATType_String: retval = GATTable_Add_String(parameters, p->key, p->d.string_data); break; default: retval = GAT_KEY_TYPE_ERROR; break; } if (GAT_SUCCESS != retval) { break; } } if (GAT_SUCCESS == retval) { /* create the metric to store into the list */ GATMetric new_metric = GATMetric_Create(data->name, parameters, data->measurement_type, data->data_type, data->unit); if (NULL == new_metric) { retval = GAT_MEMORYFAILURE; } else { *metric = new_metric; } } GATTable_Destroy(&parameters); } } return retval; } /** GATMetric_CreateListOfMetrics * * The function GATMetric_CreateListOfMetrics creates a list of GATMetric * objects from a given list of static metric data. This is a pure helper * function for adaptor writers. * * @param data The address of the static metric data array. * @param count The size of the given array of static metric data. * @param list The pointer to the variable, which receives the resulting list * of metrics. * * @return An error code. */ GATResult GATMetric_CreateListOfMetrics(GATStaticMetric *data, GATuint32 count, GATList_GATMetric *list) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != data && NULL != list) { GATuint32 i = 0; GATList_GATMetric new_list = GATList_GATMetric_Create(); *list = NULL; if (NULL == new_list) { retval = GAT_MEMORYFAILURE; } else { for (/**/; i < count; ++i) { GATList_GATMetric_Iterator it = NULL; GATMetric metric = NULL; retval = GATMetric_CreateMetric(&data[i], &metric); if (GAT_SUCCESS != retval) { break; } /* store the metric into the list */ it = GATList_GATMetric_Insert(new_list, GATList_GATMetric_End(new_list), metric); GATMetric_Destroy(&metric); if (NULL == it) { retval = GAT_MEMORYFAILURE; break; } } if (GAT_SUCCESS == retval) { *list = new_list; } } } return retval; } /* Local functions */