#include "mhdf.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <H5Tpublic.h>

Include dependency graph for validate.c:

Functions
static int	check_valid_file_ids (struct mhdf_FileDesc *desc)

static int	check_file_contains_holes (const char *filename)

static int	check_valid_connectivity (mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static int	check_valid_adjacencies (mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static int	check_valid_sets (mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static int	check_valid_tags (mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static const char *	desc_name (struct mhdf_FileDesc desc, struct mhdf_EntDesc grp)

static int	id_contained (long file_id, const long *ranges, int num_range)

static int	ids_contained (const long ids, int num_ids, const long ranges, int num_ranges)

static int	ranges_contained (const long id_ranges, int num_id_ranges, const long ranges, int num_ranges)

static int	string_contained (const char str, const char const *const list)

static int	contains_duplicates (long *array, long n)

static int	ranges_contain_duplicates (long *ranges, long nranges)

static long *	all_id_ranges (struct mhdf_FileDesc desc, int include_null, int num_ranges_out)

static long *	get_dim_ranges (struct mhdf_FileDesc desc, int dim, int num_ranges_out)

static int	merge_ranges (long *ranges, int nranges)

static int	check_valid_end_indices (const long indices, long num_idx, int min_len, long start_id, long max_value, const char typestr, const char *name)

static int	check_valid_elem_conn (int idx, mhdf_FileHandle file, struct mhdf_FileDesc *desc, int conn_dim)

static int	check_valid_poly_conn (int idx, mhdf_FileHandle file, struct mhdf_FileDesc *desc, int conn_dim)

static int	check_valid_tag (int tag_idx, mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static int	check_valid_var_len_tag (int tag_idx, mhdf_FileHandle file, struct mhdf_FileDesc *desc)

static int	check_valid_adj_list (long start_id, long count, const long data, long data_len, const long valid_ranges, long num_valid_ranges, const char *name)

static int	check_valid_parents_children (long start_id, long count, hid_t meta_handle, hid_t data_handle, long data_len, int parents)

static int	check_valid_set_contents (struct mhdf_FileDesc *desc, long start_id, long count, hid_t meta_handle, hid_t data_handle, long data_len)

static int	lcomp (const void p1, const void p2)

static int	dcomp (const void p1, const void p2)

int	main (int argc, char *argv[])

Variables
int	verbose = 0
	program-wide verbose output flag More...

Function Documentation

◆ all_id_ranges()

static long * all_id_ranges	(	struct mhdf_FileDesc *	desc,
		int	include_null,
		int *	num_ranges_out
	)

static

Definition at line 907 of file validate.c.

 {
  int i, num_ranges = 0;
  struct mhdf_EntDesc* group;
  long* ranges = malloc( 2 * sizeof( long ) * ( desc->num_elem_desc + 2 + !!include_null ) );
  if( include_null )
  {
  num_ranges = 1;
  ranges[0] = 0;
  ranges[1] = 1;
  }
  for( i = -1; i <= desc->num_elem_desc; ++i )
  {
  if( i == -1 )
  group = &desc->nodes;
  else if( i == desc->num_elem_desc )
  group = &desc->sets;
  else
  group = &desc->elems[i].desc;
  
  if( num_ranges && ranges[2 * num_ranges - 2] + ranges[2 * num_ranges - 1] == group->start_id )
  {
  ranges[2 * num_ranges - 1] += group->count;
  }
  else
  {
  ranges[2 * num_ranges] = group->start_id;
  ranges[2 * num_ranges + 1] = group->count;
  ++num_ranges;
  }
  }
  
  *num_ranges_out = merge_ranges( ranges, num_ranges );
  return ranges;
 }

References mhdf_EntDesc::count, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, merge_ranges(), mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::sets, and mhdf_EntDesc::start_id.

Referenced by check_valid_set_contents(), check_valid_tag(), and check_valid_var_len_tag().

◆ check_file_contains_holes()

int check_file_contains_holes ( const char * filename )

static

Definition at line 231 of file validate.c.

 {
 #ifndef _WIN32
  const int blocksize = 512;
 #endif
  int errorcode;
  struct stat buf;
  
  errorcode = stat( filename, &buf );
  if( errorcode )
  {
  perror( filename );
  return 1;
  }
  
 #ifndef _WIN32 /*Does not have st_blocks*/
  if( buf.st_size / blocksize > buf.st_blocks + 1 )
  {
  printf( "File \"%s\" contains holes. This indicates that portions of the file were never "
  "written.\n",
  filename );
  return 1;
  }
 #endif
  
  return 0;
 }

Referenced by main().

◆ check_valid_adj_list()

static int check_valid_adj_list	(	long	start_id,
		long	count,
		const long *	data,
		long	data_len,
		const long *	valid_ranges,
		long	num_valid_ranges,
		const char *	name
	)

static

Definition at line 637 of file validate.c.

 {
  long i, n, id, invalid_id = 0, invalid_vals = 0;
  const long* iter = data;
  const long* const end = data + data_len;
  int result = 0;
  
  for( i = 0; iter != end; ++i )
  {
  id = *iter;
  ++iter;
  if( iter == end )
  {
  printf( "Entry %ld in %s adjacency data (ID %ld) is truncated by the end of the "
  "adjacency list.\n",
  i, name, id );
  result = 1;
  break;
  }
  
  if( id < start_id || ( id - start_id ) >= count )
  {
  if( verbose )
  printf( "Entry %ld in %s adjacency data has ID %ld outside of group range [%ld,%ld].\n", i, name, id,
  start_id, start_id + count - 1 );
  ++invalid_id;
  }
  
  n = *iter;
  ++iter;
  if( n < 1 )
  {
  printf( "Entry %ld in %s adjacency data (ID %ld) has %ld adjacency entries.\n", i, name, id, n );
  result = 1;
  if( n < 0 ) break; /* data is corrupt. don't proceed further */
  }
  
  if( iter + n > end )
  {
  printf( "Entry %ld in %s adjacency data (ID %ld) is truncated by the end of the "
  "adjacency list.\n",
  i, name, id );
  result = 1;
  break;
  }
  
  if( !ids_contained( iter, n, valid_ranges, num_valid_ranges ) )
  {
  if( verbose )
  printf( "Entry %ld in %s adjacency data (ID %ld) has invalid IDs in its adjacency "
  "list.\n",
  i, name, id );
  
  ++invalid_vals;
  }
  iter += n;
  }
  
  if( invalid_id )
  {
  printf( "%ld entries in %s adjacency data were for entities not in %s\n", invalid_id, name, name );
  result = 1;
  }
  if( invalid_vals )
  {
  printf( "%ld entries in %s adjacency data contained invalid adjacent entity ids\n", invalid_id, name );
  result = 1;
  }
  return result;
 }

References ids_contained(), and verbose.

Referenced by check_valid_adjacencies().

◆ check_valid_adjacencies()

int check_valid_adjacencies	(	mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 584 of file validate.c.

 {
  const int num_ranges = desc->num_elem_desc;
  long *ranges, *buffer;
  int i;
  int invalid = 0;
  long count;
  hid_t handle;
  mhdf_Status status;
  
  /* Build list of ID ranges for all elements. Consider any element ID to be a valid
  * thing to be adjacent to. So we disallow adjacency to nodes, sets, or undefined IDs */
  ranges = malloc( sizeof( long ) * 2 * num_ranges );
  for( i = 0; i < num_ranges; ++i )
  {
  ranges[2 * i] = desc->elems[i].desc.start_id;
  ranges[2 * i + 1] = desc->elems[i].desc.count;
  }
  
  for( i = 0; i < num_ranges; ++i )
  {
  if( !desc->elems[i].have_adj ) continue;
  
  handle = mhdf_openAdjacency( file, desc->elems[i].handle, &count, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error openening adjacency list for %s: %s\n", desc->elems[i].handle,
  mhdf_message( &status ) );
  free( ranges );
  return 1;
  }
  
  buffer = malloc( sizeof( long ) * count );
  mhdf_readAdjacency( handle, 0, count, H5T_NATIVE_LONG, buffer, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading adjacency list for %s: %s\n", desc->elems[i].handle,
  mhdf_message( &status ) );
  free( ranges );
  mhdf_closeData( file, handle, &status );
  return 1;
  }
  mhdf_closeData( file, handle, &status );
  
  invalid += check_valid_adj_list( desc->elems[i].desc.start_id, desc->elems[i].desc.count, buffer, count, ranges,
  num_ranges, desc->elems[i].handle );
  free( buffer );
  }
  
  free( ranges );
  return invalid;
 }

References buffer, check_valid_adj_list(), mhdf_EntDesc::count, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, mhdf_ElemDesc::handle, mhdf_ElemDesc::have_adj, mhdf_closeData(), mhdf_isError(), mhdf_message(), mhdf_openAdjacency(), mhdf_readAdjacency(), mhdf_FileDesc::num_elem_desc, and mhdf_EntDesc::start_id.

Referenced by main().

◆ check_valid_connectivity()

int check_valid_connectivity	(	mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 259 of file validate.c.

 {
  int idx, dim, result = 0;
  
  for( idx = 0; idx < desc->num_elem_desc; ++idx )
  {
  if( !strcmp( desc->elems[idx].type, mhdf_POLYHEDRON_TYPE_NAME ) )
  dim = 2;
  else
  dim = 0;
  
  if( desc->elems[idx].desc.vals_per_ent == -1 )
  result += check_valid_poly_conn( idx, file, desc, dim );
  else
  result += check_valid_elem_conn( idx, file, desc, dim );
  }
  
  return result;
 }

References check_valid_elem_conn(), check_valid_poly_conn(), mhdf_ElemDesc::desc, dim, mhdf_FileDesc::elems, mhdf_POLYHEDRON_TYPE_NAME, mhdf_FileDesc::num_elem_desc, mhdf_ElemDesc::type, and mhdf_EntDesc::vals_per_ent.

Referenced by main().

◆ check_valid_elem_conn()

int check_valid_elem_conn	(	int	idx,
		mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc,
		int	conn_dim
	)

static

Definition at line 379 of file validate.c.

 {
  long *ranges, *buffer, *iter;
  int num_ranges;
  long i, invalid = 0;
  hid_t handle;
  mhdf_Status status;
  const long count = desc->elems[idx].desc.count;
  const long len = desc->elems[idx].desc.vals_per_ent;
  
  ranges = get_dim_ranges( desc, conn_dim, &num_ranges );
  handle = mhdf_openConnectivitySimple( file, desc->elems[idx].handle, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening connectivity for %s: %s\n", desc->elems[idx].handle,
  mhdf_message( &status ) );
  free( ranges );
  return 1;
  }
  
  buffer = malloc( sizeof( long ) * count * len );
  mhdf_readConnectivity( handle, 0, count, H5T_NATIVE_LONG, buffer, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading connectivity for %s: %s\n", desc->elems[idx].handle,
  mhdf_message( &status ) );
  free( ranges );
  free( buffer );
  mhdf_closeData( file, handle, &status );
  return 1;
  }
  mhdf_closeData( file, handle, &status );
  
  iter = buffer;
  for( i = 0; i < count; ++i, iter += len )
  {
  if( !ids_contained( iter, len, ranges, num_ranges ) )
  {
  if( verbose )
  printf( "Invalid connectivity for element %ld (ID %ld) in %s\n", i, i + desc->elems[idx].desc.start_id,
  desc->elems[idx].handle );
  ++invalid;
  }
  }
  free( buffer );
  free( ranges );
  
  if( invalid )
  {
  printf( "%ld elements with invalid connectivity in %s\n", invalid, desc->elems[idx].handle );
  return 1;
  }
  return 0;
 }

References buffer, mhdf_EntDesc::count, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, get_dim_ranges(), mhdf_ElemDesc::handle, ids_contained(), mhdf_closeData(), mhdf_isError(), mhdf_message(), mhdf_openConnectivitySimple(), mhdf_readConnectivity(), mhdf_EntDesc::start_id, mhdf_EntDesc::vals_per_ent, and verbose.

Referenced by check_valid_connectivity().

◆ check_valid_end_indices()

static int check_valid_end_indices	(	const long *	indices,
		long	num_idx,
		int	min_len,
		long	start_id,
		long	max_value,
		const char *	typestr,
		const char *	name
	)

static

Definition at line 434 of file validate.c.

 {
  long i, invalid = 0, prev = -1;
  
  if( num_idx == 0 )
  {
  printf( "WARNING: Empty index list for %s %s\n", name, typestr );
  return 0;
  }
  
  for( i = 0; i < num_idx; ++i )
  {
  if( indices[i] < prev )
  {
  if( verbose )
  {
  if( start_id > 0 )
  printf( "Invalid end index %ld for %s %ld (ID %ld). Prev index is %ld\n", indices[i], name, i,
  i + start_id, prev );
  else
  printf( "Invalid end index %ld for entry %ld in %s %s. Prev index is %ld\n", indices[i], i, name,
  typestr, prev );
  }
  ++invalid;
  }
  else if( indices[i] - prev < min_len )
  {
  if( verbose )
  {
  if( start_id > 0 )
  printf( "%s %ld (ID %ld) has only %ld values\n", name, i, start_id, indices[i] - prev );
  else
  printf( "Entry %ld in %s %s has only %ld values\n", i, name, typestr, indices[i] - prev );
  }
  ++invalid;
  }
  else if( indices[i] >= max_value )
  {
  if( verbose )
  {
  if( start_id > 0 )
  printf( "%s %ld (ID %ld) end index exceeds upper bound of %ld\n", name, i, start_id, max_value );
  else
  printf( "Entry %ld in %s %s end index exceeds uppper bound of %ld\n", i, name, typestr, max_value );
  }
  ++invalid;
  }
  prev = indices[i];
  }
  
  if( invalid )
  {
  printf( "%ld invalid end indices for %s %s\n", invalid, typestr, name );
  }
  
  return invalid;
 }

References verbose.

Referenced by check_valid_parents_children(), check_valid_poly_conn(), check_valid_set_contents(), and check_valid_var_len_tag().

◆ check_valid_file_ids()

int check_valid_file_ids ( struct mhdf_FileDesc * desc )

static

Definition at line 195 of file validate.c.

 {
  const int ngrp = 2 + desc->num_elem_desc;
  int i, err = 0;
  struct mhdf_EntDesc** sorted = malloc( ngrp * sizeof( struct mhdf_EntDesc* ) );
  for( i = 0; i < desc->num_elem_desc; ++i )
  sorted[i] = &desc->elems[i].desc;
  sorted[i++] = &desc->nodes;
  sorted[i] = &desc->sets;
  qsort( sorted, ngrp, sizeof( struct mhdf_EntDesc* ), &dcomp );
  for( i = 0; i < ngrp; ++i )
  {
  if( sorted[i]->count < 0 )
  {
  printf( "Group \"%s\" has negative count!\n", desc_name( desc, sorted[i] ) );
  ++err;
  }
  if( sorted[i]->count && sorted[i]->start_id == 0 )
  {
  printf( "Group \"%s\" contains NULL ID!\n", desc_name( desc, sorted[i] ) );
  ++err;
  }
  
  if( i > 0 && sorted[i - 1]->start_id + sorted[i - 1]->count > sorted[i]->start_id )
  {
  printf( "Conflicting group IDs for \"%s\" [%ld,%ld] and \"%s\" [%ld,%ld]\n",
  desc_name( desc, sorted[i - 1] ), sorted[i - 1]->start_id,
  sorted[i - 1]->start_id + sorted[i - 1]->count - 1, desc_name( desc, sorted[i] ),
  sorted[i]->start_id, sorted[i]->start_id + sorted[i]->count - 1 );
  ++err;
  }
  }
  free( sorted );
  return err;
 }

References mhdf_EntDesc::count, dcomp(), mhdf_ElemDesc::desc, desc_name(), mhdf_FileDesc::elems, mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::sets, and mhdf_EntDesc::start_id.

Referenced by main().

◆ check_valid_parents_children()

static int check_valid_parents_children	(	long	start_id,
		long	count,
		hid_t	meta_handle,
		hid_t	data_handle,
		long	data_len,
		int	parents
	)

static

Definition at line 796 of file validate.c.

 {
  mhdf_Status status;
  long *indices, *contents;
  const char parstr[] = "Parent";
  const char cldstr[] = "Child";
  const char* name = parents ? parstr : cldstr;
  long i, prev, start, n;
  long invalid = 0, invalid_dup = 0;
  long range[2];
  int result = 0;
  range[0] = start_id;
  range[1] = count;
  
  indices = malloc( sizeof( long ) * count );
  if( parents )
  mhdf_readSetParentEndIndices( meta_handle, 0, count, H5T_NATIVE_LONG, indices, &status );
  else
  mhdf_readSetChildEndIndices( meta_handle, 0, count, H5T_NATIVE_LONG, indices, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading set %s end indices: %s\n", name, mhdf_message( &status ) );
  free( indices );
  return 1;
  }
  
  if( check_valid_end_indices( indices, count, 0, start_id, data_len, "Set", name ) )
  {
  free( indices );
  return 1;
  }
  
  contents = malloc( sizeof( long ) * data_len );
  mhdf_readSetParentsChildren( data_handle, 0, data_len, H5T_NATIVE_LONG, contents, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading set %s IDs: %s\n", name, mhdf_message( &status ) );
  free( indices );
  free( contents );
  return 1;
  }
  
  prev = -1;
  for( i = 0; i < count; ++i )
  {
  start = prev + 1;
  n = indices[i] - prev;
  prev = indices[i];
  
  if( !ids_contained( contents + start, n, range, 1 ) )
  {
  if( verbose ) printf( "Set %ld (ID %ld) has invalid %s IDs.\n", i, start_id + i, name );
  ++invalid;
  }
  else if( contains_duplicates( contents + start, n ) )
  {
  if( verbose ) printf( "Set %ld (ID %ld) %s list contains duplicate IDs.\n", i, start_id + i, name );
  ++invalid_dup;
  }
  }
  
  free( indices );
  free( contents );
  
  if( invalid )
  {
  printf( "%ld sets had invalid %s lists.\n", invalid, name );
  result = 1;
  }
  
  if( invalid_dup )
  {
  printf( "%ld sets had duplicate handles in %s lists.\n", invalid_dup, name );
  result = 1;
  }
  
  return result;
 }

References check_valid_end_indices(), contains_duplicates(), ids_contained(), mhdf_isError(), mhdf_message(), mhdf_readSetChildEndIndices(), mhdf_readSetParentEndIndices(), mhdf_readSetParentsChildren(), and verbose.

Referenced by check_valid_sets().

◆ check_valid_poly_conn()

int check_valid_poly_conn	(	int	idx,
		mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc,
		int	conn_dim
	)

static

Definition at line 498 of file validate.c.

 {
  long *ranges, *buffer, *indices, *iter;
  int num_ranges;
  long i, invalid, num_poly, num_conn, first_id, prev, len;
  hid_t handles[2];
  mhdf_Status status;
  int min_conn_len;
  if( !strcmp( mhdf_POLYHEDRON_TYPE_NAME, desc->elems[idx].type ) )
  min_conn_len = 4;
  else
  min_conn_len = 3;
  
  mhdf_openPolyConnectivity( file, desc->elems[idx].handle, &num_poly, &num_conn, &first_id, handles, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening connectivity for %s: %s\n", desc->elems[idx].handle,
  mhdf_message( &status ) );
  return 1;
  }
  
  indices = malloc( sizeof( long ) * num_poly );
  mhdf_readPolyConnIndices( handles[0], 0, num_poly, H5T_NATIVE_LONG, indices, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading poly indices for %s: %s\n", desc->elems[idx].handle,
  mhdf_message( &status ) );
  free( indices );
  mhdf_closeData( file, handles[0], &status );
  mhdf_closeData( file, handles[1], &status );
  return 1;
  }
  mhdf_closeData( file, handles[0], &status );
  
  invalid = check_valid_end_indices( indices, num_poly, min_conn_len, first_id, num_conn, "Connectivity",
  desc->elems[idx].handle );
  if( invalid )
  {
  free( indices );
  mhdf_closeData( file, handles[1], &status );
  return 1;
  }
  
  ranges = get_dim_ranges( desc, conn_dim, &num_ranges );
  
  buffer = malloc( sizeof( long ) * num_conn );
  mhdf_readPolyConnIDs( handles[1], 0, num_conn, H5T_NATIVE_LONG, buffer, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading connectivity for %s: %s\n", desc->elems[idx].handle,
  mhdf_message( &status ) );
  free( ranges );
  free( indices );
  free( buffer );
  mhdf_closeData( file, handles[1], &status );
  return 1;
  }
  mhdf_closeData( file, handles[1], &status );
  
  prev = -1;
  iter = buffer;
  for( i = 0; i < num_poly; ++i )
  {
  len = indices[i] - prev;
  prev = indices[i];
  if( !ids_contained( iter, len, ranges, num_ranges ) )
  {
  if( verbose )
  printf( "Invalid connectivity for element %ld (ID %ld) in %s\n", i, i + first_id,
  desc->elems[idx].handle );
  ++invalid;
  }
  iter += len;
  }
  free( indices );
  free( buffer );
  free( ranges );
  
  if( invalid )
  {
  printf( "%ld elements with invalid connectivity in %s\n", invalid, desc->elems[idx].handle );
  return 1;
  }
  return 0;
 }

