/*

 * Table functions

 *

 * Copyright (C) 2009-2026, 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 "libesedb_column.h"

#include "libesedb_data_definition.h"

#include "libesedb_definitions.h"

#include "libesedb_index.h"

#include "libesedb_io_handle.h"

#include "libesedb_libbfio.h"

#include "libesedb_libcdata.h"

#include "libesedb_libcerror.h"

#include "libesedb_libfcache.h"

#include "libesedb_libfdata.h"

#include "libesedb_page_tree.h"

#include "libesedb_record.h"

#include "libesedb_table.h"

#include "libesedb_table_definition.h"

#include "libesedb_types.h"

/* Creates a table

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

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_initialize(

     libesedb_table_t **table,

     libbfio_handle_t *file_io_handle,

     libesedb_io_handle_t *io_handle,

     libesedb_table_definition_t *table_definition,

     libesedb_table_definition_t *template_table_definition,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_initialize";

  int segment_index                         = 0;

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  if( *table != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

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

     function );

    return( -1 );

  }

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table definition.",

     function );

    return( -1 );

  }

  if( table_definition->table_catalog_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table definition - missing table catalog definition.",

     function );

    return( -1 );

  }

  internal_table = memory_allocate_structure(

                    libesedb_internal_table_t );

  if( internal_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create table.",

     function );

    goto on_error;

  }

  if( memory_set(

       internal_table,

       0,

       sizeof( libesedb_internal_table_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear table.",

     function );

    memory_free(

     internal_table );

    return( -1 );

  }

  /* TODO add clone function ?

   */

  if( libfdata_vector_initialize(

       &( internal_table->pages_vector ),

       (size64_t) io_handle->page_size,

       (intptr_t *) io_handle,

       NULL,

       NULL,

       (int (*)(intptr_t *, intptr_t *, libfdata_vector_t *, libfdata_cache_t *, int, int, off64_t, size64_t, uint32_t, uint8_t, libcerror_error_t **)) &libesedb_io_handle_read_page,

       NULL,

       LIBFDATA_DATA_HANDLE_FLAG_NON_MANAGED,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create pages vector.",

     function );

    goto on_error;

  }

  if( libfdata_vector_append_segment(

       internal_table->pages_vector,

       &segment_index,

       0,

       io_handle->pages_data_offset,

       io_handle->pages_data_size,

       0,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,

     "%s: unable to append segment to pages vector.",

     function );

    goto on_error;

  }

  if( libfcache_cache_initialize(

       &( internal_table->pages_cache ),

       LIBESEDB_MAXIMUM_CACHE_ENTRIES_PAGES,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create pages cache.",

     function );

    goto on_error;

  }

  if( libesedb_page_tree_initialize(

       &( internal_table->table_page_tree ),

       io_handle,

       internal_table->pages_vector,

       internal_table->pages_cache,

       table_definition->table_catalog_definition->identifier,

       table_definition->table_catalog_definition->father_data_page_number,

       table_definition,

       template_table_definition,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create table page tree.",

     function );

    goto on_error;

  }

  if( table_definition->long_value_catalog_definition != NULL )

  {

    /* TODO add clone function ?

     */

    if( libfdata_vector_initialize(

         &( internal_table->long_values_pages_vector ),

         (size64_t) io_handle->page_size,

         (intptr_t *) io_handle,

         NULL,

         NULL,

         (int (*)(intptr_t *, intptr_t *, libfdata_vector_t *, libfdata_cache_t *, int, int, off64_t, size64_t, uint32_t, uint8_t, libcerror_error_t **)) &libesedb_io_handle_read_page,

         NULL,

         LIBFDATA_DATA_HANDLE_FLAG_NON_MANAGED,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create long values pages vector.",

       function );

      goto on_error;

    }

    if( libfdata_vector_append_segment(

         internal_table->long_values_pages_vector,

         &segment_index,

         0,

         io_handle->pages_data_offset,

         io_handle->pages_data_size,

         0,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,

       "%s: unable to append segment to long values pages vector.",

       function );

      goto on_error;

    }

    if( libfcache_cache_initialize(

         &( internal_table->long_values_pages_cache ),

         LIBESEDB_MAXIMUM_CACHE_ENTRIES_PAGES,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create long values pages cache.",

       function );

      goto on_error;

    }

    if( libesedb_page_tree_initialize(

         &( internal_table->long_values_page_tree ),

         io_handle,

         internal_table->long_values_pages_vector,

         internal_table->long_values_pages_cache,

         table_definition->long_value_catalog_definition->identifier,

         table_definition->long_value_catalog_definition->father_data_page_number,

         table_definition,

         template_table_definition,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create long value page tree.",

       function );

      goto on_error;

    }

  }

  internal_table->io_handle                 = io_handle;

  internal_table->file_io_handle            = file_io_handle;

  internal_table->table_definition          = table_definition;

  internal_table->template_table_definition = template_table_definition;

  *table = (libesedb_table_t *) internal_table;

  return( 1 );

