bufrdeco_tree.c File Reference

This file has the code which parse sequences in a bufr. More...

#include "bufrdeco.h"

Include dependency graph for bufrdeco_tree.c:

Go to the source code of this file.

Functions
int	get_unexpanded_descriptor_array_from_sec3 (struct bufr_sequence *s, struct bufrdeco *b)
	Set to a struct bufr_sequence an unexpanded descriptor array from sec3 in a BUFR report. More...
int	bufrdeco_parse_tree_recursive (struct bufrdeco *b, struct bufr_sequence *father, buf_t father_idesc, const char *key)
	Parse the descriptor tree in a recursive way. More...

Detailed Description

This file has the code which parse sequences in a bufr.

Definition in file bufrdeco_tree.c.

Function Documentation

bufrdeco_parse_tree_recursive()

int bufrdeco_parse_tree_recursive	(	struct bufrdeco *	b,
		struct bufr_sequence *	father,
		buf_t	father_idesc,
		const char *	key
	)

Parse the descriptor tree in a recursive way.

Parameters

key	string with descriptor in form 'FXXYYY'
father	pointer to the father struct bufr_sequence
father_idesc	index of sequence descriptor in father bufr_sequence which this sequence derived
b	pointer to the base struct bufrdeco

Returns

0 if success, 1 otherwise

Definition at line 60 of file bufrdeco_tree.c.