References buffer, check_valid_end_indices(), mhdf_FileDesc::elems, get_dim_ranges(), mhdf_ElemDesc::handle, ids_contained(), mhdf_closeData(), mhdf_isError(), mhdf_message(), mhdf_openPolyConnectivity(), mhdf_POLYHEDRON_TYPE_NAME, mhdf_readPolyConnIDs(), mhdf_readPolyConnIndices(), mhdf_ElemDesc::type, and verbose.

Referenced by check_valid_connectivity().

◆ check_valid_set_contents()

static int check_valid_set_contents	(	struct mhdf_FileDesc *	desc,
		long	start_id,
		long	count,
		hid_t	meta_handle,
		hid_t	data_handle,
		long	data_len
	)

static

Definition at line 943 of file validate.c.

 {
  mhdf_Status status;
  long *indices, *contents;
  short* flags;
  long i, prev, start, n;
  long invalid_len = 0, invalid_handle = 0, invalid_dup = 0;
  long* ranges;
  int num_ranges;
  int tmpresult;
  
  indices = malloc( sizeof( long ) * count );
  mhdf_readSetContentEndIndices( meta_handle, 0, count, H5T_NATIVE_LONG, indices, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading set content end indices: %s\n", mhdf_message( &status ) );
  free( indices );
  return 1;
  }
  
  if( check_valid_end_indices( indices, count, 0, start_id, data_len, "Set", "Content" ) )
  {
  free( indices );
  return 1;
  }
  
  ranges = all_id_ranges( desc, 0, &num_ranges );
  
  flags = malloc( sizeof( short ) * count );
  mhdf_readSetFlags( meta_handle, 0, count, H5T_NATIVE_SHORT, flags, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading set flags: %s\n", mhdf_message( &status ) );
  free( indices );
  free( flags );
  free( ranges );
  return 1;
  }
  
  contents = malloc( sizeof( long ) * data_len );
  mhdf_readSetData( data_handle, 0, data_len, H5T_NATIVE_LONG, contents, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading set content IDs: %s\n", mhdf_message( &status ) );
  free( indices );
  free( contents );
  free( flags );
  free( ranges );
  return 1;
  }
  
  prev = -1;
  for( i = 0; i < count; ++i )
  {
  start = prev + 1;
  n = indices[i] - prev;
  prev = indices[i];
  
  if( flags[i] & mhdf_SET_RANGE_BIT )
  {
  if( n % 2 )
  {
  if( verbose )
  printf( "Set %ld (ID %ld) is marked as range-compressed but has odd number of "
  "content values.\n",
  i + 1, start_id + i );
  ++invalid_len;
  continue;
  }
  tmpresult = ranges_contained( contents + start, n / 2, ranges, num_ranges );
  }
  else
  {
  tmpresult = ids_contained( contents + start, n, ranges, num_ranges );
  }
  if( !tmpresult )
  {
  if( verbose ) printf( "Set %ld (ID %ld) has invalid content IDs.\n", i + 1, start_id + i );
  ++invalid_handle;
  continue;
  }
  
  if( flags[i] & mhdf_SET_ORDER_BIT ) continue;
  
  if( flags[i] & mhdf_SET_RANGE_BIT )
  tmpresult = ranges_contain_duplicates( contents + start, n / 2 );
  else
  tmpresult = contains_duplicates( contents + start, n );
  if( tmpresult )
  {
  if( verbose )
  printf( "Set %ld (ID %ld) is not ordered but contains duplicate handles.\n", i + 1, start_id + i );
  ++invalid_dup;
  }
  }
  
  free( indices );
  free( contents );
  free( flags );
  free( ranges );
  
  tmpresult = 0;
  if( invalid_len )
  {
  printf( "%ld ranged sets had invalid (odd) content list lengths.\n", invalid_len );
  tmpresult = 1;
  }
  if( invalid_handle )
  {
  printf( "%ld sets had invalid IDs in their content lists.\n", invalid_handle );
  tmpresult = 1;
  }
  if( invalid_dup )
  {
  printf( "%ld unordered sets had duplicate IDs in their content lists.\n", invalid_dup );
  tmpresult = 1;
  }
  
  return tmpresult;
 }