on_error:

  if( internal_table != NULL )

  {

    if( internal_table->long_values_pages_cache != NULL )

    {

      libfcache_cache_free(

       &( internal_table->long_values_pages_cache ),

       NULL );

    }

    if( internal_table->long_values_pages_vector != NULL )

    {

      libfdata_vector_free(

       &( internal_table->long_values_pages_vector ),

       NULL );

    }

    if( internal_table->long_values_page_tree != NULL )

    {

      libesedb_page_tree_free(

       &( internal_table->long_values_page_tree ),

       NULL );

    }

    if( internal_table->table_page_tree != NULL )

    {

      libesedb_page_tree_free(

       &( internal_table->table_page_tree ),

       NULL );

    }

    if( internal_table->pages_cache != NULL )

    {

      libfcache_cache_free(

       &( internal_table->pages_cache ),

       NULL );

    }

    if( internal_table->pages_vector != NULL )

    {

      libfdata_vector_free(

       &( internal_table->pages_vector ),

       NULL );

    }

    memory_free(

     internal_table );

  }

  return( -1 );

}

/* Frees a table

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_free(

     libesedb_table_t **table,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_free";

  int result                                = 1;

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  if( *table != NULL )

  {

    internal_table = (libesedb_internal_table_t *) *table;

    *table         = NULL;

    /* The io_handle, file_io_handle and table_definition references

     * are freed elsewhere

     */

    if( libfdata_vector_free(

         &( internal_table->pages_vector ),

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to free pages vector.",

       function );

      result = -1;

    }

    if( libfcache_cache_free(

         &( internal_table->pages_cache ),

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to free pages cache.",

       function );

      result = -1;

    }

    if( internal_table->long_values_pages_vector != NULL )

    {

      if( libfdata_vector_free(

           &( internal_table->long_values_pages_vector ),

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

         "%s: unable to free long values pages vector.",

         function );

        result = -1;

      }

    }

    if( internal_table->long_values_pages_cache != NULL )

    {

      if( libfcache_cache_free(

           &( internal_table->long_values_pages_cache ),

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

         "%s: unable to free long values pages cache.",

         function );

        result = -1;

      }

    }

    if( internal_table->long_values_page_tree != NULL )

    {

      if( libesedb_page_tree_free(

           &( internal_table->long_values_page_tree ),

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

         "%s: unable to free long values page tree.",

         function );

        result = -1;

      }

    }

    if( libesedb_page_tree_free(

         &( internal_table->table_page_tree ),

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

       "%s: unable to free table page tree.",

       function );

      result = -1;

    }

    memory_free(

     internal_table );

  }

  return( result );

}

/* Retrieves the table identifier or Father Data Page (FDP) object identifier

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_identifier(

     libesedb_table_t *table,

     uint32_t *identifier,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_identifier";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_identifier(

       internal_table->table_definition->table_catalog_definition,

       identifier,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve catalog definition identifier.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the size of the UTF-8 encoded string of the table name

 * The returned size includes the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf8_name_size(

     libesedb_table_t *table,

     size_t *utf8_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf8_name_size";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf8_name_size(

       internal_table->table_definition->table_catalog_definition,

       utf8_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve UTF-8 string size.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the UTF-8 encoded string of the table name

 * The size should include the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf8_name(

     libesedb_table_t *table,

     uint8_t *utf8_string,

     size_t utf8_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf8_name";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf8_name(

       internal_table->table_definition->table_catalog_definition,

       utf8_string,

       utf8_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_CONVERSION,

     LIBCERROR_CONVERSION_ERROR_GENERIC,

     "%s: unable to retrieve UTF-8 string.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the size of the UTF-16 encoded string of the table name

 * The returned size includes the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf16_name_size(

     libesedb_table_t *table,

     size_t *utf16_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf16_name_size";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf16_name_size(

       internal_table->table_definition->table_catalog_definition,

       utf16_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve UTF-16 string size.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the UTF-16 encoded string of the table name

 * The size should include the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf16_name(

     libesedb_table_t *table,

     uint16_t *utf16_string,

     size_t utf16_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf16_name";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf16_name(

       internal_table->table_definition->table_catalog_definition,

       utf16_string,

       utf16_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_CONVERSION,

     LIBCERROR_CONVERSION_ERROR_GENERIC,

     "%s: unable to retrieve UTF-16 string.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the size of the UTF-8 encoded string of the template name

 * The returned size includes the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf8_template_name_size(

     libesedb_table_t *table,

     size_t *utf8_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf8_template_name_size";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf8_template_name_size(

       internal_table->table_definition->table_catalog_definition,

       utf8_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve UTF-8 string size.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the UTF-8 encoded string of the template name

 * The size should include the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf8_template_name(

     libesedb_table_t *table,

     uint8_t *utf8_string,

     size_t utf8_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf8_template_name";

  if( table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table.",

     function );

    return( -1 );

  }

  internal_table = (libesedb_internal_table_t *) table;

  if( internal_table->io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing IO handle.",

     function );

    return( -1 );

  }

  if( internal_table->table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid table - missing table definition.",

     function );

    return( -1 );

  }

  if( libesedb_catalog_definition_get_utf8_template_name(

       internal_table->table_definition->table_catalog_definition,

       utf8_string,

       utf8_string_size,

       internal_table->io_handle->ascii_codepage,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_CONVERSION,

     LIBCERROR_CONVERSION_ERROR_GENERIC,

     "%s: unable to retrieve UTF-8 string.",

     function );

    return( -1 );

  }

  return( 1 );

}

/* Retrieves the size of the UTF-16 encoded string of the template name

 * The returned size includes the end of string character

 * Returns 1 if successful or -1 on error

 */

int libesedb_table_get_utf16_template_name_size(

     libesedb_table_t *table,

     size_t *utf16_string_size,

     libcerror_error_t **error )

{

  libesedb_internal_table_t *internal_table = NULL;

  static char *function                     = "libesedb_table_get_utf16_template_name_size";