bufrdeco_tableD.c File Reference

file with the code to read table D data (code and flag tables) More...

#include "bufrdeco.h"

Include dependency graph for bufrdeco_tableD.c:

Go to the source code of this file.

Functions
int	bufr_read_tableD (struct bufrdeco *b)
	Reads a file with table D content according with WMO csv format. More...
int	bufr_find_tableD_index (buf_t *index, struct bufr_tableD *td, const char *key)
int	bufrdeco_tableD_get_descriptors_array (struct bufr_sequence *s, struct bufrdeco *b, const char *key)
	get the descriptors array for a descriptor sequence defined in table D with F = 3 More...

Detailed Description

file with the code to read table D data (code and flag tables)

Definition in file bufrdeco_tableD.c.

Function Documentation

bufr_find_tableD_index()

int bufr_find_tableD_index	(	buf_t *	index,
		struct bufr_tableD *	td,
		const char *	key
	)

Definition at line 169 of file bufrdeco_tableD.c.

{
  buf_t i, i0;
  buf_t ix = 0;
  char *c, aux[8];
 
  //bufrdeco_assert ( td != NULL && key != NULL && index != NULL);
  
  aux[0] = key[1];
  aux[1] = key[2];
  aux[2] = '\0';
  ix = strtoul ( aux, &c, 10 );
  i0 = td->x_start[ix];
  for ( i = i0 ; i < i0 + td->num[ix] ; i++ )
    {
      if ( td->l[i][1] != key[0] ||
           td->l[i][2] != key[1] ||
           td->l[i][3] != key[2] ||
           td->l[i][4] != key[3] ||
           td->l[i][5] != key[4] ||
           td->l[i][6] != key[5] )
        {
          continue;
        }
      else
        {
          *index = i;
          return 0;
        }
    }
  return 1; // not found
}

References bufr_tableD::l, bufr_tableD::num, and bufr_tableD::x_start.

Referenced by bufrdeco_tableD_get_descriptors_array().

Here is the caller graph for this function:

bufr_read_tableD()

int bufr_read_tableD

(

struct bufrdeco *

b

)

Reads a file with table D content according with WMO csv format.

Parameters

b	pointer to a target struct bufrdeco

Returns

If succeded return 0, otherwise 1

Definition at line 32 of file bufrdeco_tableD.c.

{
  char aux[32], *c;
  char *tk[16];
  int nt;
  FILE *t;
  buf_t ix = 0;
  buf_t i = 0;
  int j0, nj = 0;
  char oldkey[8];
  char caux[256];
  char laux[CSV_MAXL];
  struct bufr_descriptor desc;
  struct bufr_tableD *td;
 
  //bufrdeco_assert (b != NULL);
  
  td = &(b->tables->d);
  if ( td->path[0] == 0 )
    {
      return 1;
    }
 
  // Check if we've already readed this table.
  if ( strcmp ( td->path, td->old_path ) == 0 )
    {
#ifdef __DEBUG      
      printf ("# Reused table %s\n", td->path);
#endif      
      return 0; // all done
    }
 
  strcpy ( caux, td->path );
  memset ( td, 0, sizeof ( struct bufr_tableD ) );
  strcpy ( td->path,caux );
  if ( ( t = fopen ( td->path, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof (b->error),"Unable to open table D file '%s'\n", td->path );
      return 1;
    }
 
  // read first line, it is ignored
  fgets ( laux, CSV_MAXL, t );
 
  oldkey[0] = 0;
  j0 = 0;
 
  while ( fgets ( laux, CSV_MAXL, t ) != NULL && i < BUFR_MAXLINES_TABLED )
    {
      // Parse line
      //printf("%s\n",laux);
      if ( parse_csv_line ( &nt, tk, laux ) < 0 || ( nt != 2 && nt != 4) )
        {
          snprintf ( b->error, sizeof (b->error),"Error parsing csv line from table D file '%s' found %d tokens in line %u\n", td->path, nt, i );
          return 1;
        }
 
      // item fields
      strcpy(td->item[i].key, tk[0]);
      strcpy(td->item[i].key2, tk[1]);
 
      if (nt == 4 && tk[2][0])
        strcpy (td->item[i].description, tk[2]);
      else
        td->item[i].description[0] = 0;
 
      if (nt == 4 && tk[3][0])
        strcpy(td->item[i].description2, tk[3]);
      else
        td->item[i].description2[0] = 0;
 
      if ( strcmp ( oldkey, tk[0] ) )
        {
          if ( oldkey[0] )
            {
              // write number of descriptors in emulated ECMWF line
              sprintf ( aux, "%s%3d", oldkey, nj );
              td->l[j0][1] = aux[0];
              td->l[j0][2] = aux[1];
              td->l[j0][3] = aux[2];
              td->l[j0][4] = aux[3];
              td->l[j0][5] = aux[4];
              td->l[j0][6] = aux[5];
              td->l[j0][7] = aux[6];
              td->l[j0][8] = aux[7];
              td->l[j0][9] = aux[8];
            }
          j0 = i;
          nj = 1;
        }
      else
        {
          nj++;
        }
      strcpy ( oldkey, tk[0] );
 
      ix = strtoul ( tk[0], &c, 10 );
      uint32_t_to_descriptor ( &desc, ix );
 
      if ( td->num[desc.x] == 0 )
        {
          td->x_start[desc.x] = i;  // marc the start
        }
      ( td->num[desc.x] ) ++;
 
      // Now emule ECMWF format
      sprintf ( td->l[i], "           %s", tk[1] );
      i++;
    }
  fclose ( t );
 
  // Last sequence
  sprintf ( aux, "%s%3d", oldkey, nj );
  td->l[j0][1] = aux[0];
  td->l[j0][2] = aux[1];
  td->l[j0][3] = aux[2];
  td->l[j0][4] = aux[3];
  td->l[j0][5] = aux[4];
  td->l[j0][6] = aux[5];
  td->l[j0][7] = aux[6];
  td->l[j0][8] = aux[7];
  td->l[j0][9] = aux[8];
 
  td->nlines = i;
  td->wmo_table = 1;
  strcpy ( td->old_path, td->path ); // store latest path
  return 0;
}

References BUFR_MAXLINES_TABLED, CSV_MAXL, bufr_tables::d, bufr_tableD_decoded_item::description, bufr_tableD_decoded_item::description2, bufrdeco::error, bufr_tableD::item, bufr_tableD_decoded_item::key, bufr_tableD_decoded_item::key2, bufr_tableD::l, bufr_tableD::nlines, bufr_tableD::num, bufr_tableD::old_path, parse_csv_line(), bufr_tableD::path, bufrdeco::tables, uint32_t_to_descriptor(), bufr_tableD::wmo_table, bufr_descriptor::x, and bufr_tableD::x_start.

Referenced by bufr_read_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_tableD_get_descriptors_array()

int bufrdeco_tableD_get_descriptors_array	(	struct bufr_sequence *	s,
		struct bufrdeco *	b,
		const char *	key
	)

get the descriptors array for a descriptor sequence defined in table D with F = 3

Parameters

s	target struct bufr_sequence
b	pointer to the basic container struct bufrdeco
key	string in the form FXXYYY which is the key of descriptor we want to find out, F = 3

Returns

If the sequence has been filled with success then returns 0, otherwise returns 1

Definition at line 211 of file bufrdeco_tableD.c.

{
  buf_t i, j;
  uint32_t nv, v;
  char *c;
  struct bufr_tableD *td;
 
  bufrdeco_assert ( b != NULL && s != NULL && key != NULL );
  
  td = & ( b->tables->d );
 
  // Reject wrong arguments
  if ( s == NULL || b == NULL || key == NULL )
    {
      snprintf ( b->error, sizeof (b->error),"%s(): Wrong entry arguments\n", __func__ );
      return 1;
    }
 
  // here the calling b item learn where to find table C line
 
  if ( bufr_find_tableD_index ( &i, td, key ) )
    {
      snprintf ( b->error, sizeof (b->error), "%s(): descriptor '%s' not found in table D\n", __func__, key );
      return 1; // descritor not found
    }
 
  // Get the name of common sequence
  if (td->item[i].description[0])
     strcpy(s->name, td->item[i].description);
  else
     s->name[0] = 0;
  
  // reads the amount of possible values
  nv = strtoul ( &td->l[i][7], &c, 10 );
 
  // s->level must be set by caller
  // s->father must be set by caller
 
  s->ndesc = 0;
 
  // read all descriptors
  for ( j = 0; j < nv && ( i + j ) < td->nlines ; j++ )
    {
      v = strtoul ( & ( td->l[i+j][11] ), &c, 10 );
      uint32_t_to_descriptor ( & ( s->lseq[j] ), v );
      ( s->ndesc ) ++;
    }
  // s->sons are not set here
  return 0;
}

References bufr_find_tableD_index(), bufrdeco_assert, bufr_tables::d, bufr_tableD_decoded_item::description, bufrdeco::error, bufr_tableD::item, bufr_tableD::l, bufr_sequence::lseq, bufr_sequence::name, bufr_sequence::ndesc, bufr_tableD::nlines, bufrdeco::tables, and uint32_t_to_descriptor().

Referenced by bufrdeco_parse_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function: