/* Resizes an array
* Returns 1 if successful or -1 on error
*/
int libcdata_array_resize(
libcdata_array_t *array,
int number_of_entries,
int (*entry_free_function)(
intptr_t **entry,
libcerror_error_t **error ),
libcerror_error_t **error )
{
libcdata_internal_array_t *internal_array = NULL;
static char *function = "libcdata_array_resize";
int result = 1;
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
internal_array = (libcdata_internal_array_t *) array;
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_grab_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
if( libcdata_internal_array_resize(
internal_array,
number_of_entries,
entry_free_function,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize array.",
function );
result = -1;
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( result );
}
/* Appends an entry
* Sets the entry index to the newly appended entry
* Returns 1 if successful or -1 on error
*/
int libcdata_array_append_entry(
libcdata_array_t *array,
int *entry_index,
intptr_t *entry,
libcerror_error_t **error )
{
libcdata_internal_array_t *internal_array = NULL;
static char *function = "libcdata_array_append_entry";
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
internal_array = (libcdata_internal_array_t *) array;
if( entry_index == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry index.",
function );
return( -1 );
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_grab_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
*entry_index = internal_array->number_of_entries;
if( libcdata_internal_array_resize(
internal_array,
internal_array->number_of_entries + 1,
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize array.",
function );
goto on_error;
}
internal_array->entries[ *entry_index ] = entry;
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( 1 );
on_error:
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
NULL );
#endif
return( -1 );
}
/* Inserts an entry in the array
*
* Uses the entry_compare_function to determine the order of the entries
* The entry_compare_function should return LIBCDATA_COMPARE_LESS,
* LIBCDATA_COMPARE_EQUAL, LIBCDATA_COMPARE_GREATER if successful or -1 on error
*
* Duplicate entries are allowed by default and inserted after the last duplicate entry.
* Only allowing unique entries can be enforced by setting the flag LIBCDATA_INSERT_FLAG_UNIQUE_ENTRIES
*
* Returns 1 if successful, 0 if the node already exists or -1 on error
*/
int libcdata_array_insert_entry(
libcdata_array_t *array,
int *entry_index,
intptr_t *entry,
int (*entry_compare_function)(
intptr_t *first_entry,
intptr_t *second_entry,
libcerror_error_t **error ),
uint8_t insert_flags,
libcerror_error_t **error )
{
libcdata_internal_array_t *internal_array = NULL;
static char *function = "libcdata_tree_node_insert_node";
int compare_result = 0;
int entry_iterator = 0;
int result = 1;
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
internal_array = (libcdata_internal_array_t *) array;
if( entry_index == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry index.",
function );
return( -1 );
}
if( entry_compare_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry compare function.",
function );
return( -1 );
}
if( ( insert_flags & ~( LIBCDATA_INSERT_FLAG_UNIQUE_ENTRIES ) ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported insert flags: 0x%02" PRIx8 ".",
function,
insert_flags );
return( -1 );
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_grab_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
if( internal_array->entries != NULL )
{
for( entry_iterator = 0;
entry_iterator < internal_array->number_of_entries;
entry_iterator++ )
{
compare_result = entry_compare_function(
entry,
internal_array->entries[ entry_iterator ],
error );
if( compare_result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to compare entry: %d.",
function,
entry_iterator );
goto on_error;
}
else if( compare_result == LIBCDATA_COMPARE_EQUAL )
{
if( ( insert_flags & LIBCDATA_INSERT_FLAG_UNIQUE_ENTRIES ) != 0 )
{
result = 0;
break;
}
}
else if( compare_result == LIBCDATA_COMPARE_LESS )
{
result = 1;
break;
}
else if( compare_result != LIBCDATA_COMPARE_GREATER )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported entry compare function return value: %d.",
function,
compare_result );
goto on_error;
}
}
}
if( result != 0 )
{
if( ( internal_array->entries != NULL )
&& ( compare_result == LIBCDATA_COMPARE_LESS ) )
{
*entry_index = entry_iterator;
if( libcdata_internal_array_resize(
internal_array,
internal_array->number_of_entries + 1,
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize array.",
function );
goto on_error;
}
for( entry_iterator = internal_array->number_of_entries - 1;
entry_iterator > *entry_index;
entry_iterator-- )
{
internal_array->entries[ entry_iterator ] = internal_array->entries[ entry_iterator - 1 ];
}
internal_array->entries[ *entry_index ] = entry;
}
else
{
*entry_index = internal_array->number_of_entries;
if( libcdata_internal_array_resize(
internal_array,
internal_array->number_of_entries + 1,
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize array.",
function );
goto on_error;
}
if( internal_array->entries == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid array - missing entries.",
function );
goto on_error;
}
internal_array->entries[ *entry_index ] = entry;
}
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( result );
on_error:
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
NULL );
#endif
return( -1 );
}
/* Removes an entry
* Returns 1 if successful or -1 on error
*/
int libcdata_array_remove_entry(
libcdata_array_t *array,
int entry_index,
intptr_t **entry,
libcerror_error_t **error )
{
libcdata_internal_array_t *internal_array = NULL;
static char *function = "libcdata_array_remove_entry";
int entry_iterator = 0;
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
internal_array = (libcdata_internal_array_t *) array;
if( ( entry_index < 0 )
|| ( entry_index >= internal_array->number_of_entries ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid entry index value out of bounds.",
function );
return( -1 );
}
if( entry == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry.",
function );
return( -1 );
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_grab_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
*entry = internal_array->entries[ entry_index ];
if( entry_index == ( internal_array->number_of_entries - 1 ) )
{
internal_array->entries[ entry_index ] = NULL;
}
else
{
for( entry_iterator = ( internal_array->number_of_entries - 1 );
entry_iterator > entry_index;
entry_iterator-- )
{
internal_array->entries[ entry_iterator - 1 ] = internal_array->entries[ entry_iterator ];
internal_array->entries[ entry_iterator ] = NULL;
}
}
if( libcdata_internal_array_resize(
internal_array,
internal_array->number_of_entries - 1,
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize array.",
function );
goto on_error;
}
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( 1 );
on_error:
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
libcthreads_read_write_lock_release_for_write(
internal_array->read_write_lock,
NULL );
#endif
return( -1 );
}