References all_id_ranges(), check_valid_end_indices(), contains_duplicates(), mhdf_EntDesc::count, ids_contained(), mhdf_isError(), mhdf_message(), mhdf_readSetContentEndIndices(), mhdf_readSetData(), mhdf_readSetFlags(), mhdf_SET_ORDER_BIT, mhdf_SET_RANGE_BIT, ranges_contain_duplicates(), ranges_contained(), mhdf_EntDesc::start_id, and verbose.

Referenced by check_valid_sets().

◆ check_valid_sets()

int check_valid_sets	(	mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 714 of file validate.c.

 {
  long count, start_id, data_len;
  mhdf_Status status;
  hid_t meta, handle;
  int result = 0;
  
  if( desc->sets.count == 0 ) return 0;
  
  meta = mhdf_openSetMeta( file, &count, &start_id, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening set description table: %s\n", mhdf_message( &status ) );
  return 1;
  }
  
  if( desc->have_set_contents )
  {
  handle = mhdf_openSetData( file, &data_len, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening set contents table: %s\n", mhdf_message( &status ) );
  }
  else
  {
  result += check_valid_set_contents( desc, start_id, count, meta, handle, data_len );
  mhdf_closeData( file, handle, &status );
  }
  }
  
  if( desc->have_set_children )
  {
  handle = mhdf_openSetChildren( file, &data_len, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening set child table: %s\n", mhdf_message( &status ) );
  mhdf_closeData( file, meta, &status );
  }
  else
  {
  result += check_valid_parents_children( start_id, count, meta, handle, data_len, 0 );
  mhdf_closeData( file, handle, &status );
  }
  }
  
  if( desc->have_set_parents )
  {
  handle = mhdf_openSetParents( file, &data_len, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening set child table: %s\n", mhdf_message( &status ) );
  mhdf_closeData( file, meta, &status );
  }
  else
  {
  result += check_valid_parents_children( start_id, count, meta, handle, data_len, 1 );
  mhdf_closeData( file, handle, &status );
  }
  }
  
  mhdf_closeData( file, meta, &status );
  return result;
 }

References check_valid_parents_children(), check_valid_set_contents(), mhdf_EntDesc::count, mhdf_FileDesc::have_set_children, mhdf_FileDesc::have_set_contents, mhdf_FileDesc::have_set_parents, mhdf_closeData(), mhdf_isError(), mhdf_message(), mhdf_openSetChildren(), mhdf_openSetData(), mhdf_openSetMeta(), mhdf_openSetParents(), and mhdf_FileDesc::sets.

Referenced by main().

◆ check_valid_tag()

static int check_valid_tag	(	int	tag_idx,
		mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 1082 of file validate.c.

 {
  long *ids = 0, count, junk;
  long* ranges;
  int nranges;
  hid_t handles[3];
  mhdf_Status status;
  const struct mhdf_TagDesc* tag = &( desc->tags[tag_idx] );
  int i, result = 0;
  long srange[2] = { 0, 0 };
  const char* name;
  struct mhdf_EntDesc* group;
  hid_t h5type;
  hsize_t size;
  
  if( tag->have_sparse )
  {
  mhdf_openSparseTagData( file, tag->name, &count, &junk, handles, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening sparse data for tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  return 1;
  }
  
  ids = malloc( sizeof( long ) * count );
  mhdf_readSparseTagEntities( handles[0], 0, count, H5T_NATIVE_LONG, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading sparse entities for tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  mhdf_closeData( file, handles[0], &status );
  mhdf_closeData( file, handles[1], &status );
  free( ids );
  return 1;
  }
  
  mhdf_closeData( file, handles[0], &status );
  ranges = all_id_ranges( desc, 0, &nranges );
  if( !ids_contained( ids, count, ranges, nranges ) )
  {
  ++result;
  printf( "Sparse data for tag \"%s\" has values for invalid IDs\n", tag->name );
  }
  else if( contains_duplicates( ids, count ) )
  {
  ++result;
  printf( "Sparse data for tag \"%s\" has duplicate values for one or more entities\n", tag->name );
  }
  free( ranges );
  
  for( i = 0; i < tag->num_dense_indices; ++i )
  {
  if( tag->dense_elem_indices[i] == -2 )
  {
  name = mhdf_set_type_handle();
  group = &desc->sets;
  }
  else if( tag->dense_elem_indices[i] == -1 )
  {
  name = mhdf_node_type_handle();
  group = &desc->nodes;
  }
  else
  {
  name = desc->elems[tag->dense_elem_indices[i]].handle;
  group = &desc->elems[tag->dense_elem_indices[i]].desc;
  }
  
  srange[0] = group->start_id;
  srange[1] = group->count;
  if( ids_contained( ids, count, srange, 2 ) )
  {
  ++result;
  printf( "Tag \"%s\" has both sparse values and dense values for one or more "
  "entities in \"%s\"\n",
  tag->name, name );
  }
  }
  
  free( ids );
  }
  
  if( tag->type != mhdf_ENTITY_ID )
  {
  if( tag->have_sparse ) mhdf_closeData( file, handles[1], &status );
  return result;
  }
  
  ranges = all_id_ranges( desc, 1, &nranges );
  if( tag->default_value && !ids_contained( tag->default_value, tag->size, ranges, nranges ) )
  {
  ++result;
  printf( "Handle tag \"%s\" has invalid ID(s) in its default value.\n", tag->name );
  }
  if( tag->global_value && !ids_contained( tag->global_value, tag->size, ranges, nranges ) )
  {
  ++result;
  printf( "Handle tag \"%s\" has invalid ID(s) in its global/mesh value.\n", tag->name );
  }
  
  h5type = H5T_NATIVE_LONG;
  if( tag->size > 1 )
  {
  size = tag->size;
 #if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
  h5type = H5Tarray_create( H5T_NATIVE_LONG, 1, &size );
 #else
  h5type = H5Tarray_create( H5T_NATIVE_LONG, 1, &size, NULL );
 #endif
  }
  
  if( tag->have_sparse )
  {
  ids = malloc( tag->size * count * sizeof( long ) );
  mhdf_readTagValues( handles[1], 0, count, h5type, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading sparse values for handle tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  mhdf_closeData( file, handles[1], &status );
  free( ids );
  free( ranges );
  if( tag->size > 1 ) H5Tclose( h5type );
  return 1;
  }
  mhdf_closeData( file, handles[1], &status );
  
  if( !ids_contained( ids, tag->size * count, ranges, nranges ) )
  {
  ++result;
  printf( "Sparse data for one or more entities with handle tag \"%s\" has invalid ID(s).\n", tag->name );
  }
  free( ids );
  }
  
  for( i = 0; i < tag->num_dense_indices; ++i )
  {
  if( tag->dense_elem_indices[i] == -2 )
  {
  name = mhdf_set_type_handle();
  /*group = &desc->sets;*/
  }
  else if( tag->dense_elem_indices[i] == -1 )
  {
  name = mhdf_node_type_handle();
  /*group = &desc->nodes;*/
  }
  else
  {
  name = desc->elems[tag->dense_elem_indices[i]].handle;
  /*group = &desc->elems[ tag->dense_elem_indices[i] ].desc;*/
  }
  
  handles[0] = mhdf_openDenseTagData( file, tag->name, name, &count, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal dense values for handle tag \"%s\" on \"%s\": %s\n", tag->name, name,
  mhdf_message( &status ) );
  ++result;
  continue;
  }
  
  ids = malloc( tag->size * count * sizeof( long ) );
  mhdf_readTagValues( handles[0], 0, count, h5type, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading dense values for handle tag \"%s\" on \"%s\": %s\n", tag->name,
  name, mhdf_message( &status ) );
  mhdf_closeData( file, handles[0], &status );
  free( ids );
  ++result;
  continue;
  }
  mhdf_closeData( file, handles[1], &status );
  
  if( !ids_contained( ids, count, ranges, nranges ) )
  {
  ++result;
  printf( "Dense data on \"%s\" for handle tag \"%s\" has invalid ID(s) for one or more "
  "entities.\n",
  name, tag->name );
  }
  free( ids );
  }
  
  if( tag->size > 1 ) H5Tclose( h5type );
  
  return result;
 }

