/*

 * The list functions

 *

 * Copyright (C) 2010-2024, Joachim Metz <joachim.metz@gmail.com>

 *

 * Refer to AUTHORS for acknowledgements.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 */

#include <common.h>

#include <memory.h>

#include <types.h>

#include "libfdata_definitions.h"

#include "libfdata_libcdata.h"

#include "libfdata_libcerror.h"

#include "libfdata_libcnotify.h"

#include "libfdata_libfcache.h"

#include "libfdata_list.h"

#include "libfdata_list_element.h"

#include "libfdata_mapped_range.h"

#include "libfdata_range.h"

#include "libfdata_types.h"

#include "libfdata_unused.h"

/* Creates a list

 * Make sure the value list is referencing, is set to NULL

 *

 * If the flag LIBFDATA_DATA_HANDLE_FLAG_MANAGED is set the list

 * takes over management of the data handle and the data handle is freed when

 * no longer needed

 *

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_initialize(

     libfdata_list_t **list,

     intptr_t *data_handle,

     int (*free_data_handle)(

            intptr_t **data_handle,

            libcerror_error_t **error ),

     int (*clone_data_handle)(

            intptr_t **destination_data_handle,

            intptr_t *source_data_handle,

            libcerror_error_t **error ),

     int (*read_element_data)(

            intptr_t *data_handle,

            intptr_t *file_io_handle,

            libfdata_list_element_t *list_element,

            libfdata_cache_t *cache,

            int element_data_file_index,

            off64_t element_data_offset,

            size64_t element_data_size,

            uint32_t element_data_flags,

            uint8_t read_flags,

            libcerror_error_t **error ),

     int (*write_element_data)(

            intptr_t *data_handle,

            intptr_t *file_io_handle,

            libfdata_list_element_t *list_element,

            libfdata_cache_t *cache,

            int element_data_file_index,

            off64_t element_data_offset,

            size64_t element_data_size,

            uint32_t element_data_flags,

            uint8_t write_flags,

            libcerror_error_t **error ),

     uint8_t flags,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_initialize";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  if( *list != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid list value already set.",

     function );

    return( -1 );

  }

  if( ( flags & 0xfe ) != 0 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,

     "%s: unsupported flags: 0x%02" PRIx8 ".",

     function );

    return( -1 );

  }

  internal_list = memory_allocate_structure(

                   libfdata_internal_list_t );

  if( internal_list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create list.",

     function );

    goto on_error;

  }

  if( memory_set(

       internal_list,

       0,

       sizeof( libfdata_internal_list_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear list.",

     function );

    memory_free(

     internal_list );

    return( -1 );

  }

  if( libcdata_array_initialize(

       &( internal_list->elements_array ),

       0,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create elements array.",

     function );

    goto on_error;

  }

  if( libcdata_array_initialize(

       &( internal_list->mapped_ranges_array ),

       0,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create mapped ranges array.",

     function );

    goto on_error;

  }

  internal_list->flags             |= flags;

  internal_list->data_handle        = data_handle;

  internal_list->free_data_handle   = free_data_handle;

  internal_list->clone_data_handle  = clone_data_handle;

  internal_list->read_element_data  = read_element_data;

  internal_list->write_element_data = write_element_data;

  *list = (libfdata_list_t *) internal_list;

  return( 1 );

on_error:

  if( internal_list != NULL )

  {

    if( internal_list->elements_array != NULL )

    {

      libcdata_array_free(

       &( internal_list->elements_array ),

       NULL,

       NULL );

    }

    memory_free(

     internal_list );

  }

  return( -1 );

}

/* Frees a list

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_free(

     libfdata_list_t **list,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_free";

  int result                              = 1;

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  if( *list != NULL )

  {

    internal_list = (libfdata_internal_list_t *) *list;

    *list         = NULL;

    if( libcdata_array_free(

         &( internal_list->elements_array ),

         (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_list_element_free,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to free the elements array.",

       function );

      result = -1;

    }

    if( libcdata_array_free(

         &( internal_list->mapped_ranges_array ),

         (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_mapped_range_free,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to free the mapped ranges array.",

       function );

      result = -1;

    }

    if( ( internal_list->flags & LIBFDATA_DATA_HANDLE_FLAG_MANAGED ) != 0 )

    {

      if( internal_list->data_handle != NULL )

      {

        if( internal_list->free_data_handle == NULL )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

           "%s: invalid list - missing free data handle function.",

           function );

          result = -1;

        }

        else if( internal_list->free_data_handle(

                  &( internal_list->data_handle ),

                  error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

           "%s: unable to free data handle.",

           function );

          result = -1;

        }

      }

    }

    memory_free(

     internal_list );

  }

  return( result );

}

/* Clones (duplicates) the list

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_clone(

     libfdata_list_t **destination_list,

     libfdata_list_t *source_list,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_destination_list = NULL;

  libfdata_internal_list_t *internal_source_list      = NULL;

  static char *function                               = "libfdata_list_clone";

  if( destination_list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid destination list.",

     function );

    return( -1 );

  }

  if( *destination_list != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid destination list value already set.",

     function );

    return( -1 );

  }

  if( source_list == NULL )

  {

    *destination_list = NULL;

    return( 1 );

  }

  internal_source_list = (libfdata_internal_list_t *) source_list;

  internal_destination_list = memory_allocate_structure(

                               libfdata_internal_list_t );

  if( internal_destination_list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create destination list.",

     function );

    goto on_error;

  }

  if( memory_set(

       internal_destination_list,

       0,

       sizeof( libfdata_internal_list_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear destination list.",

     function );

    memory_free(

     internal_destination_list );

    return( -1 );

  }

  if( internal_source_list->data_handle != NULL )

  {

    if( internal_source_list->free_data_handle == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

       "%s: invalid source list - missing free data handle function.",

       function );

      goto on_error;

    }

    if( internal_source_list->clone_data_handle == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

       "%s: invalid source list - missing clone data handle function.",

       function );

      goto on_error;

    }

    if( internal_source_list->clone_data_handle(

         &( internal_destination_list->data_handle ),

         internal_source_list->data_handle,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to clone data handle.",

       function );

      goto on_error;

    }

  }

/* TODO set destination list in destination elements */

  if( libcdata_array_clone(

       &( internal_destination_list->elements_array ),

       internal_source_list->elements_array,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_list_element_free,

       (int (*)(intptr_t **, intptr_t *, libcerror_error_t **)) &libfdata_list_element_clone,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create destination elements array.",

     function );

    goto on_error;

  }

  if( libcdata_array_clone(

       &( internal_destination_list->mapped_ranges_array ),

       internal_source_list->mapped_ranges_array,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_mapped_range_free,

       (int (*)(intptr_t **, intptr_t *, libcerror_error_t **)) &libfdata_mapped_range_clone,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create destination mapped ranges array.",

     function );

    goto on_error;

  }

  internal_destination_list->flags              = internal_source_list->flags | LIBFDATA_DATA_HANDLE_FLAG_MANAGED;

  internal_destination_list->free_data_handle   = internal_source_list->free_data_handle;

  internal_destination_list->clone_data_handle  = internal_source_list->clone_data_handle;

  internal_destination_list->read_element_data  = internal_source_list->read_element_data;

  internal_destination_list->write_element_data = internal_source_list->write_element_data;

  *destination_list = (libfdata_list_t *) internal_destination_list;

  return( 1 );