{
  buf_t i, j, nl;
  struct bufr_sequence *l;
  struct bufr_descriptor *d;
 
  //bufrdeco_assert (b != NULL);
  
  if ( key == NULL )
    {
      // case first layer
      memset ( b->tree, 0, sizeof ( struct bufrdeco_expanded_tree ) ); //reset memory
      b->tree->nseq = 1; // Set current number of sequences in tree, i.e. 1
      l = & ( b->tree->seq[0] ); // This is to write easily
      strcpy ( l->key, "000000" ); // Key '000000' is the first descriptor of first sequence of level 0
      l->level = 0; // Level 0
      l->father = NULL; // This layer is God, it has not father
      l->father_idesc = father_idesc; // No meaning here
      l->iseq = 0; // first
      strcpy ( l->name, "Main sequence from SEC3" );
      // here we get l->ndesc and l->lsec[] array
      if ( get_unexpanded_descriptor_array_from_sec3 ( l, b ) )
        {
          return 1;
        }
    }
  else
    {
      // First increase nseq counter
      if ( b->tree->nseq < NMAXSEQ_DESCRIPTORS )
        {
          ( b->tree->nseq ) ++;
        }
      else
        {
          // No more bufr_sequence permitted
          snprintf ( b->error, sizeof (b->error),"%s(): Reached max number of bufr_sequence. "
                    "Use bigger NMAXSEQ_LAYER \n" , __func__);
          return 1;
        }
      nl = b->tree->nseq; // To write code easily
      l = & ( b->tree->seq[nl - 1] ); // To write code easily
      strcpy ( l->key, key ); // Set the key of sequence in table d (f == 3)
      l->level = father->level + 1; // level for sequence
      l->father = father; // set the father
      l->father_idesc = father_idesc; // Set the father idesc
      l->iseq = nl - 1; // index of sequence in tree
 
      // here we get ndesc and lsec array from table d
      if ( bufrdeco_tableD_get_descriptors_array ( l, b, key ) )
        {
          return 1; // something went wrong
        }
    }
 
  // Set init replication level values from father, copying the one in replicated[0]
  for ( i = 1 ; i < l->ndesc ; i++)
  {
    l->replicated[i] = l->replicated[0];
  }
    
  // Checks for replication levels, no data present, event or conditioning event
  for ( i = 0; i < l->ndesc ; i++ )
    {
      d = & ( l->lseq[i] ); // To write/read code easily
 
      // Case of replication
      if ( d->f == 1 )
        {
          for ( j = 0; j < d->x; j++ )
            {
              if ( d->y == 0 )
                l->replicated[j + i + 2]++; // a delayed replicator follow
              else
                l->replicated[j + i + 1]++; // No delayed descriptor
            }
        }
 
 
      if ( d->f == 2 )
        {
          // check for no data present descriptors
          if ( d->x == 21 &&
               d->y > 0 )
            {
              if ( ( d->y + i ) < l->ndesc )
                {
                  l->no_data_present.active = 1;
                  l->no_data_present.first = i + 1;
                  l->no_data_present.last = i + d->y;
 
                }
              else
                {
                  // range of no data present out of sequence
                  snprintf ( b->error, sizeof (b->error),"%s(): Range of 'no data present' out of sequence limits\n" , __func__);
                  return 1;
                }
            }
 
          // Check for event descriptors
          if ( d->x == 41 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->event.active = 1;
                  l->event.first = i + 1;
                  l->event.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->event.active )
                {
                  l->event.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong event descriptor\n" , __func__);
                  return 1;
                }
            }
 
          // Check for conditioning event descriptors
          if ( d->x == 42 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->cond_event.active = 1;
                  l->cond_event.first = i + 1;
                  l->cond_event.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->cond_event.active )
                {
                  l->cond_event.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong conditioning event event descriptor\n" , __func__);
                  return 1;
                }
            }
 
          // Check for categorical forecasts descriptors
          if ( d->x == 43 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->cat_forecast.active = 1;
                  l->cat_forecast.first = i + 1;
                  l->cat_forecast.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->cat_forecast.active )
                {
                  l->cat_forecast.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong categorical forecasts descriptor\n" , __func__);
                  return 1;
                }
            }
        }
    }
 
  // now we detect sons and go to parse them
  for ( i = 0; i < l->ndesc ; i++ )
    {
      // we search for descriptors with f == 3
      if ( l->lseq[i].f != 3 )
        {
          l->sons[i] = NULL;
          continue;
        }
      l->sons[i] = & ( b->tree->seq[b->tree->nseq] );
      l->sons[i]->replicated[0] = l->replicated[i]; // This is a trick to pass replication level to sons
      
      // we then recursively parse the son
      if ( bufrdeco_parse_tree_recursive ( b, l, i, l->lseq[i].c ) )
        {
          return 1;
        }
    }
 
  // if we are here all gone well
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_parse_tree_recursive(), bufrdeco_tableD_get_descriptors_array(), bufr_descriptor::c, bufr_sequence::cat_forecast, bufr_sequence::cond_event, bufrdeco::error, bufr_sequence::event, bufr_descriptor::f, bufr_sequence::father, bufr_sequence::father_idesc, bufr_sequence_index_range::first, get_unexpanded_descriptor_array_from_sec3(), bufr_sequence::iseq, bufr_sequence::key, bufr_sequence_index_range::last, bufr_sequence::level, bufr_sequence::lseq, bufr_sequence::name, bufr_sequence::ndesc, NMAXSEQ_DESCRIPTORS, bufr_sequence::no_data_present, bufrdeco_expanded_tree::nseq, bufr_sequence::replicated, bufrdeco_expanded_tree::seq, bufr_sequence::sons, bufrdeco::tree, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_parse_tree(), and bufrdeco_parse_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

get_unexpanded_descriptor_array_from_sec3()

int get_unexpanded_descriptor_array_from_sec3	(	struct bufr_sequence *	s,
		struct bufrdeco *	b
	)

Set to a struct bufr_sequence an unexpanded descriptor array from sec3 in a BUFR report.

Parameters

s	Pointer to the target struct bufr_sequence
b	Pointer to the base struct bufrdeco

Returns

If succeded return 0

Here we get a struct bufr_sequence from the data about descriptors stored in sec3 of a bufr report

Definition at line 35 of file bufrdeco_tree.c.

{
  buf_t i;
 
  bufrdeco_assert (b != NULL && s != NULL);
  
  // First we copy the array descriptors in sec3 as level0
  for ( i = 0; i < b->sec3.ndesc ; i++ )
    {
      memcpy ( & ( s->lseq[i] ), & ( b->sec3.unexpanded[i] ), sizeof ( struct bufr_descriptor ) );
    }
  s->ndesc = b->sec3.ndesc;
  return 0;
}

References bufrdeco_assert, bufr_sequence::lseq, bufr_sequence::ndesc, bufr_sec3::ndesc, bufrdeco::sec3, and bufr_sec3::unexpanded.

Referenced by bufrdeco_parse_tree_recursive().

Here is the caller graph for this function: