gensvm_strutil.c

Go to the documentation of this file.

#include "gensvm_strutil.h"
#include "gensvm_print.h"

bool str_startswith(const char *str, const char *pre)
{
    size_t lenpre = strlen(pre),
           lenstr = strlen(str);
    return lenstr < lenpre ? false : strncmp(pre, str, lenpre) == 0;
}

bool str_endswith(const char *str, const char *suf)
{
    size_t lensuf = strlen(suf),
           lenstr = strlen(str);
    return lenstr < lensuf ? false : strncmp(str + lenstr - lensuf, suf,
            lensuf) == 0;
}

bool str_contains_char(const char *str, const char c)
{
    size_t i, len = strlen(str);
    for (i=0; i<len; i++)
        if (str[i] == c)
            return true;
    return false;
}

int count_str_occurrences(const char *str, const char *chars)
{
    size_t i, j, len_str = strlen(str),
        len_chars = strlen(chars);
    int count = 0;
    for (i=0; i<len_str; i++) {
        for (j=0; j<len_chars; j++) {
            count += (str[i] == chars[j]);
        }
    }
    return count;
}

char **str_split(char *original, const char *delims, int *len_ret)
{
    char *copy = NULL,
         *token = NULL,
         **result = NULL;
    int i, count;

    size_t len = strlen(original);
    size_t n_delim = strlen(delims);

    // add the null terminator to the delimiters
    char all_delim[1 + n_delim];
    for (i=0; i<n_delim; i++)
        all_delim[i] = delims[i];
    all_delim[n_delim] = '\0';

    // number of occurances of the delimiters
    count = count_str_occurrences(original, delims);

    // extra count in case there is a delimiter at the end
    count += (str_contains_char(delims, original[len - 1]));

    // extra count for the null terminator
    count++;

    // allocate the result array
    result = Calloc(char *, count);

    // tokenize a copy of the original string and keep the splits
    i = 0;
    copy = Calloc(char, len + 1);
    strcpy(copy, original);
    token = strtok(copy, all_delim);
    while (token) {
        result[i] = Calloc(char, strlen(token) + 1);
        strcpy(result[i], token);
        i++;

        token = strtok(NULL, all_delim);
    }
    free(copy);

    *len_ret = i;

    return result;
}

void next_line(FILE *fid, char *filename)
{
    char buffer[GENSVM_MAX_LINE_LENGTH];
    get_line(fid, filename, buffer);
}

char *get_line(FILE *fid, char *filename, char *buffer)
{
    char *retval = fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
    if (retval == NULL) {
        err("[GenSVM Error]: Error reading from file %s\n", filename);
    }
    return retval;
}

double get_fmt_double(FILE *fid, char *filename, const char *fmt)
{
    char buffer[GENSVM_MAX_LINE_LENGTH];
    double value = NAN;
    int retval;

    get_line(fid, filename, buffer);
    retval = sscanf(buffer, fmt, &value);
    if (retval == 0)
        err("[GenSVM Error]: No double read from file.\n");
    return value;
}

long get_fmt_long(FILE *fid, char *filename, const char *fmt)
{
    char buffer[GENSVM_MAX_LINE_LENGTH];
    long value = 0;
    int retval;

    get_line(fid, filename, buffer);
    retval = sscanf(buffer, fmt, &value);
    if (retval == 0)
        err("[GenSVM Error]: No long read from file.\n");
    return value;
}

long all_doubles_str(char *buffer, long offset, double *all_doubles)
{
    double value;
    long i = 0;
    char *start = NULL,
         *end = NULL;

    start = buffer + offset;
    while (true) {
        value = strtod(start, &end);
        if (start != end) {
            all_doubles[i] = value;
            i++;
        } else
            break;
        start = end;
        end = NULL;
    }

    return i;
}

long all_longs_str(char *buffer, long offset, long *all_longs)
{
    long value;
    long i = 0;
    char *start = NULL,
         *end = NULL;

    start = buffer + offset;
    while (true) {
        value = strtol(start, &end, 10);
        if (start != end) {
            all_longs[i] = value;
            i++;
        } else
            break;
        start = end;
        end = NULL;
    }

    return i;
}