C++ (Cpp) strm_emit Examples

Example #1

File: iter.c Project: matz/streem

static int
iter_consec(strm_stream* strm, strm_value data)
{
  struct slice_data* d = strm->data;
  strm_int n = d->n;

  if (d->i < n) {
    d->buf[d->i++] = data;
    if (d->i == n) {
      strm_array ary = strm_ary_new(d->buf, n);
      strm_emit(strm, strm_ary_value(ary), NULL);
    }
    return STRM_OK;
  }
  else {
    strm_array ary;
    strm_int i;
    strm_int len = n-1;

    for (i=0; i<len; i++) {
      d->buf[i] = d->buf[i+1];
    }
    d->buf[len] = data;
    ary = strm_ary_new(d->buf, n);
    strm_emit(strm, strm_ary_value(ary), NULL);
  }
  return STRM_OK;
}

Example #2

File: iter.c Project: matz/streem

static int
gen_repeat(strm_stream* strm, strm_value data)
{
  struct repeat_data *d = strm->data;

  d->count--;
  if (d->count == 0) {
    strm_emit(strm, d->v, NULL);
    strm_stream_close(strm);
  }
  else {
    strm_emit(strm, d->v, gen_repeat);
  }
  return STRM_OK;
}

Example #3

File: exec.c Project: likeog/streem

static int
blk_exec(strm_task* task, strm_value data)
{
  strm_lambda lambda = task->data;
  strm_value ret = strm_nil_value();
  node_args* args = (node_args*)lambda->body->args;
  int n;
  strm_state c = {0};

  c.task = task;
  c.prev = lambda->state;
  if (args) {
    assert(args->len == 1);
    strm_var_set(&c, node_to_sym(args->data[0]), data);
  }

  n = exec_expr(&c, lambda->body->compstmt, &ret);
  if (n) return STRM_NG;
  if (lambda->state->exc) {
    if (lambda->state->exc->type == NODE_ERROR_RETURN) {
      ret = lambda->state->exc->arg;
      free(lambda->state->exc);
      lambda->state->exc = NULL;
    } else {
      return STRM_NG;
    }
  }
  strm_emit(task, ret, NULL);
  return STRM_OK;
}

Example #4

File: exec.c Project: cbforks/streem

static int
blk_exec(strm_stream* strm, strm_value data)
{
  strm_lambda lambda = strm->data;
  strm_value ret = strm_nil_value();
  node_args* args = (node_args*)lambda->body->args;
  node_error* exc;
  int n;
  strm_state c = {0};

  c.prev = lambda->state;
  if (args) {
    assert(args->len == 1);
    strm_var_set(&c, node_to_sym(args->data[0]), data);
  }

  n = exec_expr(strm, &c, lambda->body->compstmt, &ret);
  exc = strm->exc;
  if (exc) {
    if (exc->type == NODE_ERROR_RETURN) {
      ret = exc->arg;
      strm_clear_exc(strm);
    }
    else {
      if (strm_option_verbose) {
        strm_eprint(strm);
      }
      return STRM_NG;
    }
  }
  if (n) return STRM_NG;
  strm_emit(strm, ret, NULL);
  return STRM_OK;
}

Example #5

File: exec.c Project: fenglyu/streem

static void
blk_exec(strm_task* task, strm_value data)
{
  strm_lambda *lambda = task->data;
  strm_value ret = strm_nil_value();
  node_values* args = (node_values*)lambda->body->args;
  int n;
  strm_state c = {0};

  c.task = task;
  c.prev = lambda->state;
  assert(args->len == 1);
  strm_var_set(&c, (strm_string*)args->data[0], data);

  n = exec_expr(&c, lambda->body->compstmt, &ret);
  if (n) return;
  if (lambda->state->exc) {
    if (lambda->state->exc->type == NODE_ERROR_RETURN) {
      ret = lambda->state->exc->arg;
      free(lambda->state->exc);
      lambda->state->exc = NULL;
    } else {
      return;
    }
  }
  strm_emit(task, ret, NULL);
}

Example #6

File: stat.c Project: byelipk/streem

static int
avg_finish(strm_stream* strm, strm_value data)
{
  struct sum_data* d = strm->data;

  strm_emit(strm, strm_flt_value(d->sum/d->num), NULL);
  return STRM_OK;
}

Example #7

File: iter.c Project: matz/streem

static int
minmax_finish(strm_stream* strm, strm_value data)
{
  struct minmax_data* d = strm->data;

  strm_emit(strm, d->data, NULL);
  return STRM_OK;
}

Example #8

File: exec.c Project: fenglyu/streem

static void
arr_exec(strm_task* task, strm_value data)
{
  struct array_data *arrd = task->data;
  strm_emit(task, arrd->arr->ptr[arrd->n++], NULL);
  if (arrd->n == arrd->arr->len)
    strm_task_close(task);
}

Example #9

File: iter.c Project: matz/streem

static int
iter_uniq(strm_stream* strm, strm_value data)
{
  struct uniq_data* d = strm->data;

  if (!d->init) {
    d->init = TRUE;
    d->last = data;
    strm_emit(strm, data, NULL);
    return STRM_OK;
  }
  if (!strm_value_eq(data, d->last)) {
    d->last = data;
    strm_emit(strm, data, NULL);
  }
  return STRM_OK;
}

Example #10

File: stat.c Project: byelipk/streem

static int
var_finish(strm_stream* strm, strm_value data)
{
  struct stdev_data* d = strm->data;
  double s = d->s2 / (d->num-1);
  strm_emit(strm, strm_flt_value(s), NULL);
  return STRM_OK;
}

Example #11

File: iter.c Project: matz/streem

static int
count_finish(strm_stream* strm, strm_value data)
{
  struct count_data* d = strm->data;

  strm_emit(strm, strm_int_value(d->count), NULL);
  free(d);
  return STRM_OK;
}

Example #12

File: iter.c Project: matz/streem

static int
reduce_finish(strm_stream* strm, strm_value data)
{
  struct reduce_data* d = strm->data;

  if (!d->init) return STRM_NG;
  strm_emit(strm, d->acc, NULL);
  return STRM_OK;
}

Example #13

File: exec.c Project: fenglyu/streem

static void
cfunc_exec(strm_task* task, strm_value data)
{
  strm_value ret;
  exec_cfunc func = task->data;
  strm_state c = {0};

  if ((*func)(&c, 1, &data, &ret) == STRM_OK) {
    strm_emit(task, ret, NULL);
  }
}

Example #14

File: iter.c Project: matz/streem

static int
iter_drop(strm_stream* strm, strm_value data)
{
  struct take_data* d = strm->data;

  if (d->n > 0) {
    d->n--;
    return STRM_OK;
  }
  strm_emit(strm, data, NULL);
  return STRM_OK;
}

Example #15

File: exec.c Project: likeog/streem

static int
arr_exec(strm_task* task, strm_value data)
{
  struct array_data *arrd = task->data;

  if (arrd->n == strm_ary_len(arrd->arr)) {
    strm_task_close(task);
    return STRM_OK;
  }
  strm_emit(task, strm_ary_ptr(arrd->arr)[arrd->n++], arr_exec);
  return STRM_OK;
}

Example #16

File: iter.c Project: matz/streem

static int
iter_take(strm_stream* strm, strm_value data)
{
  struct take_data* d = strm->data;

  strm_emit(strm, data, NULL);
  d->n--;
  if (d->n == 0) {
    strm_stream_close(strm);
  }
  return STRM_OK;
}

Example #17

File: iter.c Project: matz/streem

static int
iter_map(strm_stream* strm, strm_value data)
{
  struct map_data* d = strm->data;
  strm_value val;

  if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
    return STRM_NG;
  }
  strm_emit(strm, val, NULL);
  return STRM_OK;
}

Example #18

File: exec.c Project: chadbrewbaker/streem

static int
arr_exec(strm_task* task, strm_value data)
{
  struct array_data *arrd = task->data;

  if (arrd->n == arrd->arr->len) {
    strm_task_close(task);
    return STRM_OK;
  }
  strm_emit(task, arrd->arr->ptr[arrd->n++], arr_exec);
  return STRM_OK;
}

Example #19

File: exec.c Project: cbforks/streem

static int
cfunc_exec(strm_stream* strm, strm_value data)
{
  strm_value ret;
  strm_cfunc func = strm->data;

  if ((*func)(strm, 1, &data, &ret) == STRM_OK) {
    strm_emit(strm, ret, NULL);
    return STRM_OK;
  }
  return STRM_NG;
}

Example #20

File: exec.c Project: cbforks/streem

static int
arr_exec(strm_stream* strm, strm_value data)
{
  struct array_data *arrd = strm->data;

  if (arrd->n == strm_ary_len(arrd->arr)) {
    strm_stream_close(strm);
    return STRM_OK;
  }
  strm_emit(strm, strm_ary_ptr(arrd->arr)[arrd->n++], arr_exec);
  return STRM_OK;
}

