log_csv.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
 
#include "log_numbers.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define LOG_MAX_COLUMNS 25
#define LOG_MAX_SERIES  4
#define LOG_NAME_MAX    28
#define LOG_SAMPLE_MAX  16
#define LOG_SAMPLES     3
#define LOG_ROW_MAX     1024
/* -------------------------------------------------------------- source --- */
 
 

typedef struct {
    size_t (*read)(void *ctx, char *buf, size_t max); 
    bool (*rewind)(void *ctx);          
    bool (*error)(void *ctx);
    void *ctx;
    bool (*size)(void *ctx, size_t *bytes);
    bool (*seek)(void *ctx, size_t offset);
} log_source_t;

typedef struct {
    const char *text;   
    size_t len;         
    size_t pos;         
} log_mem_ctx_t;

void log_source_memory(log_source_t *src, log_mem_ctx_t *ctx, const char *text,
                       size_t len);

void log_source_stdio(log_source_t *src, void *file);
/* --------------------------------------------------------------- rows ---- */
 
 

typedef struct {
    log_source_t *src;     
    char buf[256];         
    size_t len;            
    size_t pos;            
    bool eof;              
    bool started; 
    bool failed;  
    bool overflow;
    bool cut;     
} log_reader_t;

void log_reader_init(log_reader_t *r, log_source_t *src);

int log_reader_row(log_reader_t *r, char delimiter, char *store,
                   size_t store_size, char **fields, int max_fields,
                   int *total_fields);
/* ------------------------------------------------------------ analysis --- */
 
 
 
 

typedef enum {
    LOG_OK = 0,
    LOG_ERR_READ,
    LOG_ERR_NO_HEADER,
    LOG_ERR_NO_ROWS,
    LOG_ERR_NO_NUMERIC,
    LOG_ERR_TOO_MANY_COLUMNS,
    LOG_ERR_MEMORY,
    LOG_ERR_ARG
} log_err_t;

const char *log_err_str(log_err_t err);

typedef struct {
    char raw_header[LOG_NAME_MAX];   
    char name[LOG_NAME_MAX];         
    char unit[LOG_UNIT_MAX];         
    char sample[LOG_SAMPLES][LOG_SAMPLE_MAX];  
    int non_empty;                   
    int parsed;                      
    bool unit_from_values;           
    bool mixed_units;                
    bool numeric; 
    bool monotonic;                  
    double min;                      
    double max;                      
    double first;                    
    double last;                     
} log_column_t;

typedef struct {
    char delimiter;                  
    log_conv_t convention;           
    bool convention_forced;          
    bool convention_confident;       
    bool convention_conflict;        
    log_votes_t votes;               
    log_ambig_t ambiguous_as;        
 
    int n_columns;                   
    log_column_t columns[LOG_MAX_COLUMNS];  
 
    int time_index; 
    char time_unit[LOG_UNIT_MAX];    
 
    int row_count;                   
    int ragged_rows; 
    int long_rows;   
    int max_fields;                  
    bool truncated; 
    bool cut_row;
} log_analysis_t;

typedef struct {
    char delimiter;          
    log_conv_t convention;   
    log_ambig_t ambiguous_as;           
    int time_index;          
    const char *time_unit;   
    int max_rows;            
} log_csv_opts_t;

#define LOG_DEFAULT_MAX_ROWS 60000
#define LOG_TIME_AUTO (-2)

void log_csv_opts_default(log_csv_opts_t *opts);

extern const char log_csv_delimiters[4];

const char *log_csv_delimiter_label(char delimiter);

char log_csv_sniff(const char *sample, size_t len);

log_err_t log_csv_analyse(log_source_t *src, const log_csv_opts_t *opts,
                          log_analysis_t *out);
/* --------------------------------------------------------------- build --- */
 
 
 
 

typedef struct {
    char name[LOG_NAME_MAX];   
    char unit[LOG_UNIT_MAX];   
    char group[LOG_NAME_MAX];  
    int column;                
    float min;                 
    float max;                 
    bool constant;             
    bool mixed_units;          
} log_field_t;

typedef struct {
    int count;                 
    int n_fields;              
    float *time; 
    float *value[LOG_MAX_SERIES];  
    log_field_t field[LOG_MAX_SERIES];  
 
    char time_name[LOG_NAME_MAX];   
    char time_unit[LOG_UNIT_MAX];   
    log_conv_t convention;          
    char delimiter;                 
    int unparsed_cells;             
 
    double duration_s;              
    double median_dt_s;             
    double max_gap_s;               
    double rate_hz;                 
} log_data_t;

log_err_t log_csv_build(log_source_t *src, const log_analysis_t *a,
                        const int *columns, int n_columns, log_data_t *out);

void log_data_free(log_data_t *data);

void log_set_allocator(void *(*alloc_fn)(size_t), void (*free_fn)(void *));
 
#ifdef __cplusplus
}
#endif