nitf_PluginRegistry_loadPlugin(const char* fullName, nitf_Error * error) { /* For now, the key is the dll name minus the extension */ char keyName[NITF_MAX_PATH] = ""; char* p; int ok; int i, begin, end; nitf_DLL *dll; char **ident; nitf_PluginRegistry* reg = nitf_PluginRegistry_getInstance(error); /* Construct the DLL object */ dll = nitf_DLL_construct(error); if (!dll) { return NITF_FAILURE; } /* Otherwise we can load the DLL */ if (!nitf_DLL_load(dll, fullName, error)) { /* * If the load failed, we have a set error * So all we have to do is close shop, go home */ return NITF_FAILURE; } nitf_Utils_baseName(keyName, fullName, NITF_DLL_EXTENSION); /* Now init the plugin!!! */ ident = doInit(dll, keyName, error); /* If no ident, we have a set error and an invalid plugin */ if (ident) { /* I expect to have problems with this now and then */ ok = insertPlugin(reg, ident, dll, error); /* If insertion failed, take our toys and leave */ if (!ok) { return NITF_FAILURE; } #if NITF_DEBUG_PLUGIN_REG printf("Successfully loaded plugin: [%s] at [%p]\n", keyName, dll); #endif return NITF_SUCCESS; } return NITF_FAILURE; }
/* * This function is a garbage-collector. * It is called at exit time. In the event that the singleton * is properly returned, it destructs it. * * Since this function is only registered in the getInstance() * call in the first place, it is presumed to exist already, and * thereby need destruction. * */ NITFPRIV(void) exitListener(void) { nitf_Error error; nitf_Mutex* mutex = GET_MUTEX(); nitf_PluginRegistry *single = nitf_PluginRegistry_getInstance(&error); if (single) { int unloadRet = nitf_PluginRegistry_unload(single, &error); if (unloadRet) { implicitDestruct(&single); } } nitf_Mutex_delete(mutex); }
NITFAPI(NITF_BOOL) nitf_PluginRegistry_loadDir(const char *dirName, nitf_Error * error) { NITF_BOOL status; /* first, get the registry */ nitf_PluginRegistry *reg = nitf_PluginRegistry_getInstance(error); /* must be thread safe */ nitf_Mutex_lock( GET_MUTEX() ); status = nitf_PluginRegistry_internalLoadDir(reg, dirName, error); /* unlock */ nitf_Mutex_unlock( GET_MUTEX() ); return status; }
nitf_PluginRegistry_registerTREHandler(NITF_PLUGIN_INIT_FUNCTION init, NITF_PLUGIN_TRE_HANDLER_FUNCTION handle, nitf_Error * error) { nitf_PluginRegistry* reg = nitf_PluginRegistry_getInstance(error); const char** ident; int i = 1; int ok = 1; if (!reg) { return NITF_FAILURE; } if ( (ident = (*init)(error)) == NULL) { return NITF_FAILURE; } if (!ident[0] || (strcmp(ident[0], NITF_PLUGIN_TRE_KEY) != 0)) { nitf_Error_initf(error, NITF_CTXT, NITF_ERR_INVALID_OBJECT, "Expected a TRE identity"); return NITF_FAILURE; } for (; ident[i] != NULL; ++i) { #ifdef NITF_DEBUG_PLUGIN_REG if (nitf_HashTable_exists(reg->treHandlers, ident[i])) { printf("Warning, static handler overriding [%s] hook\n", ident[i]); } #endif ok &= nitf_HashTable_insert(reg->treHandlers, ident[i], (NITF_DATA*)handle, error); } return ok; }
nitf_PluginRegistry_TREHandlerExists(const char* ident) { NITF_BOOL exists; nitf_Error error; /* first, get the registry */ nitf_PluginRegistry* const reg = nitf_PluginRegistry_getInstance(&error); if (reg == NULL) { return NITF_FAILURE; } /* must be thread safe */ nitf_Mutex_lock(GET_MUTEX()); exists = nitf_PluginRegistry_internalTREHandlerExists(reg, ident); /* unlock */ nitf_Mutex_unlock(GET_MUTEX()); return exists; }
nitf_PluginRegistry_retrieveCompInterface(const char *comp, nitf_Error* error) { /* In all cases below, the function we're calling should populate the * error if one occurs. */ nitf_PluginRegistry *reg; nitf_CompressionInterface *compIface; NITF_PLUGIN_COMPRESSION_CONSTRUCT_FUNCTION constructCompIface; int hadError = 0; /* Find the compression interface here */ reg = nitf_PluginRegistry_getInstance(error); if (!reg) { return NULL; } /* Now retrieve the comp iface creator */ constructCompIface = nitf_PluginRegistry_retrieveCompConstructor(reg, comp, &hadError, error); if (hadError || constructCompIface == NULL) { return NULL; } /* Now actually construct it */ compIface = (nitf_CompressionInterface *) (*constructCompIface) (comp, error); if (compIface == NULL) { return NULL; } return compIface; }
int main(int argc, char **argv) { /* This is the reader object */ nitf_Reader* reader; nitf_Record* record; /* The IO handle */ nitf_IOHandle io; /* Get the error object */ nitf_Error error; /* Check argv and make sure we are happy */ if ( argc != 2 ) { printf("Usage: %s <nitf-file>\n", argv[0]); exit(EXIT_FAILURE); } io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, &error); if ( NITF_INVALID_HANDLE( io ) ) { nitf_Error_print(&error, stdout, "Exiting..."); exit( EXIT_FAILURE ); } reader = nitf_Reader_construct(&error); if (!reader) { nitf_Error_print(&error, stdout, "Exiting (1) ..."); exit( EXIT_FAILURE ); } printf("Here are the loaded handlers\n"); printf("* * * * * * * * * * * * * * * *\n"); { nitf_PluginRegistry* reg = nitf_PluginRegistry_getInstance(&error); nitf_HashTable_print( reg->treHandlers); } printf("* * * * * * * * * * * * * * * *\n"); record = nitf_Reader_read(reader, io, &error); if (!record) { nitf_Error_print(&error, stderr, "Failed to read the file"); exit(EXIT_FAILURE); } /* Now show the header */ showFileHeader(record->header); /* And now show the image information */ if (record->header->numImages) { /* Walk each image and show */ nitf_ListIterator iter = nitf_List_begin(record->images); nitf_ListIterator end = nitf_List_end(record->images); while ( nitf_ListIterator_notEqualTo(&iter, &end) ) { nitf_ImageSegment* segment = (nitf_ImageSegment*)nitf_ListIterator_get(&iter); nitf_ImageSubheader* dolly = nitf_ImageSubheader_clone(segment->subheader, &error); if (!dolly) { nitf_Error_print(&error, stdout, "During cloning!"); exit(EXIT_FAILURE); } SHOW_IMSUB(segment->subheader); SHOW_IMSUB(dolly); nitf_ImageSubheader_destruct(&dolly); nitf_ListIterator_increment(&iter); } } else { printf("No image in file!\n"); } nitf_IOHandle_close(io); nitf_Record_destruct(&record); nitf_Reader_destruct(&reader); return 0; }
int main(int argc, char**argv) { nitf_Error error; nitf_PluginRegistry* reg; NITF_PLUGIN_TRE_HANDLER_FUNCTION test_main; int bad = 0; if (argc != 2) { printf("Usage: %s <TRE>\n", argv[0]); exit(EXIT_FAILURE); } reg = nitf_PluginRegistry_getInstance(&error); if (!reg) { nitf_Error_print(&error, stdout, "Exiting..."); exit(EXIT_FAILURE); } /* Don't need this now that it is a singleton * * if (! nitf_PluginRegistry_load(reg, &error) ) * { * nitf_Error_print(&error, stdout, "Exiting..."); * exit(EXIT_FAILURE); * } */ nitf_HashTable_print(reg->treHandlers); test_main = nitf_PluginRegistry_retrieveTREHandler(reg, argv[1], &bad, &error); if (bad) { nitf_Error_print(&error, stderr, "Error!"); } else if (test_main == (NITF_PLUGIN_TRE_HANDLER_FUNCTION)NULL) { printf("No such plugin could be found\n"); } else { int ok; printf("Found DLL and main!!!\n"); ok = (*test_main)(0, NULL, NULL, &error); if (!ok) { nitf_Error_print(&error, stderr , ""); } } /* Don't need this now that the registry is a singleton * if (! nitf_PluginRegistry_unload(reg, &error) ) * { * nitf_Error_print(&error, stdout, "Exiting..."); * exit(EXIT_FAILURE); * } */ /* Don't need this now that the registry is a singleton * * nitf_PluginRegistry_destruct(®); */ return 0; }