lwgeom_write_to_buffer()

static int lwgeom_write_to_buffer ( const LWGEOM *  geom, TWKB_GLOBALS *  globals, TWKB_STATE *  parent_state  )

static

Definition at line 429 of file lwout_twkb.c.

{
        int i, is_empty, has_z = 0, has_m = 0, ndims;
        size_t bbox_size = 0, optional_precision_byte = 0;
        uint8_t flag = 0, type_prec = 0;
        bytebuffer_t header_bytebuffer, geom_bytebuffer;
 
        TWKB_STATE child_state;
        memset(&child_state, 0, sizeof(TWKB_STATE));
        child_state.header_buf = &header_bytebuffer;
        child_state.geom_buf = &geom_bytebuffer;
        child_state.idlist = parent_state->idlist;
 
        bytebuffer_init_with_size(child_state.header_buf, 16);
        bytebuffer_init_with_size(child_state.geom_buf, 64);
 
        /* Read dimensionality from input */
        ndims = lwgeom_ndims(geom);
        is_empty = lwgeom_is_empty(geom);
        if ( ndims > 2 )
        {
                has_z = lwgeom_has_z(geom);
                has_m = lwgeom_has_m(geom);
        }
 
        /* Do we need extended precision? If we have a Z or M we do. */
        optional_precision_byte = (has_z || has_m);
 
        /* Both X and Y dimension use the same precision */
        globals->factor[0] = pow(10, globals->prec_xy);
        globals->factor[1] = globals->factor[0];
 
        /* Z and M dimensions have their own precisions */
        if ( has_z )
                globals->factor[2] = pow(10, globals->prec_z);
        if ( has_m )
                globals->factor[2 + has_z] = pow(10, globals->prec_m);
 
        /* Reset stats */
        for ( i = 0; i < MAX_N_DIMS; i++ )
        {
                /* Reset bbox calculation */
                child_state.bbox_max[i] = INT64_MIN;
                child_state.bbox_min[i] = INT64_MAX;
                /* Reset accumulated delta values to get absolute values on next point */
                child_state.accum_rels[i] = 0;
        }
 
        /* TYPE/PRECISION BYTE */
        if ( abs(globals->prec_xy) > 7 )
                lwerror("%s: X/Z precision cannot be greater than 7 or less than -7", __func__);
 
        /* Read the TWKB type number from the geometry */
        TYPE_PREC_SET_TYPE(type_prec, lwgeom_twkb_type(geom));
        /* Zig-zag the precision value before encoding it since it is a signed value */
        TYPE_PREC_SET_PREC(type_prec, zigzag8(globals->prec_xy));
        /* Write the type and precision byte */
        bytebuffer_append_byte(child_state.header_buf, type_prec);
 
        /* METADATA BYTE */
        /* Set first bit if we are going to store bboxes */
        FIRST_BYTE_SET_BBOXES(flag, (globals->variant & TWKB_BBOX) && ! is_empty);
        /* Set second bit if we are going to store resulting size */
        FIRST_BYTE_SET_SIZES(flag, globals->variant & TWKB_SIZE);
        /* There will be no ID-list (for now) */
        FIRST_BYTE_SET_IDLIST(flag, parent_state->idlist && ! is_empty);
        /* Are there higher dimensions */
        FIRST_BYTE_SET_EXTENDED(flag, optional_precision_byte);
        /* Empty? */
        FIRST_BYTE_SET_EMPTY(flag, is_empty);
        /* Write the header byte */
        bytebuffer_append_byte(child_state.header_buf, flag);
 
        /* EXTENDED PRECISION BYTE (OPTIONAL) */
        /* If needed, write the extended dim byte */
        if( optional_precision_byte )
        {
                uint8_t flag = 0;
 
                if ( has_z && ( globals->prec_z > 7 || globals->prec_z < 0 ) )
                        lwerror("%s: Z precision cannot be negative or greater than 7", __func__);
 
                if ( has_m && ( globals->prec_m > 7 || globals->prec_m < 0 ) )
                        lwerror("%s: M precision cannot be negative or greater than 7", __func__);
 
                HIGHER_DIM_SET_HASZ(flag, has_z);
                HIGHER_DIM_SET_HASM(flag, has_m);
                HIGHER_DIM_SET_PRECZ(flag, globals->prec_z);
                HIGHER_DIM_SET_PRECM(flag, globals->prec_m);
                bytebuffer_append_byte(child_state.header_buf, flag);
        }
 
        /* It the geometry is empty, we're almost done */
        if ( is_empty )
        {
                /* If this output is sized, write the size of */
                /* all following content, which is zero because */
                /* there is none */
                if ( globals->variant & TWKB_SIZE )
                        bytebuffer_append_byte(child_state.header_buf, 0);
 
                bytebuffer_append_bytebuffer(parent_state->geom_buf, child_state.header_buf);
                bytebuffer_destroy_buffer(child_state.header_buf);
                bytebuffer_destroy_buffer(child_state.geom_buf);
                return 0;
        }
 
        /* Write the TWKB into the output buffer */
        lwgeom_to_twkb_buf(geom, globals, &child_state);
 
        /*If we have a header_buf, we know that this function is called inside a collection*/
        /*and then we have to merge the bboxes of the included geometries*/
        /*and put the result to the parent (the collection)*/
        if( (globals->variant & TWKB_BBOX) && parent_state->header_buf )
        {
                LWDEBUG(4,"Merge bboxes");
                for ( i = 0; i < ndims; i++ )
                {
                        if(child_state.bbox_min[i]<parent_state->bbox_min[i])
                                parent_state->bbox_min[i] = child_state.bbox_min[i];
                        if(child_state.bbox_max[i]>parent_state->bbox_max[i])
                                parent_state->bbox_max[i] = child_state.bbox_max[i];
                }
        }
 
        /* Did we have a box? If so, how big? */
        bbox_size = 0;
        if( globals->variant & TWKB_BBOX )
        {
                LWDEBUG(4,"We want boxes and will calculate required size");
                bbox_size = sizeof_bbox(&child_state, ndims);
        }
 
        /* Write the size if wanted */
        if( globals->variant & TWKB_SIZE )
        {
                /* Here we have to add what we know will be written to header */
                /* buffer after size value is written */
                size_t size_to_register = bytebuffer_getlength(child_state.geom_buf);
                size_to_register += bbox_size;
                bytebuffer_append_uvarint(child_state.header_buf, size_to_register);
        }
 
        if( globals->variant & TWKB_BBOX )
                write_bbox(&child_state, ndims);
 
        bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.header_buf);
        bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.geom_buf);
 
        bytebuffer_destroy_buffer(child_state.header_buf);
        bytebuffer_destroy_buffer(child_state.geom_buf);
        return 0;
}