References all_id_ranges(), contains_duplicates(), mhdf_EntDesc::count, mhdf_TagDesc::default_value, mhdf_TagDesc::dense_elem_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, mhdf_TagDesc::global_value, mhdf_ElemDesc::handle, mhdf_TagDesc::have_sparse, ids_contained(), mhdf_closeData(), mhdf_ENTITY_ID, mhdf_isError(), mhdf_message(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openSparseTagData(), mhdf_readSparseTagEntities(), mhdf_readTagValues(), mhdf_set_type_handle(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, mhdf_FileDesc::sets, mhdf_TagDesc::size, size, mhdf_EntDesc::start_id, mhdf_FileDesc::tags, and mhdf_TagDesc::type.

Referenced by check_valid_tags().

◆ check_valid_tags()

int check_valid_tags	(	mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 1069 of file validate.c.

 {
  int i, result = 0;
  for( i = 0; i < desc->num_tag_desc; ++i )
  {
  if( desc->tags[i].size < 0 )
  result += check_valid_var_len_tag( i, file, desc );
  else
  result += check_valid_tag( i, file, desc );
  }
  return result;
 }

References check_valid_tag(), check_valid_var_len_tag(), mhdf_FileDesc::num_tag_desc, mhdf_TagDesc::size, and mhdf_FileDesc::tags.

Referenced by main().

◆ check_valid_var_len_tag()

static int check_valid_var_len_tag	(	int	tag_idx,
		mhdf_FileHandle	file,
		struct mhdf_FileDesc *	desc
	)

static

Definition at line 1273 of file validate.c.

 {
  long *ids = 0, count, num_val;
  long* ranges;
  int nranges;
  hid_t handles[3];
  mhdf_Status status;
  const struct mhdf_TagDesc* tag = &( desc->tags[tag_idx] );
  int result = 0;
  
  if( tag->num_dense_indices != 0 )
  {
  printf( "Dense data for tag \"%s\" not allowed for variable-length tags\n", tag->name );
  ++result;
  }
  
  if( tag->have_sparse )
  {
  mhdf_openSparseTagData( file, tag->name, &count, &num_val, handles, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error opening sparse data for tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  return 1;
  }
  
  ids = malloc( sizeof( long ) * count );
  mhdf_readSparseTagEntities( handles[0], 0, count, H5T_NATIVE_LONG, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading sparse entities for tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  mhdf_closeData( file, handles[0], &status );
  mhdf_closeData( file, handles[1], &status );
  mhdf_closeData( file, handles[2], &status );
  free( ids );
  return 1;
  }
  
  mhdf_closeData( file, handles[0], &status );
  ranges = all_id_ranges( desc, 0, &nranges );
  if( !ids_contained( ids, count, ranges, nranges ) )
  {
  ++result;
  printf( "Sparse data for tag \"%s\" has values for invalid IDs\n", tag->name );
  }
  else if( contains_duplicates( ids, count ) )
  {
  ++result;
  printf( "Sparse data for tag \"%s\" has duplicate values for one or more entities\n", tag->name );
  }
  free( ranges );
  
  mhdf_readSparseTagIndices( handles[2], 0, count, H5T_NATIVE_LONG, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading indices for variable length tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  mhdf_closeData( file, handles[1], &status );
  mhdf_closeData( file, handles[2], &status );
  free( ids );
  return 1;
  }
  mhdf_closeData( file, handles[2], &status );
  
  if( check_valid_end_indices( ids, count, 1, 0, num_val, "Variable-length tag", tag->name ) ) ++result;
  free( ids );
  }
  
  if( tag->type != mhdf_ENTITY_ID )
  {
  if( tag->have_sparse ) mhdf_closeData( file, handles[1], &status );
  return result;
  }
  
  ranges = all_id_ranges( desc, 1, &nranges );
  if( tag->default_value && !ids_contained( tag->default_value, tag->default_value_size, ranges, nranges ) )
  {
  ++result;
  printf( "Handle tag \"%s\" has invalid ID(s) in its default value.\n", tag->name );
  }
  if( tag->global_value && !ids_contained( tag->global_value, tag->global_value_size, ranges, nranges ) )
  {
  ++result;
  printf( "Handle tag \"%s\" has invalid ID(s) in its global/mesh value.\n", tag->name );
  }
  
  if( tag->have_sparse )
  {
  ids = malloc( num_val * sizeof( long ) );
  mhdf_readTagValues( handles[1], 0, num_val, H5T_NATIVE_LONG, ids, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "Internal error reading values for variable-length handle tag \"%s\": %s\n", tag->name,
  mhdf_message( &status ) );
  mhdf_closeData( file, handles[1], &status );
  free( ids );
  free( ranges );
  return 1;
  }
  mhdf_closeData( file, handles[1], &status );
  
  if( !ids_contained( ids, tag->size * count, ranges, nranges ) )
  {
  ++result;
  printf( "Data for one or more entities with variable-length handle tag \"%s\" has "
  "invalid ID(s).\n",
  tag->name );
  }
  free( ids );
  }
  
  return result;
 }

References all_id_ranges(), check_valid_end_indices(), contains_duplicates(), mhdf_EntDesc::count, mhdf_TagDesc::default_value, mhdf_TagDesc::default_value_size, mhdf_TagDesc::global_value, mhdf_TagDesc::global_value_size, mhdf_TagDesc::have_sparse, ids_contained(), mhdf_closeData(), mhdf_ENTITY_ID, mhdf_isError(), mhdf_message(), mhdf_openSparseTagData(), mhdf_readSparseTagEntities(), mhdf_readSparseTagIndices(), mhdf_readTagValues(), mhdf_TagDesc::name, mhdf_TagDesc::num_dense_indices, mhdf_TagDesc::size, mhdf_FileDesc::tags, and mhdf_TagDesc::type.

Referenced by check_valid_tags().

◆ contains_duplicates()

static int contains_duplicates	(	long *	array,
		long	n
	)

static

Definition at line 778 of file validate.c.

 {
  long i;
  qsort( array, n, sizeof( long ), &lcomp );
  for( i = 1; i < n; ++i )
  if( array[i - 1] == array[i] ) return 1;
  return 0;
 }

References lcomp().

Referenced by check_valid_parents_children(), check_valid_set_contents(), check_valid_tag(), and check_valid_var_len_tag().

◆ dcomp()

static int dcomp	(	const void *	p1,
		const void *	p2
	)

static

Definition at line 127 of file validate.c.

 {
  const struct mhdf_EntDesc* d1 = *(const struct mhdf_EntDesc**)( p1 );
  const struct mhdf_EntDesc* d2 = *(const struct mhdf_EntDesc**)( p2 );
  return lcomp( &d1->start_id, &d2->start_id );
 }

References lcomp(), and mhdf_EntDesc::start_id.

Referenced by check_valid_file_ids().

◆ desc_name()

static const char * desc_name	(	struct mhdf_FileDesc *	desc,
		struct mhdf_EntDesc *	grp
	)

static

Definition at line 182 of file validate.c.

 {
  struct mhdf_ElemDesc junk, *elem;
  const size_t diff = (char*)&junk.desc - (char*)&junk;
  static const char nodes[] = "Vertices";
  static const char sets[] = "Sets";
  if( grp == &desc->nodes ) return nodes;
  if( grp == &desc->sets ) return sets;
  
  elem = (struct mhdf_ElemDesc*)( (char*)grp - diff );
  return elem->handle;
 }

References mhdf_ElemDesc::desc, and mhdf_ElemDesc::handle.

Referenced by check_valid_file_ids().

◆ get_dim_ranges()

static long * get_dim_ranges	(	struct mhdf_FileDesc *	desc,
		int	dim,
		int *	num_ranges_out
	)

static

Definition at line 329 of file validate.c.

 {
  long* ranges = 0;
  int i, j;
  const char* const types1D[] = { mhdf_EDGE_TYPE_NAME, 0 };
  const char* const types2D[] = { mhdf_TRI_TYPE_NAME, mhdf_QUAD_TYPE_NAME, mhdf_POLYGON_TYPE_NAME, 0 };
  const char* const types3D[] = { mhdf_TET_TYPE_NAME, mhdf_PYRAMID_TYPE_NAME,
  mhdf_PRISM_TYPE_NAME, mdhf_KNIFE_TYPE_NAME,
  mdhf_HEX_TYPE_NAME, mhdf_POLYHEDRON_TYPE_NAME,
  mhdf_SEPTAHEDRON_TYPE_NAME, 0 };
  
  char const* const* typelist;
  switch( dim )
  {
  case 0:
  *num_ranges_out = 1;
  ranges = malloc( 2 * sizeof( long ) );
  ranges[0] = desc->nodes.start_id;
  ranges[1] = desc->nodes.count;
  return ranges;
  case 1:
  typelist = types1D;
  break;
  case 2:
  typelist = types2D;
  break;
  case 3:
  typelist = types3D;
  break;
  default:
  fprintf( stderr, "Internal error at %s:%d: request for entities of dimesion %d\n", __FILE__, __LINE__,
  dim );
  abort();
  }
  
  *num_ranges_out = 0;
  for( i = 0; i < desc->num_elem_desc; ++i )
  if( string_contained( desc->elems[i].type, typelist ) ) ++*num_ranges_out;
  ranges = malloc( *num_ranges_out * 2 * sizeof( long ) );
  for( i = 0, j = 0; i < desc->num_elem_desc; ++i )
  if( string_contained( desc->elems[i].type, typelist ) )
  {
  ranges[j++] = desc->elems[i].desc.start_id;
  ranges[j++] = desc->elems[i].desc.count;
  }
  
  *num_ranges_out = merge_ranges( ranges, *num_ranges_out );
  return ranges;
 }

References mhdf_EntDesc::count, mhdf_ElemDesc::desc, dim, mhdf_FileDesc::elems, mdhf_HEX_TYPE_NAME, mdhf_KNIFE_TYPE_NAME, merge_ranges(), mhdf_EDGE_TYPE_NAME, mhdf_POLYGON_TYPE_NAME, mhdf_POLYHEDRON_TYPE_NAME, mhdf_PRISM_TYPE_NAME, mhdf_PYRAMID_TYPE_NAME, mhdf_QUAD_TYPE_NAME, mhdf_SEPTAHEDRON_TYPE_NAME, mhdf_TET_TYPE_NAME, mhdf_TRI_TYPE_NAME, mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_EntDesc::start_id, string_contained(), and mhdf_ElemDesc::type.

Referenced by check_valid_elem_conn(), and check_valid_poly_conn().

◆ id_contained()

static int id_contained	(	long	file_id,
		const long *	ranges,
		int	num_range
	)

static

Definition at line 279 of file validate.c.

 {
  const long* end = ranges + 2 * num_range;
  for( ; ranges != end; ranges += 2 )
  {
  if( file_id >= ranges[0] && ( file_id - ranges[0] ) < ranges[1] ) return 1;
  }
  return 0;
 }

Referenced by ids_contained().

◆ ids_contained()

static int ids_contained	(	const long *	ids,
		int	num_ids,
		const long *	ranges,
		int	num_ranges
	)

static

Definition at line 289 of file validate.c.

 {
  int i;
  for( i = 0; i < num_ids; ++i )
  if( !id_contained( ids[i], ranges, num_ranges ) ) return 0;
  return 1;
 }

References id_contained().

Referenced by check_valid_adj_list(), check_valid_elem_conn(), check_valid_parents_children(), check_valid_poly_conn(), check_valid_set_contents(), check_valid_tag(), and check_valid_var_len_tag().

◆ lcomp()

static int lcomp	(	const void *	p1,
		const void *	p2
	)

static

Definition at line 119 of file validate.c.

 {
  long l1 = *(const long*)p1;
  long l2 = *(const long*)p2;
  return l1 < l2 ? -1 : l1 > l2 ? 1 : 0;
 }

Referenced by contains_duplicates(), dcomp(), merge_ranges(), and ranges_contain_duplicates().

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 136 of file validate.c.

 {
  int result = 0;
  mhdf_FileHandle file;
  mhdf_Status status;
  unsigned long max_id;
  struct mhdf_FileDesc* desc;
  
  if( argc < 2 || argc > 3 )
  {
  fprintf( stderr, "Usage: %s <filename> <verbose_option> \n", argv[0] );
  return 1;
  }
  
  file = mhdf_openFile( argv[1], 0, &max_id, -1, &status );
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "%s: %s\n", argv[1], mhdf_message( &status ) );
  return 1;
  }
  if( argc == 3 )
  {
  verbose = atoi( argv[2] );
  }
  desc = mhdf_getFileSummary( file, H5T_NATIVE_LONG, &status, 0 ); /*no extra set info*/
  if( mhdf_isError( &status ) )
  {
  fprintf( stderr, "%s: %s\n", argv[1], mhdf_message( &status ) );
  return 1;
  }
  
  if( desc->nodes.count < 1 ) puts( "WARNING: file contains no vertices." );
  if( desc->num_elem_desc < 1 ) puts( "WARNING: file contains no elements." );
  
  result += check_valid_file_ids( desc );
  result += check_file_contains_holes( argv[1] );
  result += check_valid_connectivity( file, desc );
  result += check_valid_adjacencies( file, desc );
  result += check_valid_sets( file, desc );
  result += check_valid_tags( file, desc );
  
  free( desc );
  mhdf_closeFile( file, &status );
  return result;
 }

