diff options
Diffstat (limited to 'vendor/voclient/libvotable/votHandle.c')
| -rw-r--r-- | vendor/voclient/libvotable/votHandle.c | 232 |
1 files changed, 232 insertions, 0 deletions
diff --git a/vendor/voclient/libvotable/votHandle.c b/vendor/voclient/libvotable/votHandle.c new file mode 100644 index 00000000..4c8f3904 --- /dev/null +++ b/vendor/voclient/libvotable/votHandle.c @@ -0,0 +1,232 @@ +/** + * VOTHANDLE.C -- (Private) Methods to manage interface handles. + * + * @file votHandle.c + * @author Mike Fitzpatrick and Eric Timmermann + * @date 8/03/09 + * + * @brief (Private) Methods to manage interface handles. + */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include "votParseP.h" + + +static Element **handles; /** A pointer to the handles */ +static handle_t handleMax = 0; /** max available handles */ +static handle_t handleCount = 0; /** count of current used handles */ + + + +/** + * vot_handleCount -- Get the number of handle_t used (private method) + * + * @brief Get the number of handle_t used (private method) + * @fn int vot_handleCount (void) + * + * @return The number of handle_t types currently stored + */ +int vot_handleCount () { return (handleCount); } + + +/** + * vot_lookupHandle -- Lookup the handle_t to an Element (private method) + * + * @brief Lookup the handle_t to an Element (private method) + * @fn handle_t vot_lookupHandle (Element *elem) + * + * @param *elem A pointer to an Element + * @return A handle_t to the Element + */ +handle_t +vot_lookupHandle (Element *elem) +{ +#ifdef HANDLE_SEARCH + unsigned int i = 0, j = 0; + unsigned int big = 1024, small = 20; +#endif + + if (elem == (Element *) NULL) + return (0); + + /* The handle structure is basically an array of pointers. In general the + * address will be an increasing value, but is not guaranteed to always be + * offset by an integer number of Elem structs. The strategy is to search + * in large chunks before resorting to sequential access to the array to + * find the exact match. + * + */ + +#ifdef HANDLE_SEARCH + big = max (1024, (handleCount / 10)); + small = max (20, (handleCount / 200)); + for (i = 0; i < handleMax; i+=big) + if (elem > handles[i] || i >= handleMax) + break; + for (j = (i - big); j < handleMax; j+=small) + if (elem > handles[j] || j >= handleMax) + break; + for (j = (j - small); j < handleMax; j++) + if (handles[j] == elem) + return ((j + 1)); +#else + if (elem->handle >= 0) + return (elem->handle); +#endif + + return (vot_setHandle (elem)); +} + + +/** + * vot_setHandle -- Assign the Element a handle_t (private method) + * + * @brief Assign the Element a handle_t (private method) + * @fn handle_t vot_setHandle (Element *elem) + * + * @param elem A pointer to an Element to be assigned a handle_t. + * @return A handle_t refering to elem + */ +handle_t +vot_setHandle (Element *elem) +{ + unsigned int i = 0; + Element **old_handles; + + if (elem == NULL) + return (0); + + if (handleCount == handleMax) { + old_handles = handles; + handles = (Element **) calloc ((handleMax + HANDLE_INCREMENT + 1), + sizeof(Element *)); + + for (i = 0; i < handleMax; i++) + handles[i] = old_handles[i]; + + handleMax = handleMax + HANDLE_INCREMENT; + free (old_handles); + } + + for (i = handleCount+1; i >= 0; i--) { + if (handles[i] == NULL) { + elem->handle = i + 1; + handles[i] = elem; + handleCount++; + return ((i + 1)); + } + } + + /* If we get this far, it's an error condition. + */ + vot_handleError ("ERROR: Handle overflow."); + return (0); +} + + +/** + * vot_freeHandle -- Free a handle for use (private method) + * + * @brief Free a handle for use (private method) + * @fn vot_freeHandle (handle_t handle) + * + * @param handle A handle_t to the Element you wish to free + * @return nothing + */ +void +vot_freeHandle (handle_t handle) +{ + if (handle < handleMax) { + handles[(handle - 1)] = NULL; + handleCount--; + + } else + vot_handleError ("ERROR: Handle overflow."); +} + + +/** + * vot_getElement -- Get the Element refered to by handle_t (private method) + * + * @brief Get the Element refered to by handle_t (private method) + * @fn Element *vot_getElement (handle_t handle) + * + * @param handle A handle_t to the Element. + * @return A pointer to the requested Element. + */ +Element * +vot_getElement (handle_t handle) +{ + + if (handle == 0) + vot_handleError ("ERROR: Handle NULL."); + /*return (NULL);*/ + + else if (handle > handleMax) + vot_handleError ("ERROR: Handle overflow."); + + else if (handle < handleMax) + return (Element *) handles[(handle - 1)]; + + return (NULL); +} + + +/** + * vot_handleCleanup -- Free all the handle nodes (private method) + * + * @brief Free all the handle nodes (private method) + * @fn vot_handleCleanup (void) + * + * @return nothing + */ +void +vot_handleCleanup (void) +{ + unsigned int i = 0; + + for (i = 0; i < handleMax; i++) { + if (handles[i] != NULL) + free (handles[i]); + } + handleMax = 0; + handleCount = 0; + + free (handles); + handles = NULL; + + vot_newHandleTable (); /* FIXME ???? */ +} + + +/** + * vot_newHandleTable -- Initialize a handle table (private method) + * + * @brief Initialize a handle table (private method) + * @fn vot_newHandleTable (void) + * + * @return nothing + */ +void +vot_newHandleTable (void) +{ + if (handles == NULL) + handles = (Element **) calloc (HANDLE_INCREMENT, sizeof(Element *)); +} + + +/** + * vot_handleError -- Print an error message. + * + * @brief Print an error message. + * @fn vot_handleError (char *msg) + * + * @return nothing + */ +void +vot_handleError (char *msg) +{ + fprintf (stderr, "%s\n", msg); +} |