/**
* raptor_free_memory:
* @ptr: memory pointer
*
* Free memory allocated inside raptor.
*
* Some systems require memory allocated in a library to
* be deallocated in that library. This function allows
* memory allocated by raptor to be freed.
*
* Examples include the result of the '_to_' methods that returns
* allocated memory such as raptor_uri_filename_to_uri_string,
* raptor_uri_filename_to_uri_string
* and raptor_uri_uri_string_to_filename_fragment
*
**/
void
raptor_free_memory(void *ptr)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(ptr, memory);
RAPTOR_FREE(void, ptr);
}
static void
raptor_free_serializer_factory(raptor_serializer_factory* factory)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(factory, raptor_serializer_factory);
if(factory->finish_factory)
factory->finish_factory(factory);
RAPTOR_FREE(raptor_serializer_factory, factory);
}
/**
* raptor_sequence_sort:
* @seq: sequence to sort
* @compare: comparison function
*
* The comparison function is compatible with that used for qsort()
* and provides the addresses of pointers to the data that
* must be dereferenced to get to the stored sequence data.
*
**/
RAPTOR_EXTERN_C
void
raptor_sequence_sort(raptor_sequence* seq,
int(*compare)(const void *, const void *))
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(seq, raptor_sequence);
if(seq->size > 1)
qsort(&seq->sequence[seq->start], seq->size, sizeof(void*), compare);
}
/**
* raptor_uri_set_handler:
* @handler: URI handler structure
* @context: URI handler context
*
* Change the URI class implementation to the functions provided by the
*
* The URI interface in @handler->initialised should be either 1
* or 2 (if raptor_uri_compare_func is implemented).
**/
void
raptor_uri_set_handler(const raptor_uri_handler *handler, void *context)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(handler, raptor_uri_handler);
/* RAPTOR_ASSERT is the negative of ordinary asserts - it fails if the condition is true */
RAPTOR_ASSERT(!(handler->initialised >= 1 && handler->initialised <= 2),
"raptor_uri_handler->initialised not 1..2");
raptor_uri_current_uri_handler=handler;
raptor_uri_current_uri_context=context;
}
static void
raptor_free_abbrev_po(raptor_abbrev_node** nodes)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(nodes, raptor_abbrev_node_pair);
if(nodes[0])
raptor_free_abbrev_node(nodes[0]);
if(nodes[1])
raptor_free_abbrev_node(nodes[1]);
RAPTOR_FREE(raptor_abbrev_nodes, nodes);
}
/**
* raptor_free_id_set:
* @set: #raptor_id_set
*
* INTERNAL - Destructor - Free ID Set.
*
**/
void
raptor_free_id_set(raptor_id_set *set)
{
raptor_base_id_set *base;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(set, raptor_id_set);
base = set->first;
while(base) {
raptor_base_id_set *next = base->next;
raptor_free_base_id_set(base);
base = next;
}
RAPTOR_FREE(raptor_id_set, set);
}
/**
* raptor_free_iostream:
* @iostr: iostream object
*
* Destructor - destroy an iostream.
**/
void
raptor_free_iostream(raptor_iostream *iostr)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(iostr, raptor_iostream);
if(iostr->flags & RAPTOR_IOSTREAM_FLAGS_EOF)
raptor_iostream_write_end(iostr);
if(iostr->handler->finish)
iostr->handler->finish(iostr->user_data);
if((iostr->flags & RAPTOR_IOSTREAM_FLAGS_FREE_HANDLER))
RAPTOR_FREE(raptor_iostream_handler2, iostr->handler);
RAPTOR_FREE(raptor_iostream, iostr);
}
void
raptor_free_abbrev_subject(raptor_abbrev_subject* subject)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(subject, raptor_abbrev_subject);
if(subject->node)
raptor_free_abbrev_node(subject->node);
if(subject->node_type)
raptor_free_abbrev_node(subject->node_type);
if(subject->properties)
raptor_free_avltree(subject->properties);
if(subject->list_items)
raptor_free_sequence(subject->list_items);
RAPTOR_FREE(raptor_subject, subject);
}
/**
* raptor_sequence_print:
* @seq: sequence to sort
* @fh: file handle
*
* Print the sequence contents using the print_handler to print the data items.
*/
void
raptor_sequence_print(raptor_sequence* seq, FILE* fh)
{
int i;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(seq, raptor_sequence);
fputc('[', fh);
for(i=0; i<seq->size; i++) {
if(i)
fputs(", ", fh);
if(seq->sequence[seq->start+i]) {
if(seq->print_handler)
seq->print_handler(seq->sequence[seq->start+i], fh);
else if(seq->print_handler_v2)
seq->print_handler_v2(seq->handler_context, seq->sequence[seq->start+i], fh);
} else
fputs("(empty)", fh);
}
fputc(']', fh);
}
/**
* raptor_free_sax2:
* @sax2: SAX2 object
*
* Destructor - destroy a SAX2 object
*/
void
raptor_free_sax2(raptor_sax2 *sax2)
{
raptor_xml_element *xml_element;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(sax2, raptor_sax2);
#ifdef RAPTOR_XML_EXPAT
if(sax2->xp) {
XML_ParserFree(sax2->xp);
sax2->xp=NULL;
}
#endif
#ifdef RAPTOR_XML_LIBXML
if(sax2->xc) {
raptor_libxml_free(sax2->xc);
sax2->xc=NULL;
}
if(sax2->world->libxml_flags & RAPTOR_LIBXML_FLAGS_STRUCTURED_ERROR_SAVE)
xmlSetStructuredErrorFunc(sax2->saved_structured_error_context,
sax2->saved_structured_error_handler);
if(sax2->world->libxml_flags & RAPTOR_LIBXML_FLAGS_GENERIC_ERROR_SAVE)
xmlSetGenericErrorFunc(sax2->saved_generic_error_context,
sax2->saved_generic_error_handler);
#endif
while( (xml_element=raptor_xml_element_pop(sax2)) )
raptor_free_xml_element(xml_element);
raptor_namespaces_clear(&sax2->namespaces);
if(sax2->base_uri)
raptor_free_uri_v2(sax2->world, sax2->base_uri);
RAPTOR_FREE(raptor_sax2, sax2);
}
void
raptor_free_abbrev_node(raptor_abbrev_node* node)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(node, raptor_abbrev_node);
if(--node->ref_count)
return;
switch (node->type) {
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
case RAPTOR_IDENTIFIER_TYPE_PREDICATE:
raptor_free_uri(node->value.resource.uri);
break;
case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS:
RAPTOR_FREE(blank, node->value.blank.string);
break;
case RAPTOR_IDENTIFIER_TYPE_LITERAL:
case RAPTOR_IDENTIFIER_TYPE_XML_LITERAL:
RAPTOR_FREE(literal, node->value.literal.string);
if(node->value.literal.datatype)
raptor_free_uri(node->value.literal.datatype);
if(node->value.literal.language)
RAPTOR_FREE(language, node->value.literal.language);
break;
case RAPTOR_IDENTIFIER_TYPE_ORDINAL:
case RAPTOR_IDENTIFIER_TYPE_UNKNOWN:
default:
/* Nothing to do */
break;
}
RAPTOR_FREE(raptor_abbrev_node, node);
}
/**
* raptor_free_sequence:
* @seq: sequence to destroy
*
* Destructor - free a #raptor_sequence
**/
void
raptor_free_sequence(raptor_sequence* seq)
{
int i;
int j;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN(seq, raptor_sequence);
if(seq->free_handler) {
for(i=seq->start, j=seq->start+seq->size; i<j; i++)
if(seq->sequence[i])
seq->free_handler(seq->sequence[i]);
} else if(seq->free_handler_v2) {
for(i=seq->start, j=seq->start+seq->size; i<j; i++)
if(seq->sequence[i])
seq->free_handler_v2(seq->handler_context, seq->sequence[i]);
}
if(seq->sequence)
RAPTOR_FREE(ptrarray, seq->sequence);
RAPTOR_FREE(raptor_sequence, seq);
}