References check_file_contains_holes(), check_valid_adjacencies(), check_valid_connectivity(), check_valid_file_ids(), check_valid_sets(), check_valid_tags(), mhdf_EntDesc::count, mhdf_closeFile(), mhdf_getFileSummary(), mhdf_isError(), mhdf_message(), mhdf_openFile(), mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, and verbose.

◆ merge_ranges()

static int merge_ranges	(	long *	ranges,
		int	nranges
	)

static

Definition at line 880 of file validate.c.

 {
  long i, n;
  
  if( nranges < 1 ) return 0;
  
  /* merge adjacent */
  qsort( ranges, nranges, 2 * sizeof( long ), &lcomp );
  n = 1;
  for( i = 1; i < nranges; ++i )
  {
  if( ranges[2 * n - 2] + ranges[2 * n - 1] == ranges[2 * i] )
  {
  ranges[2 * n - 1] += ranges[2 * i + 1]; /*compact the range*/
  }
  else
  {
  /* do not compact, just copy, and increase number of ranges*/
  ranges[2 * n] = ranges[2 * i];
  ranges[2 * n + 1] = ranges[2 * i + 1];
  ++n;
  }
  }
  
  return n;
 }

References lcomp().

Referenced by all_id_ranges(), and get_dim_ranges().

◆ ranges_contain_duplicates()

