C++ (Cpp) chainlen Examples

Example #1

File: widget_edit.c Project: 4nakin/freeciv-android

/**************************************************************************
  Delete UniChar structure.
**************************************************************************/
static void del_chain(struct UniChar *pChain)
{
  int i, len = 0;

  if (!pChain) {
    return;
  }

  len = chainlen(pChain);

  if (len > 1) {
    pChain = pChain->next;
    for (i = 0; i < len - 1; i++) {
      FREESURFACE(pChain->prev->pTsurf);
      FC_FREE(pChain->prev);
      pChain = pChain->next;
    }
  }

  FC_FREE(pChain);
}

Example #2

File: views.c Project: Tomas-M/iotop

struct xxxid_stats *create_diff(struct xxxid_stats *cs, struct xxxid_stats *ps, int *len)
{
    int diff_size = sizeof(struct xxxid_stats) * chainlen(cs);
    struct xxxid_stats *diff = malloc(diff_size);
    struct xxxid_stats *c;
    int n = 0;
    uint64_t xxx = ~0;

    memset(diff, 0, diff_size);

    for (c = cs; c; c = c->__next, n++)
    {
        struct xxxid_stats *p = findpid(ps, c->tid);

        if (!p)
        {
            // new process or task
            memcpy(&diff[n], c, sizeof(struct xxxid_stats));
            diff[n].read_bytes \
            = diff[n].write_bytes \
              = diff[n].swapin_delay_total \
                = diff[n].blkio_delay_total \
                  = 0;
            diff[n].__next = &diff[n + 1];
            continue;
        }

        memcpy(&diff[n], c, sizeof(struct xxxid_stats));

        // round robin value

#define RRV(to, from) {\
    to = (to < from)\
        ? xxx - to + from\
        : to - from;\
}
        RRV(diff[n].read_bytes, p->read_bytes);
        RRV(diff[n].write_bytes, p->write_bytes);

        RRV(diff[n].swapin_delay_total, p->swapin_delay_total);
        RRV(diff[n].blkio_delay_total, p->blkio_delay_total);

        static double pow_ten = 0;
        if (!pow_ten)
            pow_ten = pow(10, 9);

#undef RRV

        diff[n].blkio_val =
            (double) diff[n].blkio_delay_total / pow_ten / params.delay * 100;

        diff[n].swapin_val =
            (double) diff[n].swapin_delay_total / pow_ten / params.delay * 100;

        diff[n].read_val = (double) diff[n].read_bytes
                           / (config.f.accumulated ? 1 : params.delay);

        diff[n].write_val = (double) diff[n].write_bytes
                            / (config.f.accumulated ? 1 : params.delay);

        diff[n].__next = &diff[n + 1];
    }

    // No have previous data to calculate diff
    if (!n)
    {
        free(diff);
        return NULL;
    }

    diff[n - 1].__next = NULL;
    *len = n;

    return diff;
}

Example #3

File: views.c Project: Tomas-M/iotop

void sort_diff(struct xxxid_stats *d)
{
    int len = chainlen(d);
    int i;

    for (i = 0; i < len; i++)
    {
        int k;

        for (k = i; k < len; k++)
        {
            int found = 0;

#define CMP_FIELDS(field_name) (d[k].field_name > d[i].field_name)

            switch (sort_by)
            {
            case SORT_BY_PRIO:
                found = d[k].io_prio > d[i].io_prio;
                break;
            case SORT_BY_COMMAND:
                found = (strcmp(d[k].cmdline, d[i].cmdline) > 0);
                break;
            case SORT_BY_PID:
                found = CMP_FIELDS(tid);
                break;
            case SORT_BY_USER:
                found = CMP_FIELDS(euid);
                break;
            case SORT_BY_READ:
                found = CMP_FIELDS(read_val);
                break;
            case SORT_BY_WRITE:
                found = CMP_FIELDS(write_val);
                break;
            case SORT_BY_SWAPIN:
                found = CMP_FIELDS(swapin_val);
                break;
            case SORT_BY_IO:
                found = CMP_FIELDS(blkio_val);
                break;
            }

#undef CMP_FIELDS

            if (found)
            {
                static struct xxxid_stats tmp;

                memcpy(&tmp, &d[i], sizeof(struct xxxid_stats));
                memcpy(&d[i], &d[k], sizeof(struct xxxid_stats));
                memcpy(&d[k], &tmp, sizeof(struct xxxid_stats));
            }
        }
    }

    if (sort_order == SORT_ASC)
    {
        struct xxxid_stats *rev = malloc(sizeof(struct xxxid_stats) * len);
        for (i = 0; i < len; i++)
            memcpy(&rev[i], &d[len - i - 1], sizeof(struct xxxid_stats));
        memcpy(d, rev, sizeof(struct xxxid_stats) * len);
        free(rev);
    }

    for (i = 0; i < len; i++)
        d[i].__next = &d[i + 1];

    d[len - 1].__next = NULL;
}