// ----------------------------------------------------------------
static sllv_t* mapper_reorder_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_reorder_state_t* pstate = (mapper_reorder_state_t*)pvstate;
if (pinrec != NULL) {
if (!pstate->put_at_end) {
// OK since the field-name list was reversed at construction time.
for (sllse_t* pe = pstate->pfield_name_list->phead; pe != NULL; pe = pe->pnext)
lrec_move_to_head(pinrec, pe->value);
} else {
for (sllse_t* pe = pstate->pfield_name_list->phead; pe != NULL; pe = pe->pnext)
lrec_move_to_tail(pinrec, pe->value);
}
return sllv_single(pinrec);
} else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_nothing_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
if (pinrec != NULL) {
lrec_free(pinrec);
return NULL;
} else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_put_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
if (pinrec != NULL) {
mapper_put_state_t* pstate = (mapper_put_state_t*)pvstate;
for (int i = 0; i < pstate->num_evaluators; i++) {
// xxx decide ownership location for type conversions ...
mv_t val = pstate->pevaluators[i]->pevaluator_func(pinrec,
pctx, pstate->pevaluators[i]->pvstate);
char* string = mt_format_val(&val);
lrec_put(pinrec, pstate->output_field_names[i], string, LREC_FREE_ENTRY_VALUE);
free(string);
}
return sllv_single(pinrec);
}
else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
// xxx if empty key then make a way to communicate back to the reader that it
// can stop reading further records -- ?
static sllv_t* mapper_head_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_head_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
unsigned long long* pcount_for_group = lhmslv_get(pstate->precord_lists_by_group, pgroup_by_field_values);
if (pcount_for_group == NULL) {
pcount_for_group = mlr_malloc_or_die(sizeof(unsigned long long));
*pcount_for_group = 0LL;
lhmslv_put(pstate->precord_lists_by_group, slls_copy(pgroup_by_field_values), pcount_for_group);
}
(*pcount_for_group)++;
if (*pcount_for_group <= pstate->head_count) {
return sllv_single(pinrec);
} else {
lrec_free(pinrec);
return NULL;
}
}
else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_regularize_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
if (pinrec != NULL) {
mapper_regularize_state_t* pstate = (mapper_regularize_state_t*)pvstate;
slls_t* current_sorted_field_names = mlr_reference_keys_from_record(pinrec);
slls_sort(current_sorted_field_names);
slls_t* previous_sorted_field_names = lhmslv_get(pstate->psorted_to_original, current_sorted_field_names);
if (previous_sorted_field_names == NULL) {
previous_sorted_field_names = slls_copy(current_sorted_field_names);
lhmslv_put(pstate->psorted_to_original, previous_sorted_field_names, mlr_copy_keys_from_record(pinrec));
return sllv_single(pinrec);
} else {
lrec_t* poutrec = lrec_unbacked_alloc();
for (sllse_t* pe = previous_sorted_field_names->phead; pe != NULL; pe = pe->pnext) {
lrec_put(poutrec, pe->value, strdup(lrec_get(pinrec, pe->value)), LREC_FREE_ENTRY_VALUE);
}
lrec_free(pinrec);
return sllv_single(poutrec);
}
}
else {
return sllv_single(NULL);
}
}
static sllv_t* mapper_step_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_step_state_t* pstate = pvstate;
if (pinrec == NULL)
return sllv_single(NULL);
// ["s", "t"]
slls_t* pvalue_field_values = mlr_selected_values_from_record(pinrec, pstate->pvalue_field_names);
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
if (pgroup_by_field_values->length != pstate->pgroup_by_field_names->length) {
lrec_free(pinrec);
return NULL;
}
lhmsv_t* group_to_acc_field = lhmslv_get(pstate->groups, pgroup_by_field_values);
if (group_to_acc_field == NULL) {
group_to_acc_field = lhmsv_alloc();
lhmslv_put(pstate->groups, slls_copy(pgroup_by_field_values), group_to_acc_field);
}
sllse_t* pa = pstate->pvalue_field_names->phead;
sllse_t* pb = pvalue_field_values->phead;
// for x=1 and y=2
for ( ; pa != NULL && pb != NULL; pa = pa->pnext, pb = pb->pnext) {
char* value_field_name = pa->value;
char* value_field_sval = pb->value;
int have_dval = FALSE;
double value_field_dval = -999.0;
lhmsv_t* acc_field_to_acc_state = lhmsv_get(group_to_acc_field, value_field_name);
if (acc_field_to_acc_state == NULL) {
acc_field_to_acc_state = lhmsv_alloc();
lhmsv_put(group_to_acc_field, value_field_name, acc_field_to_acc_state);
}
// for "delta", "rsum"
sllse_t* pc = pstate->pstepper_names->phead;
for ( ; pc != NULL; pc = pc->pnext) {
char* step_name = pc->value;
step_t* pstep = lhmsv_get(acc_field_to_acc_state, step_name);
if (pstep == NULL) {
pstep = make_step(step_name, value_field_name);
if (pstep == NULL) {
fprintf(stderr, "mlr step: stepper \"%s\" not found.\n",
step_name);
exit(1);
}
lhmsv_put(acc_field_to_acc_state, step_name, pstep);
}
if (pstep->psprocess_func != NULL) {
pstep->psprocess_func(pstep->pvstate, value_field_sval, pinrec);
}
if (pstep->pdprocess_func != NULL) {
if (!have_dval) {
value_field_dval = mlr_double_from_string_or_die(value_field_sval);
have_dval = TRUE;
}
pstep->pdprocess_func(pstep->pvstate, value_field_dval, pinrec);
}
}
}
return sllv_single(pinrec);
}