static int ranges_contain_duplicates	(	long *	ranges,
		long	nranges
	)

static

Definition at line 787 of file validate.c.

 {
  long i;
  qsort( ranges, nranges, 2 * sizeof( long ), &lcomp ); /* sort by first value in each pair */
  for( i = 1; i < nranges; ++i )
  if( ranges[2 * i - 2] + ranges[2 * i - 1] > ranges[2 * i] ) return 1;
  return 0;
 }

References lcomp().

Referenced by check_valid_set_contents().

◆ ranges_contained()

static int ranges_contained	(	const long *	id_ranges,
		int	num_id_ranges,
		const long *	ranges,
		int	num_ranges
	)

static

Definition at line 297 of file validate.c.

 {
  int i;
  long start, count, avail;
  const long* end = ranges + 2 * num_ranges;
  const long* iter;
  for( i = 0; i < num_id_ranges; ++i )
  {
  start = id_ranges[2 * i];
  count = id_ranges[2 * i + 1];
  while( count > 0 )
  {
  for( iter = ranges; iter != end; iter += 2 )
  {
  if( start >= iter[0] && ( start - iter[0] ) < iter[1] ) break;
  }
  if( iter == end ) return 0;
  avail = iter[1] - ( start - iter[0] );
  count -= avail;
  start += avail;
  }
  }
  return 1;
 }