on_error:

  if( internal_destination_list != NULL )

  {

    if( internal_destination_list->elements_array != NULL )

    {

      libcdata_array_free(

       &( internal_destination_list->elements_array ),

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_list_element_free,

       NULL );

    }

    if( ( internal_destination_list->data_handle != NULL )

     && ( internal_source_list->free_data_handle != NULL ) )

    {

      internal_source_list->free_data_handle(

       &( internal_destination_list->data_handle ),

       NULL );

    }

    memory_free(

     internal_destination_list );

  }

  return( -1 );

}

/* Sets the calculate mapped ranges flag

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_set_calculate_mapped_ranges_flag(

     libfdata_list_t *list,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_set_calculate_mapped_ranges_flag";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  internal_list->flags |= LIBFDATA_FLAG_CALCULATE_MAPPED_RANGES;

  return( 1 );

}

/* List elements functions

 */

/* Empties the list

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_empty(

     libfdata_list_t *list,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_empty";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_empty(

       internal_list->elements_array,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_list_element_free,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,

     "%s: unable to empty elements array.",

     function );

    return( -1 );

  }

  if( libcdata_array_empty(

       internal_list->mapped_ranges_array,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_mapped_range_free,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

     "%s: unable to empty mapped ranges array.",

     function );

    return( -1 );

  }

  internal_list->size = 0;

  return( 1 );

}

/* Resizes the list

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_resize(

     libfdata_list_t *list,

     int number_of_elements,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_resize";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_resize(

       internal_list->elements_array,

       number_of_elements,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_list_element_free,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,

     "%s: unable to resize elements array.",

     function );

    return( -1 );

  }

  if( libcdata_array_resize(

       internal_list->mapped_ranges_array,

       number_of_elements,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfdata_mapped_range_free,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,

     "%s: unable to resize mapped ranges array.",

     function );

    return( -1 );

  }

  internal_list->flags |= LIBFDATA_FLAG_CALCULATE_MAPPED_RANGES;

  return( 1 );

}

/* Reverses the order of the elements

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_reverse(

     libfdata_list_t *list,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  libfdata_list_element_t *list_element   = NULL;

  static char *function                   = "libfdata_list_reverse";

  int element_index                       = 0;

  int number_of_elements                  = 0;

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_reverse(

       internal_list->elements_array,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_SET_FAILED,

     "%s: unable to reverse elements array.",

     function );

    return( -1 );

  }

  if( libcdata_array_get_number_of_entries(

       internal_list->elements_array,

       &number_of_elements,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve number of elements from elements array.",

     function );

    return( -1 );

  }

  for( element_index = 0;

       element_index < number_of_elements;

       element_index++ )

  {

    if( libcdata_array_get_entry_by_index(

         internal_list->elements_array,

         element_index,

         (intptr_t **) &list_element,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_GET_FAILED,

       "%s: unable to retrieve entry: %d from elements array.",

       function,

       element_index );

      return( -1 );

    }

    if( libfdata_list_element_set_element_index(

         list_element,

         element_index,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_SET_FAILED,

       "%s: unable to set list element: %d index.",

       function,

       element_index );

      return( -1 );

    }

  }

  internal_list->flags |= LIBFDATA_FLAG_CALCULATE_MAPPED_RANGES;

  return( 1 );

}

/* Retrieves the number of elements of the list

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_get_number_of_elements(

     libfdata_list_t *list,

     int *number_of_elements,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_get_number_of_elements";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_get_number_of_entries(

       internal_list->elements_array,

       number_of_elements,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve number of elements from elements array.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves a specific list element

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_get_list_element_by_index(

     libfdata_list_t *list,

     int element_index,

     libfdata_list_element_t **element,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  static char *function                   = "libfdata_list_get_list_element_by_index";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_get_entry_by_index(

       internal_list->elements_array,

       element_index,

       (intptr_t **) element,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve entry: %d from elements array.",

     function,

     element_index );

    return( -1 );

  }

  internal_list->current_element_index = element_index;

  return( 1 );

}

/* Retrieves the data range of a specific element

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_get_element_by_index(

     libfdata_list_t *list,

     int element_index,

     int *element_file_index,

     off64_t *element_offset,

     size64_t *element_size,

     uint32_t *element_flags,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  libfdata_list_element_t *list_element   = NULL;

  static char *function                   = "libfdata_list_get_element_by_index";

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_get_entry_by_index(

       internal_list->elements_array,

       element_index,

       (intptr_t **) &list_element,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve entry: %d from elements array.",

     function,

     element_index );

    return( -1 );

  }

  if( libfdata_list_element_get_data_range(

       list_element,

       element_file_index,

       element_offset,

       element_size,

       element_flags,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve data range from list element: %d.",

     function,

     element_index );

    return( -1 );

  }

  internal_list->current_element_index = element_index;

  return( 1 );

}

/* Sets the data range of a specific element

 * Returns 1 if successful or -1 on error

 */

int libfdata_list_set_element_by_index(

     libfdata_list_t *list,

     int element_index,

     int element_file_index,

     off64_t element_offset,

     size64_t element_size,

     uint32_t element_flags,

     libcerror_error_t **error )

{

  libfdata_internal_list_t *internal_list = NULL;

  libfdata_list_element_t *list_element   = NULL;

  libfdata_mapped_range_t *mapped_range   = NULL;

  static char *function                   = "libfdata_list_set_element_by_index";

  off64_t previous_element_offset         = 0;

  size64_t mapped_size                    = 0;

  size64_t previous_element_size          = 0;

  uint32_t previous_element_flags         = 0;

  int previous_element_file_index         = 0;

  int result                              = 0;

#if defined( HAVE_DEBUG_OUTPUT )

  off64_t mapped_range_offset             = 0;

  size64_t mapped_range_size              = 0;

#endif

  if( list == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid list.",

     function );

    return( -1 );

  }

  internal_list = (libfdata_internal_list_t *) list;

  if( libcdata_array_get_entry_by_index(

       internal_list->elements_array,

       element_index,

       (intptr_t **) &list_element,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve entry: %d from elements array.",

     function,

     element_index );

    return( -1 );

  }

  if( list_element == NULL )

  {

    if( libfdata_list_element_initialize(

         &list_element,

         list,

         element_index,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create list element.",

       function );

      return( -1 );

    }

    if( libcdata_array_set_entry_by_index(

         internal_list->elements_array,

         element_index,

         (intptr_t *) list_element,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_SET_FAILED,

       "%s: unable to set entry: %d in elements array.",

       function,