view release on metacpan or  search on metacpan

build/lib/src/render_results.c  view on Meta::CPAN

        return 0;
    }

    for (unsigned int i = 0; i < nfields; ++i)
    {
        const char *s = neo4j_fieldname(results, i);
        size_t l = (s == NULL)? 0 : strlen(s);
        if (l > UINT_MAX-3)
        {
            l = UINT_MAX-3;
        }
        l += 3;
        if (widths[i] < l)
        {
            widths[i] = l;
        }
    }

    for (unsigned int depth = 0; depth < config->render_inspect_rows - 1;
            ++depth)
    {
        neo4j_result_t *result = neo4j_peek(results, depth);
        if (result == NULL)
        {
            break;
        }
        for (unsigned int i = 0; i < nfields; ++i)
        {
            neo4j_value_t value = neo4j_result_field(result, i);
            size_t l = 0;

            if (neo4j_type(value) == NEO4J_STRING &&
                    !(config->render_flags & NEO4J_RENDER_QUOTE_STRINGS))
            {
                l = neo4j_string_length(value);
            }
            else
            {
                l = value_tostring(&value, NULL, 0, config->render_flags);
            }
            if (l > UINT_MAX-3)
            {
                l = UINT_MAX-3;
            }
            l += 3;

            if (widths[i] < l)
            {
                widths[i] = l;
            }
        }
    }

    return 0;
}


ssize_t obtain_fieldname(void *data, unsigned int n, const char **s,
        bool *duplicate)
{
    struct obtain_fieldname_cb_data *cdata =
            (struct obtain_fieldname_cb_data *)data;
    *s = neo4j_fieldname(cdata->results, n);
    *duplicate = false;
    return (*s != NULL)? strlen(*s) : 0;
}


ssize_t obtain_result_field(void *data, unsigned int n, const char **s,
        bool *duplicate)
{
    struct obtain_result_field_cb_data *cdata =
            (struct obtain_result_field_cb_data *)data;
    neo4j_value_t value = neo4j_result_field(cdata->result, n);

    if (neo4j_type(value) == NEO4J_STRING &&
            !(cdata->flags & NEO4J_RENDER_QUOTE_STRINGS))
    {
        *s = neo4j_ustring_value(value);
        *duplicate = false;
        return neo4j_string_length(value);
    }

    *duplicate = true;
    return render_field_value(value, s, cdata->buffer, cdata->bufcap,
            cdata->flags);
}


ssize_t render_field_value(neo4j_value_t value, const char **s,
        char **buf, size_t *bufcap, uint_fast32_t flags)
{
    size_t length;
    do
    {
        length = value_tostring(&value, *buf, *bufcap, flags);
        if (length < *bufcap)
        {
            break;
        }

        size_t newcap = length + 80;
        char *newbuf = realloc(*buf, newcap);
        if (newbuf == NULL)
        {
            return -1;
        }
        *bufcap = newcap;
        *buf = newbuf;
    } while (true);

    *s = *buf;
    return length;
}


size_t value_tostring(neo4j_value_t *value, char *buf, size_t n,
        uint_fast32_t flags)
{
    if (!(flags & NEO4J_RENDER_SHOW_NULLS) && neo4j_is_null(*value))
    {
        if (n > 0)
        {
            assert(buf != NULL);
            buf[0] = '\0';
        }
        return 0;
    }
    return neo4j_ntostring(*value, buf, n);
}


int neo4j_render_csv(FILE *stream, neo4j_result_stream_t *results,
        uint_fast32_t flags)
{
    neo4j_config_t *config = neo4j_new_config();
    config->render_flags |= flags;
    int err = neo4j_render_results_csv(config, stream, results);
    neo4j_config_free(config);
    return err;
}


// deprecated
int neo4j_render_ccsv(const neo4j_config_t *config, FILE *stream,
        neo4j_result_stream_t *results)