Referenced by check_valid_set_contents().

◆ string_contained()

static int string_contained	(	const char *	str,
		const char const const	list
	)

static

Definition at line 322 of file validate.c.

 {
  for( ; *list; ++list )
  if( !strcmp( str, *list ) ) return 1;
  return 0;
 }

Referenced by get_dim_ranges().

Variable Documentation

◆ verbose

int verbose = 0

program-wide verbose output flag

Definition at line 134 of file validate.c.

Referenced by check_valid_adj_list(), check_valid_elem_conn(), check_valid_end_indices(), check_valid_parents_children(), check_valid_poly_conn(), check_valid_set_contents(), moab::TempestOnlineMap::ComputeMetrics(), main(), obbstat_write(), and obbvis_create().

Functions

Variables

Function Documentation

◆ all_id_ranges()

◆ check_file_contains_holes()

◆ check_valid_adj_list()

◆ check_valid_adjacencies()

◆ check_valid_connectivity()

◆ check_valid_elem_conn()

◆ check_valid_end_indices()

◆ check_valid_file_ids()

◆ check_valid_parents_children()

◆ check_valid_poly_conn()

◆ check_valid_set_contents()

◆ check_valid_sets()

◆ check_valid_tag()

◆ check_valid_tags()

◆ check_valid_var_len_tag()

◆ contains_duplicates()

◆ dcomp()

◆ desc_name()

◆ get_dim_ranges()

◆ id_contained()

◆ ids_contained()

◆ lcomp()

◆ main()

◆ merge_ranges()

◆ ranges_contain_duplicates()

◆ ranges_contained()

◆ string_contained()

Variable Documentation

◆ verbose