PrepGeomCacheBuilder()

static int PrepGeomCacheBuilder ( const LWGEOM *  lwgeom, GeomCache *  cache  )

static

Given a generic GeomCache, and a geometry to prepare, prepare a PrepGeomCache and stick it into the GeomCache->index slot.

The PrepGeomCache includes the original GEOS geometry, and the GEOS prepared geometry, and a pointer to the MemoryContext where the callback functions are registered.

This function is passed into the generic GetGeomCache function so that it can build an appropriate indexed structure in the case of a cache hit when there is no indexed structure yet available to return.

Definition at line 224 of file lwgeom_geos_prepared.c.

{
        PrepGeomCache* prepcache = (PrepGeomCache*)cache;
        PrepGeomHashEntry* pghe;
 
        /*
        * First time through? allocate the global hash.
        */
        if (!PrepGeomHash)
                CreatePrepGeomHash();
 
        /*
        * No callback entry for this statement context yet? Set it up
        */
        if ( ! prepcache->context_callback )
        {
                PrepGeomHashEntry pghe;
                MemoryContextCallback *callback;
                prepcache->context_callback = AllocSetContextCreate(prepcache->context_statement,
                                           "PostGIS Prepared Geometry Context",
                                           ALLOCSET_SMALL_SIZES);
 
                /* PgSQL comments suggest allocating callback in the context */
                /* being managed, so that the callback object gets cleaned along with */
                /* the context */
                callback = MemoryContextAlloc(prepcache->context_callback, sizeof(MemoryContextCallback));
                callback->arg = (void*)(prepcache->context_callback);
                callback->func = PreparedCacheDelete;
                MemoryContextRegisterResetCallback(prepcache->context_callback, callback);
 
                pghe.context = prepcache->context_callback;
                pghe.geom = 0;
                pghe.prepared_geom = 0;
                AddPrepGeomHashEntry( pghe );
        }
 
        /*
        * Hum, we shouldn't be asked to build a new cache on top of
        * an existing one. Error.
        */
        if ( prepcache->gcache.argnum || prepcache->geom || prepcache->prepared_geom )
        {
                lwpgerror("PrepGeomCacheBuilder asked to build new prepcache where one already exists.");
                return LW_FAILURE;
    }
 
        prepcache->geom = LWGEOM2GEOS( lwgeom , 0);
        if ( ! prepcache->geom ) return LW_FAILURE;
        prepcache->prepared_geom = GEOSPrepare( prepcache->geom );
        if ( ! prepcache->prepared_geom ) return LW_FAILURE;
        prepcache->gcache.argnum = cache->argnum;
 
        /*
        * In order to find the objects we need to destroy, we keep
        * extra references in a global hash object.
        */
        pghe = GetPrepGeomHashEntry(prepcache->context_callback);
        if ( ! pghe )
        {
                lwpgerror("PrepGeomCacheBuilder failed to find hash entry for context %p", (void *)prepcache->context_callback);
                return LW_FAILURE;
        }
 
        pghe->geom = prepcache->geom;
        pghe->prepared_geom = prepcache->prepared_geom;
 
        return LW_SUCCESS;
}

References AddPrepGeomHashEntry(), PrepGeomHashEntry::context, PrepGeomCache::context_callback, PrepGeomCache::context_statement, CreatePrepGeomHash(), PrepGeomCache::gcache, PrepGeomHashEntry::geom, PrepGeomCache::geom, GetPrepGeomHashEntry(), LW_FAILURE, LW_SUCCESS, LWGEOM2GEOS(), PrepGeomHashEntry::prepared_geom, PrepGeomCache::prepared_geom, PreparedCacheDelete(), and PrepGeomHash.

Here is the call graph for this function: