/*

 * Value 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 <file_stream.h>

#include <memory.h>

#include <narrow_string.h>

#include <system_string.h>

#include <types.h>

#include <wide_string.h>

#include "libfvalue_data_handle.h"

#include "libfvalue_definitions.h"

#include "libfvalue_libcdata.h"

#include "libfvalue_libcerror.h"

#include "libfvalue_libcnotify.h"

#include "libfvalue_types.h"

#include "libfvalue_value.h"

/* Creates a value

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

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_initialize(

     libfvalue_value_t **value,

     const char *type_string,

     const char *type_description,

     libfvalue_data_handle_t *data_handle,

     int (*initialize_instance)(

           intptr_t **instance,

           libcerror_error_t **error ),

     int (*free_instance)(

           intptr_t **instance,

           libcerror_error_t **error ),

     int (*clone_instance)(

           intptr_t **destination_instance,

           intptr_t *source_instance,

           libcerror_error_t **error ),

     int (*copy_from_byte_stream)(

           intptr_t *instance,

           const uint8_t *byte_stream,

           size_t byte_stream_size,

           int encoding,

           libcerror_error_t **error ),

     int (*copy_to_byte_stream)(

           intptr_t *instance,

           uint8_t *byte_stream,

           size_t byte_stream_size,

           int encoding,

           libcerror_error_t **error ),

     int (*copy_from_integer)(

           intptr_t *instance,

           uint64_t integer_value,

           size_t integer_value_size,

           libcerror_error_t **error ),

     int (*copy_to_integer)(

           intptr_t *instance,

           uint64_t *integer_value,

           size_t *integer_value_size,

           libcerror_error_t **error ),

     int (*copy_from_floating_point)(

           intptr_t *instance,

           double floating_point_value,

           size_t floating_point_value_size,

           libcerror_error_t **error ),

     int (*copy_to_floating_point)(

           intptr_t *instance,

           double *floating_point_value,

           size_t *floating_point_value_size,

           libcerror_error_t **error ),

     int (*copy_from_utf8_string_with_index)(

           intptr_t *instance,

           const uint8_t *utf8_string,

           size_t utf8_string_length,

           size_t *utf8_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*get_utf8_string_size)(

           intptr_t *instance,

           size_t *utf8_string_size,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*copy_to_utf8_string_with_index)(

           intptr_t *instance,

           uint8_t *utf8_string,

           size_t utf8_string_size,

           size_t *utf8_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*copy_from_utf16_string_with_index)(

           intptr_t *instance,

           const uint16_t *utf16_string,

           size_t utf16_string_length,

           size_t *utf16_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*get_utf16_string_size)(

           intptr_t *instance,

           size_t *utf16_string_size,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*copy_to_utf16_string_with_index)(

           intptr_t *instance,

           uint16_t *utf16_string,

           size_t utf16_string_size,

           size_t *utf16_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*copy_from_utf32_string_with_index)(

           intptr_t *instance,

           const uint32_t *utf32_string,

           size_t utf32_string_length,

           size_t *utf32_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*get_utf32_string_size)(

           intptr_t *instance,

           size_t *utf32_string_size,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     int (*copy_to_utf32_string_with_index)(

           intptr_t *instance,

           uint32_t *utf32_string,

           size_t utf32_string_size,

           size_t *utf32_string_index,

           uint32_t string_format_flags,

           libcerror_error_t **error ),

     uint8_t flags,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_initialize";

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  if( *value != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

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

     function );

    return( -1 );

  }

  if( type_string == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid type string",

     function );

    return( -1 );

  }

  internal_value = memory_allocate_structure(

                    libfvalue_internal_value_t );

  if( internal_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create value.",

     function );

    goto on_error;

  }

  if( memory_set(

       internal_value,

       0,

       sizeof( libfvalue_internal_value_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear value.",

     function );

    memory_free(

     internal_value );

    return( -1 );

  }

  if( free_instance != NULL )

  {

    if( libcdata_array_initialize(

         &( internal_value->value_instances ),

         1,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create value instances array.",

       function );

      goto on_error;

    }

  }

  if( data_handle == NULL )

  {

/* TODO add read function ? */

    if( libfvalue_data_handle_initialize(

         &( internal_value->data_handle ),

         NULL,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

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

       function );

      goto on_error;

    }

    internal_value->flags |= LIBFVALUE_VALUE_FLAG_DATA_HANDLE_MANAGED;

  }

  else

  {

    internal_value->data_handle = data_handle;

  }

  internal_value->type_string                       = type_string;

  internal_value->type_description                  = type_description;

  internal_value->initialize_instance               = initialize_instance;

  internal_value->free_instance                     = free_instance;

  internal_value->clone_instance                    = clone_instance;

  internal_value->copy_from_byte_stream             = copy_from_byte_stream;

  internal_value->copy_to_byte_stream               = copy_to_byte_stream;

  internal_value->copy_from_integer                 = copy_from_integer;

  internal_value->copy_to_integer                   = copy_to_integer;

  internal_value->copy_from_floating_point          = copy_from_floating_point;

  internal_value->copy_to_floating_point            = copy_to_floating_point;

  internal_value->copy_from_utf8_string_with_index  = copy_from_utf8_string_with_index;

  internal_value->get_utf8_string_size              = get_utf8_string_size;

  internal_value->copy_to_utf8_string_with_index    = copy_to_utf8_string_with_index;

  internal_value->copy_from_utf16_string_with_index = copy_from_utf16_string_with_index;

  internal_value->get_utf16_string_size             = get_utf16_string_size;

  internal_value->copy_to_utf16_string_with_index   = copy_to_utf16_string_with_index;

  internal_value->copy_from_utf32_string_with_index = copy_from_utf32_string_with_index;

  internal_value->get_utf32_string_size             = get_utf32_string_size;

  internal_value->copy_to_utf32_string_with_index   = copy_to_utf32_string_with_index;

  internal_value->flags                            |= flags;

  *value = (libfvalue_value_t *) internal_value;

  return( 1 );

on_error:

  if( internal_value != NULL )

  {

    if( internal_value->value_instances != NULL )

    {

      libcdata_array_free(

       &( internal_value->value_instances ),

       NULL,

       NULL );

    }

    memory_free(

     internal_value );

  }

  return( -1 );

}

/* Frees a value

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_free(

     libfvalue_value_t **value,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_free";

  int result                                 = 1;

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  if( *value != NULL )

  {

    if( libfvalue_value_clear(

         *value,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

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

       function );

      result = -1;

    }

    internal_value = (libfvalue_internal_value_t *) *value;

    *value         = NULL;

    if( internal_value->value_instances != NULL )

    {

      if( libcdata_array_free(

           &( internal_value->value_instances ),

           internal_value->free_instance,

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

         "%s: unable to free value instances array.",

         function );

        result = -1;

      }

    }

    if( ( internal_value->flags & LIBFVALUE_VALUE_FLAG_DATA_HANDLE_MANAGED ) != 0 )

    {

      if( libfvalue_data_handle_free(

           &( internal_value->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;

      }

      internal_value->flags &= ~( LIBFVALUE_VALUE_FLAG_DATA_HANDLE_MANAGED );

    }

    memory_free(

     internal_value );

  }

  return( result );

}

/* Clones a value

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_clone(

     libfvalue_value_t **destination_value,

     libfvalue_value_t *source_value,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_source_value = NULL;

  libfvalue_data_handle_t *destination_data_handle  = NULL;

  static char *function                             = "libfvalue_value_clone";

  if( destination_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid destination value.",

     function );

    return( -1 );

  }

  if( *destination_value != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: destination value already set.",

     function );

    return( -1 );

  }

  if( source_value == NULL )

  {

    *destination_value = NULL;

    return( 1 );

  }

  internal_source_value = (libfvalue_internal_value_t *) source_value;

  if( libfvalue_data_handle_clone(

       &destination_data_handle,

       internal_source_value->data_handle,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create destination data handle.",

     function );

    goto on_error;

  }

  if( libfvalue_value_initialize(

       destination_value,

       internal_source_value->type_string,

       internal_source_value->type_description,

       destination_data_handle,

       internal_source_value->initialize_instance,

       internal_source_value->free_instance,

       internal_source_value->clone_instance,

       internal_source_value->copy_from_byte_stream,

       internal_source_value->copy_to_byte_stream,

       internal_source_value->copy_from_integer,

       internal_source_value->copy_to_integer,

       internal_source_value->copy_from_floating_point,

       internal_source_value->copy_to_floating_point,

       internal_source_value->copy_from_utf8_string_with_index,

       internal_source_value->get_utf8_string_size,

       internal_source_value->copy_to_utf8_string_with_index,

       internal_source_value->copy_from_utf16_string_with_index,

       internal_source_value->get_utf16_string_size,

       internal_source_value->copy_to_utf16_string_with_index,

       internal_source_value->copy_from_utf32_string_with_index,

       internal_source_value->get_utf32_string_size,

       internal_source_value->copy_to_utf32_string_with_index,

       internal_source_value->flags | LIBFVALUE_VALUE_FLAG_DATA_HANDLE_MANAGED,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

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

     function );

    goto on_error;

  }

  if( *destination_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing destination value.",

     function );

    goto on_error;

  }

  destination_data_handle = NULL;

  if( internal_source_value->identifier != NULL )

  {

    if( libfvalue_value_set_identifier(

         *destination_value,

         internal_source_value->identifier,

         internal_source_value->identifier_size,

         LIBFVALUE_VALUE_IDENTIFIER_FLAG_MANAGED,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_SET_FAILED,

       "%s: unable to set identifier in destination value.",

       function );

      goto on_error;

    }

  }

  /* The value instances are not cloned and are re-created on demand

   */

  return( 1 );

on_error:

  if( destination_data_handle != NULL )

  {

    libfvalue_data_handle_free(

     &destination_data_handle,

     NULL );

  }

  if( *destination_value != NULL )

  {

    libfvalue_value_free(

     destination_value,

     NULL );

  }

  return( -1 );

}

/* Clears a value

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_clear(

     libfvalue_value_t *value,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_clear";

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  internal_value = (libfvalue_internal_value_t *) value;

  if( ( internal_value->flags & LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED ) != 0 )

  {

    if( internal_value->identifier != NULL )

    {

      memory_free(

       internal_value->identifier );

    }

    internal_value->flags &= ~( LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED );

  }

  if( libfvalue_data_handle_clear(

       internal_value->data_handle,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

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

     function );

    return( -1 );

  }

  if( internal_value->value_instances != NULL )

  {

    if( internal_value->free_instance == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

       "%s: invalid value - missing free instance function.",

       function );

      return( -1 );

    }

    if( libcdata_array_empty(

         internal_value->value_instances,

         internal_value->free_instance,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to empty value instances array.",

       function );

      return( -1 );

    }

  }

  return( 1 );

}

/* Retrieves the value type

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_get_type(

     libfvalue_value_t *value,

     int *value_type,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_get_type";

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  internal_value = (libfvalue_internal_value_t *) value;

  if( value_type == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value type.",

     function );

    return( -1 );

  }

  *value_type = internal_value->type;

  return( 1 );

}

/* Compares two index values

 * Returns LIBCDATA_COMPARE_LESS, LIBCDATA_COMPARE_EQUAL, LIBCDATA_COMPARE_GREATER if successful or -1 on error

 */

int libfvalue_compare_identifier(

     intptr_t *first_value,

     intptr_t *second_value,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_first_value  = NULL;

  libfvalue_internal_value_t *internal_second_value = NULL;

  static char *function                             = "libfvalue_compare_identifier";

  size_t compare_size                               = 0;

  int result                                        = 0;

  if( first_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid first value.",

     function );

    return( -1 );

  }

  internal_first_value = (libfvalue_internal_value_t *) first_value;

  if( second_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid second value.",

     function );

    return( -1 );

  }

  internal_second_value = (libfvalue_internal_value_t *) second_value;

  if( internal_first_value->identifier == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid first value - missing identifier.",

     function );

    return( -1 );

  }

  if( internal_second_value->identifier == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid second value - missing identifier.",

     function );

    return( -1 );

  }

  if( internal_first_value->identifier_size <= internal_second_value->identifier_size )

  {

    compare_size = internal_first_value->identifier_size;

  }

  else

  {

    compare_size = internal_second_value->identifier_size;

  }

  result = memory_compare(

            internal_first_value->identifier,

            internal_second_value->identifier,

            compare_size );

  if( result < 0 )

  {

    return( LIBCDATA_COMPARE_LESS );

  }

  else if( result > 0 )

  {

    return( LIBCDATA_COMPARE_GREATER );

  }

  if( internal_first_value->identifier_size < internal_second_value->identifier_size )

  {

    return( LIBCDATA_COMPARE_LESS );

  }

  else if( internal_first_value->identifier_size > internal_second_value->identifier_size )

  {

    return( LIBCDATA_COMPARE_GREATER );

  }

  return( LIBCDATA_COMPARE_EQUAL );

}

/* Retrieves the identifier

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_get_identifier(

     libfvalue_value_t *value,

     uint8_t **identifier,

     size_t *identifier_size,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_get_identifier";

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  internal_value = (libfvalue_internal_value_t *) value;

  if( identifier == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid identifier.",

     function );

    return( -1 );

  }

  if( identifier_size == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid identifier size.",

     function );

    return( -1 );

  }

  *identifier      = internal_value->identifier;

  *identifier_size = internal_value->identifier_size;

  return( 1 );

}

/* Sets the identifier

 * Returns 1 if successful or -1 on error

 */

int libfvalue_value_set_identifier(

     libfvalue_value_t *value,

     const uint8_t *identifier,

     size_t identifier_size,

     uint8_t flags,

     libcerror_error_t **error )

{

  libfvalue_internal_value_t *internal_value = NULL;

  static char *function                      = "libfvalue_value_set_identifier";

  uint8_t supported_flags                    = 0;

  if( value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value.",

     function );

    return( -1 );

  }

  internal_value = (libfvalue_internal_value_t *) value;

  if( internal_value->identifier != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid value - identifier already set.",

     function );

    return( -1 );

  }

  if( identifier == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid identifier.",

     function );

    return( -1 );

  }

  if( ( identifier_size == 0 )

   || ( identifier_size > (size_t) SSIZE_MAX ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid identifier length value out of bounds.",

     function );

    return( -1 );

  }

  supported_flags = LIBFVALUE_VALUE_IDENTIFIER_FLAG_MANAGED

                  | LIBFVALUE_VALUE_IDENTIFIER_FLAG_CLONE_BY_REFERENCE;

  if( ( flags & ~( supported_flags ) ) != 0 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,

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

     function,

     flags );

    return( -1 );

  }

  if( ( internal_value->flags & LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED ) != 0 )

  {

    if( internal_value->identifier != NULL )

    {

      memory_free(

       internal_value->identifier );

      internal_value->identifier      = NULL;

      internal_value->identifier_size = 0;

    }

    internal_value->flags &= ~( LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED );

  }

  if( ( flags & LIBFVALUE_VALUE_IDENTIFIER_FLAG_CLONE_BY_REFERENCE ) != 0 )

  {

    internal_value->identifier = (uint8_t *) identifier;

    if( ( flags & LIBFVALUE_VALUE_IDENTIFIER_FLAG_MANAGED ) != 0 )

    {

      internal_value->flags |= LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED;

    }

  }

  else

  {

    internal_value->identifier = (uint8_t *) memory_allocate(

                                              sizeof( uint8_t ) * identifier_size );

    if( internal_value->identifier == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_MEMORY,

       LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

       "%s: unable to create identifier.",

       function );

      goto on_error;

    }

    if( memory_copy(

         internal_value->identifier,

         identifier,

         identifier_size ) == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_MEMORY,

       LIBCERROR_MEMORY_ERROR_COPY_FAILED,

       "%s: unable to copy identifier.",

       function );

      goto on_error;

    }

    internal_value->flags |= LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED;

  }

  internal_value->identifier_size = identifier_size;

  return( 1 );

on_error:

  if( internal_value->identifier != NULL )

  {

    memory_free(

     internal_value->identifier );

    internal_value->identifier = NULL;

  }

  return( -1 );

}

/* Retrieves the value data flags

 * Returns 1 if successful or -1 on error