F5contenttype.c

Go to the documentation of this file.

/*
 *
 * $Id: F5contenttype.c,v 1.9 2007/10/04 16:37:50 werner Exp $
 *
 */
 
#include "F5private.h"
#include "F5C.h"
#include "F5X.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
 
/* Author: SteffenProhaska */
int F5Cset (F5Path* fpath, const char* fieldname, const char* content_type) {
    int ok = 1;
    const int len = strlen (content_type);
    hid_t attr_type = -1;
    hid_t attr_space = -1;
    hid_t attr_id = -1;
    hid_t attr_size = 0;
    hid_t FieldTable = -1;
    hid_t FieldInfo = -1;
 
    if (len > FIBER_CONTENT_TYPE_MAXTAGLEN) {
        ok = 0;
    }
 
    if (ok && ((attr_type = H5Tcopy (H5T_C_S1)) < 0)) {
        ok = 0;
    }
 
    attr_size = len + 1;
 
    if (ok && (H5Tset_size (attr_type, (size_t)attr_size) < 0 )) {
        ok = 0;
    }
 
    if (ok && (H5Tset_strpad (attr_type, H5T_STR_NULLTERM) < 0 )) {
        ok = 0;
    }
 
    if (ok && (attr_space = H5Screate (H5S_SCALAR)) < 0) {
        ok = 0;
    }
 
    /* Creating Field content_type information per Grid */
    if (ok && (FieldTable = F5Gappend (fpath->Grid_hid, FIBER_FIELDS_TAG)) < 0)
    {
        ok = 0;
    }
 
    if (ok && (FieldInfo  = F5Gappend (FieldTable, fieldname)) < 0)
    {
        ok = 0;
    }
 
    if (ok) {
            enum { attr_name_bufsize = 20 };
        char attr_name[attr_name_bufsize];
        const int attnum = H5Aget_num_attrs (FieldInfo);
 
        assert (attr_name_bufsize > (strlen (FIBER_CONTENT_TYPE_TAG) + 1 + 3));
 
        sprintf (attr_name, "%s%03d", FIBER_CONTENT_TYPE_TAG, attnum);
        if ((attr_id = H5Acreate2(FieldInfo, attr_name, attr_type, attr_space, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
            ok = 0;
        }
    }
 
    if (ok && H5Awrite (attr_id, attr_type, content_type) < 0) {
        ok = 0;
    }
 
    if (attr_id >= 0) {
       H5Aclose (attr_id);
    }
    if (FieldInfo >= 0) {
        H5Gclose(FieldInfo);
    }
    if (FieldTable >= 0) {
        H5Gclose(FieldTable);
    }
    if (attr_space >= 0) {
        H5Sclose (attr_space);
    }
    if (attr_type >= 0) {
        H5Tclose (attr_type);
    }
 
    if (!ok) {
        return -1;
    }
    return 1;
}
 
/* Author: SteffenProhaska
 
   todo:
    - separate into a function which only assembles all objects
    - ignore objects starting with '_' (to be discussed)
    - use the new function here
   todo:
    - separate DArray stuff
 */
int F5Cget_fields (F5Path* fpath, size_t* count, char*** names) {
    int ok = 1;
    char* buffer = 0;
    hid_t FieldTable = -1;
    hsize_t num_objs = 0;
    int bufsize = 0;
    int nextidx = 0;
    int i;
 
    if (ok && (FieldTable = F5Gappend (fpath->Grid_hid, FIBER_FIELDS_TAG)) < 0)
    {
        ok = 0;
    }
    if (ok && (H5Gget_num_objs (FieldTable, &num_objs)) < 0)
    {
        ok = 0;
    }
    /* allocate a buffer which will take all the strings and the array of pointers to them */
    assert (sizeof (int) <= sizeof (void*));
 
    bufsize = num_objs * (sizeof (void*) + 20);
    nextidx = num_objs * sizeof(void*);
    if (ok && num_objs > 0 && (buffer = (char*)malloc (bufsize)) == 0) {
        ok = 0;
    }
    for (i = 0; i < num_objs; i++) {
        const int len = H5Gget_objname_by_idx (FieldTable, i, 0, 0);
        /* realloc until we have enough space */
        while (nextidx + len + 1 >= bufsize) {
            void* newbuf = 0;
            bufsize = (int)((float)bufsize * 1.2);
            newbuf = realloc (buffer, bufsize);
            if (!newbuf) {
                ok = 0;
                break;
            }
            buffer = (char*)newbuf;
        }
        /* todo understand the len stuff perhaps + 1 is not needed */
        if (H5Gget_objname_by_idx (FieldTable, i, buffer + nextidx, len + 1) <= 0) {
            ok = 0;
            break;
        };
        ((int*)buffer)[i] = nextidx;
        nextidx += len + 1;
    }
    /* now fill in the array of pointers to the strings */
    if (ok) {
        for (i = num_objs - 1; i >= 0; i--) {
            const int index = ((int*)buffer)[i];
            ((char**)buffer)[i] = buffer + index;
        }
    }
    if (FieldTable >= 0) {
        H5Gclose(FieldTable);
    }
    if (!ok) {
        free (buffer);
        return -1;
    }
    *count = num_objs;
    *names = (char**)buffer;
    return 1;
}
 
/* Author: SteffenProhaska
 
   Todo:
     - separate into a function which gets all string attributes
     - check attribute type
     - use this new function here
 */
int F5Cget_content_types (F5Path* fpath, const char* fieldname, size_t* count, char*** names) {
    int ok = 1;
    char* buffer = 0;
    hid_t FieldTable = -1;
    hid_t FieldInfo = -1;
    hid_t attr_id = -1;
    hid_t type_id = -1;
    hsize_t num_attrs = 0;
    int bufsize = 0;
    int nextidx = 0;
    int i;
 
    if (ok && (FieldTable = F5Gappend (fpath->Grid_hid, FIBER_FIELDS_TAG)) < 0)
    {
        ok = 0;
    }
    if (ok && (FieldInfo  = F5Gappend (FieldTable, fieldname)) < 0)
    {
        ok = 0;
    }
 
    if (ok) {
        num_attrs = H5Aget_num_attrs (FieldInfo);
    }
    /* allocate a buffer which will take all the strings and the array of pointers to them */
    assert (sizeof (int) <= sizeof (void*));
 
    bufsize = num_attrs * (sizeof (void*) + 50);
    nextidx = num_attrs * sizeof(void*);
    if (ok && num_attrs > 0 && (buffer = (char*)malloc (bufsize)) == 0) {
        ok = 0;
    }
    for (i = 0; i < num_attrs; i++) {
        if ((attr_id = H5Aopen_idx (FieldInfo, i)) < 0) {
            ok = 0;
            break;
        };
        if ((type_id = H5Aget_type (attr_id)) < 0) {
            ok = 0;
            break;
        }
        {
            size_t size = H5Tget_size (type_id);
 
            /* realloc until we have enough space */
            while (nextidx + size >= bufsize) {
                void* newbuf = 0;
                bufsize = (int)((float)bufsize * 1.2);
                newbuf = realloc (buffer, bufsize);
                if (!newbuf) {
                    ok = 0;
                    break;
                }
                buffer = (char*)newbuf;
            }
            if (H5Aread (attr_id, type_id, buffer + nextidx) < 0) {
                ok = 0;
                break;
            };
            ((int*)buffer)[i] = nextidx;
            nextidx += size;
        }
        H5Tclose (type_id);
        type_id = -1;
        H5Aclose (attr_id);
        attr_id = -1;
    }
    /* now fill in the array of pointers to the strings */
    if (ok) {
        for (i = num_attrs - 1; i >= 0; i--) {
            const int index = ((int*)buffer)[i];
            ((char**)buffer)[i] = buffer + index;
        }
    }
    if (type_id >= 0) {
        H5Tclose (type_id);
    }
    if (attr_id >= 0) {
        H5Aclose (attr_id);
    }
    if (FieldTable >= 0) {
        H5Gclose(FieldTable);
    }
    if (FieldInfo >= 0) {
        H5Gclose(FieldInfo);
    }
    if (!ok) {
        free (buffer);
        return -1;
    }
    *count = num_attrs;
    *names = (char**)buffer;
    return 1;
}
 
int F5Cparse_version_string (const char* version_string, char* str, size_t size
                                    , int* major, int* minor, int* patch, const char** remainder) {
    const char* run = version_string;
    int stridx = 0;
    int matches = 0;
    int numbers[3];
    numbers[0] = 0;
    numbers[1] = 0;
    numbers[2] = 0;
 
    while (*run && *run != '-' && *run != '/') {
        stridx++;
        run++;
    }
    if (*run != '-') {
        return -1;
    }
    run++;
 
    while (matches < 3) {
        if (!isdigit (*run)) {
            return -1;
        }
        numbers[matches] = atoi (run);
        matches++;
        while (isdigit (*run)) {
            run++;
        }
        if (*run == '/' || *run == '\0') {
                /* set version numbers */
            *major = numbers[0];
            *minor = numbers[1];
            *patch = numbers[2];
            /* copy name */
            {
                size_t num = stridx;
                if (num > size - 1) {
                    num = size - 1;
                }
                if (num > 0) {
                    memcpy (str, version_string, num);
                    str[num] = '\0';
                } else if (size > 0) {
                    str[0] = '\0';
                }
            }
            if (remainder) {
                if (*run == '/') {
                    *remainder = run + 1;
                } else {
                    *remainder = run;
                }
            }
            return 1;
        }
        if (*run != '.') {
            return -1;
        }
        run++;
    }
    return -1;
}
 
/* A list of strings a valid F5 url might start with.
 * Without the F5-MAJOR.MINOR.PATCH part
 *
 * You should only add to this list and never remove
 * a string. Otherwise it would break backward
 * compatibility.
 *
 */
static const char* valid_f5_urls[] = {
    "http://www.fiberbundle.net/"
    , 0
};
 
int F5Cget_version (const char* content_type, int* major, int* minor, int* patch, const char** remainder) {
    const char** url_starts;
    for (url_starts = valid_f5_urls; *url_starts; url_starts++) {
        const char* start = *url_starts;
        const int len = strlen (start);
 
        if (strncmp (content_type, start, len) == 0) {
            int maj, min, pat;
            char buf[20];
            int err;
            const char* rem;
            err = F5Cparse_version_string (content_type + len, buf, 20, &maj, &min, &pat, &rem);
            if (err > 0 && strcmp ("F5", buf) == 0) {
                *major = maj;
                *minor = min;
                *patch = pat;
                if (remainder) {
                    *remainder = rem;
                }
                return 1;
            }
        }
    }
    return -1;
}
 
int F5Cget_subspec (const char* content_type, char* str, size_t size
                                , int* major, int* minor, int* patch
                                , const char** remainder) {
    int maj, min, pat;
    int err;
    const char* rem;
    err = F5Cget_version (content_type, &maj, &min, &pat, &rem);
    if (err >= 0) {
        err = F5Cparse_version_string (rem, str, size, major, minor, patch, remainder);
    }
    return err;
}