gserialized_cmp()

int gserialized_cmp ( const GSERIALIZED *  g1, const GSERIALIZED *  g2  )

extern

Return -1 if g1 is "less than" g2, 1 if g1 is "greater than" g2 and 0 if g1 and g2 are the "same".

Equality is evaluated with a memcmp and size check. So it is possible that two identical objects where one lacks a bounding box could be evaluated as non-equal initially. Greater and less than are evaluated by calculating a sortable key from the center point of the object bounds.

Definition at line 313 of file gserialized.c.

{
        GBOX box1, box2;
        uint64_t hash1, hash2;
        size_t sz1 = SIZE_GET(g1->size);
        size_t sz2 = SIZE_GET(g2->size);
        size_t hsz1 = gserialized_header_size(g1);
        size_t hsz2 = gserialized_header_size(g2);
        uint8_t *b1 = (uint8_t*)g1 + hsz1;
        uint8_t *b2 = (uint8_t*)g2 + hsz2;
        size_t bsz1 = sz1 - hsz1;
        size_t bsz2 = sz2 - hsz2;
        size_t bsz_min = bsz1 < bsz2 ? bsz1 : bsz2;
 
        /* Equality fast path */
        /* Return equality for perfect equality only */
        int cmp_srid = gserialized_cmp_srid(g1, g2);
        int cmp = memcmp(b1, b2, bsz_min);
        int g1hasz = gserialized_has_z(g1);
        int g1hasm = gserialized_has_m(g1);
        int g2hasz = gserialized_has_z(g2);
        int g2hasm = gserialized_has_m(g2);
 
        if (bsz1 == bsz2 && cmp_srid == 0 && cmp == 0 && g1hasz == g2hasz && g1hasm == g2hasm)
                return 0;
        else
        {
                int g1_is_empty = (gserialized_get_gbox_p(g1, &box1) == LW_FAILURE);
                int g2_is_empty = (gserialized_get_gbox_p(g2, &box2) == LW_FAILURE);
                int32_t srid1 = gserialized_get_srid(g1);
                int32_t srid2 = gserialized_get_srid(g2);
 
                /* Empty < Non-empty */
                if (g1_is_empty && !g2_is_empty)
                        return -1;
 
                /* Non-empty > Empty */
                if (!g1_is_empty && g2_is_empty)
                        return 1;
 
                if (!g1_is_empty && !g2_is_empty)
                {
                        /* Using the boxes, calculate sortable hash key. */
                        hash1 = gbox_get_sortable_hash(&box1, srid1);
                        hash2 = gbox_get_sortable_hash(&box2, srid2);
 
                        if (hash1 > hash2)
                                return 1;
                        if (hash1 < hash2)
                                return -1;
                }
 
                /* Prefix comes before longer one. */
                if (bsz1 != bsz2 && cmp == 0)
                {
                        if (bsz1 < bsz2)
                                return -1;
                        else if (bsz1 > bsz2)
                                return 1;
                }
 
                /* If SRID is not equal, sort on it */
                if (cmp_srid != 0)
                        return (srid1 > srid2) ? 1 : -1;
 
                /* ZM flag sort*/
                if (g1hasz != g2hasz)
                        return (g1hasz > g2hasz) ? 1 : -1;
 
                if (g1hasm != g2hasm)
                        return (g1hasm > g2hasm) ? 1 : -1;
 
                assert(cmp != 0);
                return cmp > 0 ? 1 : -1;
        }
}