Example #21

File: stat.c Project: byelipk/streem

static int
finish_sample(strm_stream* strm, strm_value data)
{
  struct sample_data* d = strm->data;
  strm_int i, len=d->len;

  for (i=0; i<len; i++) {
    strm_emit(strm, d->samples[i], NULL);
  }
  free(d);
  return STRM_OK;
}

Example #22

File: stat.c Project: byelipk/streem

static int
correl_finish(strm_stream* strm, strm_value data)
{
  struct correl_data* d = strm->data;

  d->n--;
  double sxx = sqrt(d->sxx / d->n);
  double syy = sqrt(d->syy / d->n);
  double sxy = d->sxy / (d->n * sxx * syy);
  strm_emit(strm, strm_flt_value(sxy), NULL);
  return STRM_OK;
}

Example #23

File: seq.c Project: mySingleLive/streem

static int
seq_seed(strm_task* task, strm_value data)
{
  struct seq_seeder *s = task->data;

  if (s->n > s->end) {
    strm_task_close(task);
    return STRM_OK;
  }
  strm_emit(task, strm_int_value(s->n), seq_seed);
  s->n += s->inc;
  return STRM_OK;
}

Example #24

File: exec.c Project: likeog/streem

static int
cfunc_exec(strm_task* task, strm_value data)
{
  strm_value ret;
  strm_cfunc func = task->data;
  strm_state c = {0};

  if ((*func)(&c, 1, &data, &ret) == STRM_OK) {
    strm_emit(task, ret, NULL);
    return STRM_OK;
  }
  return STRM_NG;
}

Example #25

File: iter.c Project: cbforks/streem

static int
gen_seq(strm_stream* strm, strm_value data)
{
  struct seq_data* d = strm->data;

  if (d->end > 0 && d->n > d->end) {
    strm_stream_close(strm);
    return STRM_OK;
  }
  strm_emit(strm, strm_int_value(d->n), gen_seq);
  d->n += d->inc;
  return STRM_OK;
}

Example #26

File: iter.c Project: matz/streem

static int
finish_slice(strm_stream* strm, strm_value data)
{
  struct slice_data* d = strm->data;

  if (d->i > 0) {
    strm_array ary = strm_ary_new(d->buf, d->i);
    strm_emit(strm, strm_ary_value(ary), NULL);
  }
  free(d->buf);
  free(d);
  return STRM_OK;
}

Example #27

File: iter.c Project: matz/streem

static int
iter_filter(strm_stream* strm, strm_value data)
{
  struct map_data* d = strm->data;
  strm_value val;

  if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
    return STRM_NG;
  }
  if (strm_value_bool(val)) {
    strm_emit(strm, data, NULL);
  }
  return STRM_OK;
}

Example #28

File: iter.c Project: matz/streem

static int
iter_uniqf(strm_stream* strm, strm_value data)
{
  struct uniq_data* d = strm->data;
  strm_value val;

  if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
    return STRM_NG;
  }
  if (!d->init) {
    d->init = TRUE;
    d->last = data;
    d->v = val;
    strm_emit(strm, data, NULL);
    return STRM_OK;
  }
  if (!strm_value_eq(val, d->v)) {
    d->last = data;
    d->v = val;
    strm_emit(strm, data, NULL);
  }
  return STRM_OK;
}

Example #29

File: iter.c Project: matz/streem

static int
gen_cycle(strm_stream* strm, strm_value data)
{
  struct cycle_data *d = strm->data;
  strm_value* p;
  strm_int i, len;

  d->count--;
  p = strm_ary_ptr(d->ary);
  len = strm_ary_len(d->ary);
  if (d->count != 0) {
    len--;
  }
  for (i=0; i<len; i++) {
    strm_emit(strm, p[i], NULL);
  }
  if (d->count == 0) {
    strm_stream_close(strm);
  }
  else {
    strm_emit(strm, p[i], gen_cycle);
  }
  return STRM_OK;
}

Example #30

File: iter.c Project: matz/streem

static int
iter_slice(strm_stream* strm, strm_value data)
{
  struct slice_data* d = strm->data;
  strm_int n = d->n;

  d->buf[d->i++] = data;
  if (d->i == n) {
    strm_array ary = strm_ary_new(d->buf, n);

    d->i = 0;
    strm_emit(strm, strm_ary_value(ary), NULL);
  }
  return STRM_OK;
}