NITFAPI(cgm_Element*) cgm_PolyLineElement_construct(nitf_Error* error)
{
cgm_Element* element = cgm_Element_construct(CGM_POLYLINE_ELEMENT, error);
if (element)
{
cgm_PolyLineElement* poly = (cgm_PolyLineElement*)
NITF_MALLOC(sizeof(cgm_PolyLineElement));
if (!poly)
{
NITF_FREE(element);
return NULL;
}
poly->attributes = NULL;
poly->vertices = nitf_List_construct(error);
if (!poly->vertices)
{
NITF_FREE(poly);
NITF_FREE(element);
return NULL;
}
element->data = (NITF_DATA*)poly;
}
element->print = &polyPrint;
element->clone = &polyClone;
element->destroy = &polyDestroy;
return element;
}
/*
* TODO: Can DefaultTRE use these now that they're not private?
*
*/
NITFAPI(nitf_List*) nitf_TREUtils_basicFind(nitf_TRE* tre,
const char* pattern,
nitf_Error* error)
{
nitf_List* list;
nitf_HashTableIterator it = nitf_HashTable_begin(
((nitf_TREPrivateData*)tre->priv)->hash);
nitf_HashTableIterator end = nitf_HashTable_end(
((nitf_TREPrivateData*)tre->priv)->hash);
list = nitf_List_construct(error);
if (!list) return NULL;
while (nitf_HashTableIterator_notEqualTo(&it, &end))
{
nitf_Pair* pair = nitf_HashTableIterator_get(&it);
if (strstr(pair->key, pattern))
{
/* Should check this, I suppose */
nitf_List_pushBack(list, pair, error);
}
nitf_HashTableIterator_increment(&it);
}
return list;
}
NITFAPI(cgm_PictureBody*) cgm_PictureBody_construct(nitf_Error* error)
{
cgm_PictureBody* body =
(cgm_PictureBody*)NITF_MALLOC(sizeof(cgm_PictureBody));
if (!body)
{
nitf_Error_init(error, NITF_STRERROR(NITF_ERRNO),
NITF_CTXT, NITF_ERR_MEMORY);
return NULL;
}
body->auxColor = NULL;
body->elements = NULL;
body->elements = nitf_List_construct(error);
if (!body->elements)
{
cgm_PictureBody_destruct(&body);
return NULL;
}
body->auxColor = cgm_Color_construct(-1, -1, -1, error);
if (!body->auxColor)
{
cgm_PictureBody_destruct(&body);
return NULL;
}
body->transparency = 1;
return body;
}
NITFPRIV(nitf_PluginRegistry *) implicitConstruct(nitf_Error * error)
{
size_t pathLen;
const char *pluginEnvVar;
/* Create the registry object */
nitf_PluginRegistry *reg =
(nitf_PluginRegistry *) NITF_MALLOC(sizeof(nitf_PluginRegistry));
/* If we have a memory problem, init our error struct and return */
if (!reg)
{
nitf_Error_init(error,
NITF_STRERROR(NITF_ERRNO),
NITF_CTXT, NITF_ERR_MEMORY);
return NULL;
}
/* set these to NULL to possibly protect us later */
reg->compressionHandlers = NULL;
reg->treHandlers = NULL;
reg->decompressionHandlers = NULL;
reg->dsos = NULL;
reg->dsos = nitf_List_construct(error);
if (!reg->dsos)
{
implicitDestruct(®);
return NULL;
}
/* Construct our hash object */
reg->treHandlers = nitf_HashTable_construct(NITF_TRE_HASH_SIZE, error);
/* If we have a problem, get rid of this object and return */
if (!reg->treHandlers)
{
implicitDestruct(®);
return NULL;
}
/* do not adopt the data - we will clean it up ourselves */
nitf_HashTable_setPolicy(reg->treHandlers, NITF_DATA_RETAIN_OWNER);
reg->compressionHandlers =
nitf_HashTable_construct(NITF_COMPRESSION_HASH_SIZE, error);
/* If we have a problem, get rid of this object and return */
if (!reg->compressionHandlers)
{
implicitDestruct(®);
return NULL;
}
/* do not adopt the data - we will clean it up ourselves */
nitf_HashTable_setPolicy(reg->compressionHandlers, NITF_DATA_RETAIN_OWNER);
reg->decompressionHandlers =
nitf_HashTable_construct(NITF_DECOMPRESSION_HASH_SIZE, error);
/* If we have a problem, get rid of this object and return */
if (!reg->decompressionHandlers)
{
implicitDestruct(®);
return NULL;
}
/* do not adopt the data - we will clean it up ourselves */
nitf_HashTable_setPolicy(reg->decompressionHandlers,
NITF_DATA_RETAIN_OWNER);
/* Start with a clean slate */
memset(reg->path, 0, NITF_MAX_PATH);
/* Take the environment variable, or... */
pluginEnvVar = getenv(NITF_PLUGIN_PATH);
if (!pluginEnvVar)
{
/* Take the default path */
/*strcpy(reg->path, NITF_DEFAULT_PLUGIN_PATH);*/
return reg;
}
else
{
strcpy(reg->path, pluginEnvVar);
}
/*
* If the we have a user-defined path, they might not
* have terminated their environment variable with a
* trailing delimiter. No problem, we can do it for them.
*/
pathLen = strlen(reg->path);
if (pathLen > 0 && !isDelimiter(reg->path[pathLen - 1]))
{
/* Need to append delimiter to end */
reg->path[pathLen++] = DIR_DELIMITER;
reg->path[pathLen++] = '\0';
}
/* Return the object, its okay! */
return reg;
}