References TWKB_STATE::accum_rels, TWKB_STATE::bbox_max, TWKB_STATE::bbox_min, bytebuffer_append_byte(), bytebuffer_append_bytebuffer(), bytebuffer_append_uvarint(), bytebuffer_destroy_buffer(), bytebuffer_getlength(), bytebuffer_init_with_size(), TWKB_GLOBALS::factor, FIRST_BYTE_SET_BBOXES, FIRST_BYTE_SET_EMPTY, FIRST_BYTE_SET_EXTENDED, FIRST_BYTE_SET_IDLIST, FIRST_BYTE_SET_SIZES, TWKB_STATE::geom_buf, TWKB_STATE::header_buf, HIGHER_DIM_SET_HASM, HIGHER_DIM_SET_HASZ, HIGHER_DIM_SET_PRECM, HIGHER_DIM_SET_PRECZ, TWKB_STATE::idlist, LWDEBUG, lwerror(), lwgeom_has_m(), lwgeom_has_z(), lwgeom_is_empty(), lwgeom_ndims(), lwgeom_to_twkb_buf(), lwgeom_twkb_type(), MAX_N_DIMS, TWKB_GLOBALS::prec_m, TWKB_GLOBALS::prec_xy, TWKB_GLOBALS::prec_z, sizeof_bbox(), TWKB_BBOX, TWKB_SIZE, TYPE_PREC_SET_PREC, TYPE_PREC_SET_TYPE, TWKB_GLOBALS::variant, write_bbox(), and zigzag8().

Referenced by lwcollection_to_twkb_buf(), and lwgeom_to_twkb_with_idlist().

Here is the call graph for this function:

Here is the caller graph for this function: