Ejemplos de parseCL en C++ (Cpp)

Ejemplo n.º 1

Archivo: mem_io_retrieve.c Proyecto: gjbex/mem_io

int main(int argc, char *argv[]) {
    Params params;
    initCL(&params);
    parseCL(&params, &argc, &argv);
    char *mem_io_id = mem_io_get_id(&params);
    mem_io_merge_params(mem_io_id, &params);
    if (params.verbose)
        dumpCL(stderr, "# ", &params);
    redisContext *context = mem_io_connect(params.host, params.port,
                                           params.timeout);
    mem_io_auth(context, params.password);
    int nr_channels = mem_io_get_nr_channels(context, mem_io_id);
    if (0 <= params.channel_id) {
        if (params.verbose)
            fprintf(stderr, "# retrieving data from channel %d\n",
                    params.channel_id);
        if (params.channel_id >= nr_channels)
            errx(INVALID_CHANNEL_ERROR, "invalid channel ID %d",
                 params.channel_id);
        retrieve_channel(context, mem_io_id, params.channel_id,
                         stdout, &params, true);
    } else {
        FILE *fp = stdout;
        if (params.verbose)
            fprintf(stderr, "# retrieving data from %d channels\n",
                    nr_channels);
        int width = 1 + (int) log10(nr_channels);
        bool add_eol = !params.split;
        for (int channel_id = 0; channel_id < nr_channels;
                channel_id++) {
            if (params.split) {
                char file_name[MAX_LENGTH];
                snprintf(file_name, MAX_LENGTH, "data_%s_%0*d.dat",
                         mem_io_id, width, channel_id);
                fp = fopen(file_name, "w");
                if (fp == NULL) {
                    err(EXIT_FAILURE, "can not open file '%s' for write",
                        file_name);
                    continue;
                }
            }
            retrieve_channel(context, mem_io_id, channel_id, fp,
                             &params, add_eol);
            if (params.split) {
                fclose(fp);
            }
        }
    }
    mem_io_disconnect(context);
    free(mem_io_id);
    finalizeCL(&params);
    return EXIT_SUCCESS;
}

Ejemplo n.º 2

Archivo: reader.c Proyecto: vsb1357/IoTests

int main(int argc, char *argv[]) {
    Params params;
    struct timeval startTime, endTime;
    double total_time;
    long total_bytes;
    initCL(&params);
    parseCL(&params, &argc, &argv);
    validateCL(&params);
    gettimeofday(&startTime, NULL);
    if (params.buffer > 0) {
        if (strncmp(params.mode, "text", 6) == 0) {
            read_text_buffered(params.file, params.buffer);
        } else if (strncmp(params.mode, "binary", 6) == 0) {
            read_binary_buffered(params.file, params.buffer);
        } else if (strncmp(params.mode, "hdf5", 4) == 0) {
            read_hdf5_buffered(params.file, params.buffer);
        } else {
            errx(EXIT_FAILURE, "unknown mode '%s' for buffered",
                    params.mode);
        }
    } else {
        if (strncmp(params.mode, "text", 4) == 0) {
            read_text(params.file);
        } else if (strncmp(params.mode, "binary", 6) == 0) {
            read_binary(params.file);
        } else if (strncmp(params.mode, "hdf5", 4) == 0) {
            read_hdf5(params.file);
        } else {
            errx(EXIT_FAILURE, "unknown mode '%s' for unbuffered I/O",
                    params.mode);
        }
    }
    gettimeofday(&endTime, NULL);
    total_time =  endTime.tv_sec - startTime.tv_sec +
        (endTime.tv_usec - startTime.tv_usec)*1e-6;
    total_bytes = get_size(params.file);
    printf("%s\t%ld\t%d\t%.6f\n", params.file, total_bytes, params.buffer,
            total_time);
    finalizeCL(&params);
    return EXIT_SUCCESS;
}

Ejemplo n.º 3

Archivo: mem_io_store.c Proyecto: gjbex/mem_io

int main(int argc, char *argv[]) {
    Params params;
    initCL(&params);
    parseCL(&params, &argc, &argv);
    char *mem_io_id = mem_io_get_id(&params);
    mem_io_merge_params(mem_io_id, &params);
    if (params.verbose)
        dumpCL(stderr, "# ", &params);
    redisContext *context = mem_io_connect(params.host, params.port,
                                           params.timeout);
    mem_io_auth(context, params.password);
    int nr_channels = mem_io_get_nr_channels(context, mem_io_id);
    if (params.channel_id < 0 || params.channel_id >= nr_channels)
        errx(INVALID_CHANNEL_ERROR, "channel ID %d is invalid",
             params.channel_id);
    char *status_key = mem_io_create_channel_status_key(mem_io_id,
                                                        params.channel_id);
    if (!mem_io_channel_status_is_set(context, status_key) ||
            !mem_io_is_channel_open(context, status_key)) {
        mem_io_open_channel(context, status_key);
        char buffer[BUFF_SIZE];
        char *key = mem_io_create_key(mem_io_id, params.channel_id);
        for (;;) {
            int count = fread(buffer, sizeof(char), BUFF_SIZE, stdin);
            if (count == 0)
                break;
            mem_io_push(context, key, buffer, count);
        }
        mem_io_close_channel(context, status_key);
        free(key);
    } else {
        errx(OPEN_CHANNEL_ERROR, "writing to open channel %d",
             params.channel_id);
    }
    mem_io_disconnect(context);
    free(status_key);
    free(mem_io_id);
    finalizeCL(&params);
    return EXIT_SUCCESS;
}