bufrdeco_compressed.c File Reference

This file has the code to deal with compressed bufr reports. More...

#include "bufrdeco.h"

Include dependency graph for bufrdeco_compressed.c:

Go to the source code of this file.

Functions
int	bufrdeco_parse_compressed (struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Preliminary parse of a compressed data bufr. More...
int	bufrdeco_parse_compressed_recursive (struct bufrdeco_compressed_data_references *r, struct bufr_sequence *l, struct bufrdeco *b)
	Parse recursively the compressed data in a bufr report to get references where to get data for every descriptor in a subset. More...
int	bufrdeco_decode_replicated_subsequence_compressed (struct bufrdeco_compressed_data_references *r, struct bufr_replicator *rep, struct bufrdeco *b)
	decodes a repicated subsequence More...
int	bufrdeco_get_atom_data_from_compressed_data_ref (struct bufr_atom_data *a, struct bufrdeco_compressed_ref *r, buf_t subset, struct bufrdeco *b)
	Get atom data from a descriptor for a given subset. More...
int	bufr_decode_subset_data_compressed (struct bufrdeco_subset_sequence_data *s, struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Get data for a given subset in a compressed data bufr. More...
int	bufrdeco_increase_compressed_data_references_count (struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Increment the count of a struct bufrdeco_compressed_data_references. More...

Detailed Description

This file has the code to deal with compressed bufr reports.

Definition in file bufrdeco_compressed.c.

Function Documentation

bufr_decode_subset_data_compressed()

int bufr_decode_subset_data_compressed	(	struct bufrdeco_subset_sequence_data *	s,
		struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Get data for a given subset in a compressed data bufr.

Parameters

s	pointer to a struct bufrdeco_subset_sequence_data where to set the results
r	pointer to the struct bufrdeco_compressed_data_references with the info about how and where to get the data
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 965 of file bufrdeco_compressed.c.

{
  size_t i, j = 0; // references index
  char aux[80];
  
  if ( b == NULL )
    return 1;
 
  // Previous check
  if ( r->refs == NULL || r->nd == 0 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Try to get subset data without previous references\n", __func__ );
      return 1;
    }
 
  // first some clean
  if ( s->nd )
    {
      s->nd = 0;
    }
 
  // The subset index
  s->ss = b->state.subset;
 
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    bufrdeco_print_json_subset_data_prologue (b->out, b );
 
  // then get sequence
  for ( i = 0; i < r->nd; i++ )
    {
      if ( (b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA) &&
           (r->refs[i].replicated_desc || r->refs[i].replicated_loop) )
        snprintf(aux, sizeof (aux), "\"Replicated\":\"Descriptor %u/%u of loop %u/%u\"", r->refs[i].replicated_desc, r->refs[i].replicated_ndesc,
                r->refs[i].replicated_loop, r->refs[i].replicated_nloop);
      else
        aux[0] = '\0';
      
      if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK )
        {
          if ( bufrdeco_get_atom_data_from_compressed_data_ref ( & ( s->sequence[s->nd] ), & ( r->refs[i] ), b->state.subset, b ) )
            return 1;
 
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_object_atom_data (b->out, & ( s->sequence[s->nd] ), aux );
            }
          if ( r->refs[i].is_associated == 0 )
            {
              if ( s->nd < ( s->dim - 1 ) )
                ( s->nd ) ++;
              else if ( bufrdeco_increase_data_array ( s ) == 0 )
                ( s->nd ) ++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
            }
          else
            {
              if ( s->nd < ( s->dim - 1 ) )
                ( s->nd ) ++;
              else if ( bufrdeco_increase_data_array ( s ) == 0 )
                ( s->nd ) ++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
            }
          j++;
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_sequence_descriptor_header (b->out, r->refs[i].seq );
              j = 0;
            }
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            bufrdeco_print_json_sequence_descriptor_final (b->out);
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_object_replicator_descriptor (b->out, r->refs[i].desc, aux );
              j++;
            }
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
          {
            if ( j )
               bufrdeco_print_json_separator(b->out );
            bufrdeco_print_json_object_operator_descriptor (b->out, r->refs[i].desc, aux );
          }
          j++;
        }
    }
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    bufrdeco_print_json_subset_data_epilogue (b->out );
 
  return 0;
}

References BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK, BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK, bufrdeco_get_atom_data_from_compressed_data_ref(), bufrdeco_increase_data_array(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_object_operator_descriptor(), bufrdeco_print_json_object_replicator_descriptor(), bufrdeco_print_json_separator(), bufrdeco_print_json_sequence_descriptor_final(), bufrdeco_print_json_sequence_descriptor_header(), bufrdeco_print_json_subset_data_epilogue(), bufrdeco_print_json_subset_data_prologue(), bufrdeco_compressed_ref::desc, bufrdeco_subset_sequence_data::dim, bufrdeco::error, bufrdeco_compressed_ref::is_associated, bufrdeco_compressed_ref::mask, bufrdeco::mask, bufrdeco_subset_sequence_data::nd, bufrdeco_compressed_data_references::nd, bufrdeco::out, bufrdeco_compressed_data_references::refs, bufrdeco_compressed_ref::replicated_desc, bufrdeco_compressed_ref::replicated_loop, bufrdeco_compressed_ref::replicated_ndesc, bufrdeco_compressed_ref::replicated_nloop, bufrdeco_compressed_ref::seq, bufrdeco_subset_sequence_data::sequence, bufrdeco_subset_sequence_data::ss, bufrdeco::state, and bufrdeco_decoding_data_state::subset.

Referenced by bufrdeco_decode_data_subset().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_decode_replicated_subsequence_compressed()

int bufrdeco_decode_replicated_subsequence_compressed	(	struct bufrdeco_compressed_data_references *	r,
		struct bufr_replicator *	rep,
		struct bufrdeco *	b
	)

decodes a repicated subsequence

Parameters

r	pointer to target struct bufrdeco_compressed_data_references where to set results
rep	pointer to a replicator which contains the data for replication
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 352 of file bufrdeco_compressed.c.

{
  int res;
  buf_t i, k;
  buf_t ixloop; // Index for loop
  buf_t ixd; // Index for descriptor
  struct bufrdeco_compressed_ref *rf;
  struct bufr_replicator replicator;
  struct bufr_sequence *l = rep->s; // sequence
 
  // check arguments
  if ( b == NULL )
    return 1;
 
  if ( r == NULL || rep == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  // if no loops the we save process time and space in data
  if ( rep->nloops == 0 )
    return 0;
 
 
  // The big loop
  for ( ixloop = 0; ixloop < rep->nloops; ixloop++ )
    {
      for ( ixd = 0; ixd < rep->ndesc ; ixd ++ )
        {
          i = ixd + rep->ixdel + 1;
          switch ( l->lseq[i].f )
            {
            case 0:
              // Checks if no_data_present is active for this descriptor in this sequence
              if ( l->no_data_present.active &&
                   i >= l->no_data_present.first &&
                   i <= l->no_data_present.last )
                {
                  // If here then no_data_present has been active in this sequence
                  if ( l->lseq[i].x > 9 &&
                       l->lseq[i].x != 31 )
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n", __func__ );
                      return 1;
                    }
 
                }
              // Get data from table B
              rf = & ( r->refs[r->nd] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
              
              // First then the data itself
              if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[i] ), 0 ) )
                {
                  return 1;
                }
 
              // Case of defining bitmap 0 31 031
              if ( l->lseq[i].x == 31 && l->lseq[i].y == 31 && b->state.bitmaping )
                {
                  if ( rf->ref0 == 0 ) // Assume if ref0 == 0 then all subsets are present in same bits
                    {
                      r->refs[r->nd - b->state.bitmaping].is_bitmaped_by = ( uint32_t ) r->nd ;
                      rf->bitmap_to = r->nd - b->state.bitmaping;
                      bufrdeco_add_to_bitmap ( b->bitmap.bmap[b->bitmap.nba - 1], r->nd - b->state.bitmaping, r->nd );
                    }
                }
 
              // Process quality data
              if ( b->state.quality_active &&
                   l->lseq[i].x == 33 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nq; // index un quality_given_by array to set
                      b->bitmap.bmap[b->bitmap.nba - 1]->quality[k] = r->nd; // Set the value
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nq )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for quality vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                }
 
              //case of first order statistics
              if ( b->state.stat1_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 23 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = r->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              //case of difference statistics
              if ( b->state.dstat_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 24 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index un stqts
                      b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = r->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = l;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Then associated field
              rf = & ( r->refs[r->nd] );
              res = bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[i] ), 1 );
              if ( res > 0 )
                {
                  return 1; // case of error
                }
              else if ( res == 0 )
                {
                  //print_bufrdeco_compressed_ref ( rf );
                  // associated field read with success
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  // Set the used elements of array in r
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                  b->state.assoc_bits = 0; // Set again the assoc_bits to 0
                }
 
              break;
 
            case 1:
              // Case of replicator descriptor
              rf = & ( r->refs[r->nd] );
              rf->mask = BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR;
              rf->seq = l;
              rf->desc = & ( l->lseq[i] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              replicator.s = l;
              replicator.ixrep = i;
              if ( l->lseq[i].y != 0 )
                {
                  // no delayed
                  replicator.ixdel = i;
                  replicator.ndesc = l->lseq[i].x;
                  replicator.nloops = l->lseq[i].y;
                  bufrdeco_decode_replicated_subsequence_compressed ( r, & replicator, b );
                  ixd += replicator.ndesc; // update ixd properly
                }
              else
                {
                  // case of delayed;
                  replicator.ixdel = i + 1;
                  replicator.ndesc = l->lseq[i].x;
                  rf = & ( r->refs[r->nd] );
 
                  // The data itself to get the loops
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[replicator.ixdel] ), 0 ) )
                    {
                      return 1;
                    }
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
 
                  // Set the used elements of bufrdeco_compressed_ref
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                  replicator.nloops = ( size_t ) rf->ref0;
 
                  bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
                  ixd += replicator.ndesc + 1; // update ixd properly
                }
 
              break;
 
            case 2:
              rf = & ( r->refs[r->nd] );
              rf->mask = BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR;
              rf->seq = l;
              rf->desc = & ( l->lseq[i] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Case of operator descriptor
              if ( bufrdeco_parse_f2_compressed ( r, & ( l->lseq[i] ), b ) )
                {
                  return 1;
                }
 
              // Case of subsituted values
              if ( b->state.subs_active && l->lseq[i].x == 23 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop]; // ref which is bitmaped_to
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->subs = r->nd;
                    }
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[k] ), 0 ) )
                    {
                      return 1;
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of repaced/retained values
              if ( b->state.retained_active && l->lseq[i].x == 32 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->retain = r->nd;
                    }
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[k] ), 0 ) )
                    {
                      return 1;
                    }
 
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of first order statistics
              //
              // This operator shall signify a data item containing a
              // first-order statistical value of the type indicated by
              // the preceding 0 08 023 element descriptor; the
              // element descriptor to which the first-order statistic
              // relates is obtained by the application of the data
              // present bit-map associated with the first-order
              // statistical values follow operator; first-order statistical
              // values shall be represented as defined by this element
              // descriptor.
              if ( b->state.stat1_active && l->lseq[i].x == 24 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->ns1 -1] = r->nd;
                    }
 
                  if ( bufrdeco_tableB_compressed ( rf, b, r->refs[k].desc, 0 ) )
                    {
                      return 1;
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of difference statistics
              //
              // This operator shall signify a data item containing a
              // difference statistical value of the type indicated by
              // the preceding 0 08 024 element descriptor; the
              // element descriptor to which the difference statistical
              // value relates is obtained by the application of the
              // data present bit-map associated with the difference
              // statistical values follow operator; difference statistical
              // values shall be represented as defined by this
              // element descriptor, but with a reference value of –2**n
              // and a data width of (n+1), where n is the data width
              // given by the original descriptor. This special reference
              // value allows the statistical difference values to
              // be centred around zero.
              if ( b->state.dstat_active && l->lseq[i].x == 25 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->nds -1] = r->nd;
                    }
 
                  if ( bufrdeco_tableB_compressed ( rf, b, r->refs[k].desc, 0 ) )
                    {
                      return 1;
                    }
 
                  // here is where we change ref and bits
                  rf->ref = - ( ( int32_t ) 1 << rf->bits );
                  rf->bits++;
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              if ( l->lseq[i].x == 5 ) // cases wich produces a new ref
                {
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
              break;
 
            case 3:
              // Case of sequence descriptor
              if ( bufrdeco_parse_compressed_recursive ( r, l->sons[i], b ) )
                return 1;
              break;
 
            default:
              // this case is not possible
              snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor\n", __func__ );
              return 1;
              break;
            }
        }
    }
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_decoding_data_state::assoc_bits, bufrdeco::bitmap, bufrdeco_bitmap::bitmap_to, bufrdeco_compressed_ref::bitmap_to, bufrdeco_decoding_data_state::bitmaping, bufrdeco_compressed_ref::bits, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, bufrdeco_add_to_bitmap(), BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_increase_compressed_data_references_count(), bufrdeco_parse_compressed_recursive(), bufrdeco_parse_f2_compressed(), bufrdeco_tableB_compressed(), bufrdeco_compressed_ref::desc, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufr_sequence_index_range::first, bufrdeco_compressed_ref::is_bitmaped_by, bufr_replicator::ixdel, bufr_replicator::ixrep, bufr_sequence_index_range::last, bufr_sequence::lseq, bufrdeco_compressed_ref::mask, bufrdeco_bitmap_array::nba, bufrdeco_compressed_data_references::nd, bufr_replicator::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_bitmap::nq, bufrdeco_bitmap::ns1, bufrdeco_bitmap::quality, bufrdeco_decoding_data_state::quality_active, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, bufrdeco_compressed_data_references::refs, bufrdeco_compressed_ref::related_to, bufrdeco_compressed_ref::replicated_desc, bufrdeco_compressed_ref::replicated_loop, bufrdeco_compressed_ref::replicated_ndesc, bufrdeco_compressed_ref::replicated_nloop, bufrdeco_bitmap::retain, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufrdeco_compressed_ref::seq, bufr_sequence::sons, bufrdeco_bitmap::stat1, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_bitmap::subs, bufrdeco_decoding_data_state::subs_active, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_get_atom_data_from_compressed_data_ref()

int bufrdeco_get_atom_data_from_compressed_data_ref	(	struct bufr_atom_data *	a,
		struct bufrdeco_compressed_ref *	r,
		buf_t	subset,
		struct bufrdeco *	b
	)

Get atom data from a descriptor for a given subset.

Parameters

a	pointer to the target struct bufr_atom_data where to set the results
r	pointer to the struct bufrdeco_compressed_ref with the info to know how and where get the data
subset	index for solicited subset. First subset has index 0
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 742 of file bufrdeco_compressed.c.

{
  buf_t i, bit_offset;
  uint8_t has_data;
  uint32_t ival, ival0;
  int32_t ivals;
  struct bufr_tableB *tb;
 
  if ( b == NULL )
    return 1;
 
  if ( a == NULL || r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  if ( is_a_local_descriptor ( r->desc ) )
    {
      a->mask = DESCRIPTOR_IS_LOCAL;
      memcpy ( & ( a->desc ), r->desc, sizeof ( struct bufr_descriptor ) );
      strcpy ( a->name, "LOCAL DESCRIPTOR" );
      strcpy ( a->unit, "UNKNOWN" );
      if ( r->inc_bits )
        {
          bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
          // extract inc_bits data
          if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get associated bits from '%s'\n", __func__, r->desc->c );
              return 1;
            }
          a->val = ival + r->ref0;
        }
      else
        a->val = r->ref0;
      return 0;
    }
 
  // some utils pointers
  tb = & ( b->tables->b );
  i = tb->x_start[r->desc->x] + tb->y_ref[r->desc->x][r->desc->y];
 
  a->mask = 0;
 
  // descriptor
  memcpy ( & ( a->desc ), r->desc, sizeof ( struct bufr_descriptor ) );
  // name
  //strcpy_safe ( a->name, r->name );
  strcpy ( a->name, r->name );
  //unit
  //strcpy_safe ( a->unit, r->unit );
  strcpy ( a->unit, r->unit );
  //scale
  a->escale = r->escale;
 
  // possible bitmaps
  if ( r->is_bitmaped_by )
    {
      a->is_bitmaped_by = r->is_bitmaped_by;
    }
 
  if ( r->bitmap_to )
    {
      a->bitmap_to = r->bitmap_to;
    }
 
  // Possible quality
  if ( r->related_to )
    {
      a->related_to = r->related_to;
    }
 
 
  // First we check about string fields
  if ( strstr ( a->unit, "CCITT" ) != NULL )
    {
      if ( r->has_data == 0 )
        {
          a->mask |= DESCRIPTOR_VALUE_MISSING;
          return 0;
        }
 
      if ( r->inc_bits == 0 )
        {
          // case of all data same, so copy the local ref
          strcpy ( a->cval, r->cref0 );
          a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
        }
      else
        {
          // we have to extract chars from section data
          // compute the bit_offset
          bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * 8 * subset;
          if ( get_bits_as_char_array ( a->cval, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits * 8 ) == 0 )
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get uchars from '%s'\n", __func__, r->desc->c );
              return 1;
            }
          if ( has_data == 0 )
            {
              a->mask |= DESCRIPTOR_VALUE_MISSING;
            }
          else
            {
              a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
            }
        }
      return 0;
    }
 
  // now we check for associated data
  if ( r->is_associated )
    {
      strcpy ( a->name, "Associated value" );
      strcpy ( a->unit, "Associated unit" );
      if ( r->has_data == 0 )
        {
          a->associated = MISSING_INTEGER;
        }
      else
        {
          if ( r->inc_bits == 0 )
            {
              // case of all data same, so copy the local ref
              a->associated = r->ref0;
            }
          else
            {
              // compute the bit_offset
              bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
              // extract inc_bits data
              if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get associated bits from '%s'\n", __func__, r->desc->c );
                  return 1;
                }
              // finally get the associated data
              if ( has_data )
                {
                  a->associated = r->ref + ( int32_t ) ( r->ref0 +  ival );
                }
              else
                {
                  a->associated = MISSING_INTEGER;
                }
            }
        }
      return 0;
    }
 
  // numeric data
  if ( r->has_data == 0 ||
       r->inc_bits > r->bits ) // Here we assume no more inc_bits than bits in reference value?
    {
      a->val = MISSING_REAL;
      a->mask |= DESCRIPTOR_VALUE_MISSING;
      return 0;
    }
 
  if ( r->inc_bits == 0 )
    {
      ivals = r->ref + ( int32_t ) r->ref0;
    }
  else
    {
      // read inc_bits data
      // compute the bit_offset
      bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
      // extract inc_bits data
      if ( get_bits_as_uint32_t ( &ival0, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get %d inc_bits from '%s'\n", __func__, r->inc_bits, r->desc->c );
          return 1;
        }
 
      if ( has_data )
        {
          ivals = r->ref + ( int32_t ) ( r->ref0 + ival0 );
        }
      else
        {
          a->val = MISSING_REAL;
          a->mask |= DESCRIPTOR_VALUE_MISSING;
          return 0;
        }
    }
 
  // Get a numeric number
  a->val = ( double ) ( ivals ) * exp10 ( ( double ) ( - r->escale ) );
 
  if ( strstr ( a->unit, "CODE TABLE" ) == a->unit  || strstr ( a->unit, "Code table" ) == a->unit )
    {
      ival = ( uint32_t ) ( a->val + 0.5 );
      a->mask |= DESCRIPTOR_IS_CODE_TABLE;
      if ( bufrdeco_explained_table_val ( a->ctable, 256, & ( b->tables->c ), & ( tb->item[i].tableC_ref ), & ( a->desc ), ival ) != NULL )
        {
          a->mask |= DESCRIPTOR_HAVE_CODE_TABLE_STRING;
        }
    }
  else if ( strstr ( a->unit,"FLAG" ) == a->unit || strstr ( a->unit,"Flag" ) == a->unit )
    {
      ival = ( uint32_t ) ( a->val + 0.5 );
      a->mask |= DESCRIPTOR_IS_FLAG_TABLE;
 
      if ( bufrdeco_explained_flag_val ( a->ctable, 256, & ( b->tables->c ), & ( a->desc ), ival, r->bits ) != NULL )
        {
          a->mask |= DESCRIPTOR_HAVE_FLAG_TABLE_STRING;
        }
    }
 
  return 0;
}

References bufr_atom_data::associated, bufr_tables::b, bufrdeco_compressed_ref::bit0, bufr_atom_data::bitmap_to, bufrdeco_compressed_ref::bitmap_to, bufrdeco_compressed_ref::bits, bufrdeco_explained_flag_val(), bufrdeco_explained_table_val(), bufr_descriptor::c, bufr_tables::c, bufrdeco_compressed_ref::cref0, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, bufrdeco_compressed_ref::desc, DESCRIPTOR_HAVE_CODE_TABLE_STRING, DESCRIPTOR_HAVE_FLAG_TABLE_STRING, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_IS_CODE_TABLE, DESCRIPTOR_IS_FLAG_TABLE, DESCRIPTOR_IS_LOCAL, DESCRIPTOR_VALUE_MISSING, bufrdeco::error, bufr_atom_data::escale, bufrdeco_compressed_ref::escale, get_bits_as_char_array(), get_bits_as_uint32_t(), bufrdeco_compressed_ref::has_data, bufrdeco_compressed_ref::inc_bits, is_a_local_descriptor(), bufrdeco_compressed_ref::is_associated, bufr_atom_data::is_bitmaped_by, bufrdeco_compressed_ref::is_bitmaped_by, bufr_tableB::item, bufr_atom_data::mask, MISSING_INTEGER, MISSING_REAL, bufr_atom_data::name, bufrdeco_compressed_ref::name, bufr_sec4::raw, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, bufr_atom_data::related_to, bufrdeco_compressed_ref::related_to, bufrdeco::sec4, bufr_tableB_decoded_item::tableC_ref, bufrdeco::tables, bufr_atom_data::unit, bufrdeco_compressed_ref::unit, bufr_atom_data::val, bufr_descriptor::x, bufr_tableB::x_start, bufr_descriptor::y, and bufr_tableB::y_ref.

Referenced by bufr_decode_subset_data_compressed().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_increase_compressed_data_references_count()

int bufrdeco_increase_compressed_data_references_count	(	struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Increment the count of a struct bufrdeco_compressed_data_references.

Parameters

r	pointer to the target struct
b	pointer to the current active struct bufrdeco

Returns

0 if succeeded, 1 otherwise

Definition at line 1089 of file bufrdeco_compressed.c.

{
  if ( r->nd < ( BUFR_NMAXSEQ - 1 ) )
    {
      r->nd += 1;
    }
  else
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
      return 1;
    }
  return 0;
}

References BUFR_NMAXSEQ, bufrdeco::error, and bufrdeco_compressed_data_references::nd.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the caller graph for this function:

bufrdeco_parse_compressed()

int bufrdeco_parse_compressed	(	struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Preliminary parse of a compressed data bufr.

Parameters

r	pointer to a struct bufrdeco_compressed_data_references where to set the results
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

When a bufr report has compressed data, it is needed to do a first parse step to get references about where to find the data for every descriptor in subsets. This is what this function does. If succeeded the struct r will have all needed data to decode individual subsets.

Also be mind that the descriptors tree have to be already parsed when calling this function

Definition at line 40 of file bufrdeco_compressed.c.

{
 
  // Check about parsed tree
  if ( b->tree == NULL || b->tree->nseq == 0 )
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Try to parse compressed data without parsed tree\n", __func__ );
      return 1; //fatal error, no parsed tree
    }
 
  // first we assure that needed memory is allocated and array of bufr_compressed references initizalized
  if ( bufrdeco_init_compressed_data_references ( r ) )
    {
      return 1; // Something went wrong
    }
 
  // Then we make the parsing task in a recursive way. NULL pointer says it is the begining.
  // The NULL argument is because we begin the compresed Preliminary parse tasks
  if ( bufrdeco_parse_compressed_recursive ( r, NULL, b ) )
    {
      return 1;
    }
 
  // all is OK
  return 0;
}

References bufrdeco_init_compressed_data_references(), bufrdeco_parse_compressed_recursive(), bufrdeco::error, bufrdeco_expanded_tree::nseq, and bufrdeco::tree.

Referenced by bufrdeco_decode_data_subset(), and bufrdeco_get_target_subset_sequence_data().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_compressed_recursive()

int bufrdeco_parse_compressed_recursive	(	struct bufrdeco_compressed_data_references *	r,
		struct bufr_sequence *	l,
		struct bufrdeco *	b
	)

Parse recursively the compressed data in a bufr report to get references where to get data for every descriptor in a subset.

Parameters

r	pointer to target struct bufrdeco_compressed_data_references where to set results
l	pointer to a struct bufr_sequence to parse in this call. If NULL then it is first root sequence
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 76 of file bufrdeco_compressed.c.

{
  int res;
  buf_t i, k;
  struct bufr_sequence *seq; // auxiliar pointer
  struct bufrdeco_compressed_ref *rf;
  struct bufr_replicator replicator;
 
  // Check arguments
  if ( b == NULL )
    return 1;
 
  if ( r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument\n", __func__ );
      return 1;
    }
 
  if ( l == NULL )
    {
      // inits the array. This is the begining of preliminary parse
      // At the moment there are no structs bufrdeco_compressed_ref used
      r->nd = 0;
      // set the auxiliar pointer at the begining of array of sequences of bufrdeco_expanded_tree
      seq = & ( b->tree->seq[0] );
      // Cleans the state of parsing
      memset ( & ( b->state ), 0, sizeof ( struct bufrdeco_decoding_data_state ) );
      // and set some other initial values
      b->state.bit_offset = 0;
      b->state.added_bit_length = 0;
      b->state.added_scale = 0;
      b->state.added_reference = 0;
      b->state.assoc_bits = 0;
      b->state.changing_reference = 255;
      b->state.fixed_ccitt = 0;
      b->state.local_bit_reserved = 0;
      b->state.factor_reference = 1;
      b->state.quality_active = 0;
      b->state.subs_active = 0;
      b->state.retained_active = 0;
      b->state.stat1_active = 0;
      b->state.dstat_active = 0;
      b->state.bitmaping = 0;
      b->state.bitmap = NULL;
 
    }
  else
    {
      // This is the case when layer of sequence is no 0, i.e. has been called recursively
      // We just set the auxiliar index
      seq = l;
    }
 
  // Mark the init of a sequence. It waste a  reference to mark it
  rf = & ( r->refs[r->nd] );
  rf->mask = BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK;
  rf->seq = seq;
  // Set the used elements of array in r
  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
    return 1;
 
 
  // loop for a sequence
  for ( i = 0; i < seq->ndesc ; i++ )
    {
      // switch according to 'f' of the descriptor of sequence
      switch ( seq->lseq[i].f )
        {
        case 0:
          // Checks if no_data_present is active for this descriptor in this sequence
          if ( seq->no_data_present.active &&
               i >= seq->no_data_present.first &&
               i <= seq->no_data_present.last )
            {
              // If here then no_data_present has been active in this sequence
              if ( seq->lseq[i].x > 9 &&
                   seq->lseq[i].x != 31 )
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n", __func__ );
                  return 1;
                }
 
            }
 
          // Get data from table B
          rf = & ( r->refs[r->nd] ); // pointer to the target struct bufrdeco_compressed ref. To read/write code easily
 
          // First the the data itself
          if ( bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[i] ), 0 ) )
            {
              return 1;
            }
 
          //case of first order statistics
          if ( b->state.stat1_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 23 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
              b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = r->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                  return 1;
                }
            }
 
          //case of difference statistics
          if ( b->state.dstat_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 24 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index un stqts
              b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = r->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                  return 1;
                }
            }
 
          rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
          rf->seq = seq;
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          // Then we check for an associated field
          rf = & ( r->refs[r->nd] );
          // If is not an associated field returned value is -1 and no action is made
          res = bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[i] ), 1 );
          if ( res > 0 )
            {
              return 1; // case of error
            }
          else if ( res == 0 )
            {
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = seq;
              // associated field read with success, set again the used elements of r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Update the pointer to the target struct bufrdeco_compressed ref
              i++; // Update main loop index, note that i is also incrmented at the end of loop.
            }
 
 
          break;
 
        case 1:
          // Case of replicator descriptor. waste a reference
          rf = & ( r->refs[r->nd] );
          rf->mask = BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR;
          rf->seq = seq;
          rf->desc = & ( seq->lseq[i] );
          // Set the used elements of array in r
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          memset ( &replicator, 0, sizeof ( struct bufr_replicator ) ); // mr proper
          replicator.s = seq;
          replicator.ixrep = i; // the index of recplicator descriptor in the sequence
          if ( seq->lseq[i].y != 0 )
            {
              // no delayed
              replicator.ixdel = i; // The index of descriptor with info about actual replication factor
              replicator.ndesc = seq->lseq[i].x;
              replicator.nloops = seq->lseq[i].y;
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              // call to decode a replicated subsequence
              bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
            }
          else
            {
              // case of delayed;
              replicator.ixdel = i + 1; // the index of descriptor in sequence with information about the actual amonut of replications
              replicator.ndesc = seq->lseq[i].x;
              rf = & ( r->refs[r->nd] );
 
              // The the data itself to get the loops
              if ( bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[ replicator.ixdel ] ), 0 ) )
                {
                  return 1;
                }
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = seq;
 
              // Set the used elements of bufrdeco_compressed_ref
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Note that is supossed all subsets has the same nlopps,
              // so the inc_bits must be 0 and nloops = ref0
              replicator.nloops = ( size_t ) rf->ref0;
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              // call to decode a replicated subsequence
              bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
            }
          i = replicator.ixdel + replicator.ndesc; // update i properly
          break;
 
        case 2:
          // Case of operator descriptor
          rf = & ( r->refs[r->nd] );
          rf->mask = BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR;
          rf->seq = seq;
          rf->desc = & ( seq->lseq[i] );
          // Set the used elements of array in r
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          if ( bufrdeco_parse_f2_compressed ( r, & ( seq->lseq[i] ), b ) )
            {
              return 1;
            }
 
          break;
 
        case 3:
          // Case of sequence descriptor
          if ( bufrdeco_parse_compressed_recursive ( r, seq->sons[i], b ) )
            {
              return 1;
            }
          break;
 
        default:
          // this case is not possible
          snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor '%s' \n", __func__, seq->lseq[i].c );
          return 1;
          break;
        }
    }
 
  // Mark end of sequence. waste a reference
  rf = & ( r->refs[r->nd] );
  rf->mask = BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK;
  rf->seq = seq;
  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
     return 1;
 
 
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_reference, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufrdeco_decoding_data_state::bit_offset, bufrdeco_decoding_data_state::bitmap, bufrdeco::bitmap, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK, BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK, bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_increase_compressed_data_references_count(), bufrdeco_parse_compressed_recursive(), bufrdeco_parse_f2_compressed(), bufrdeco_tableB_compressed(), bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufrdeco_compressed_ref::desc, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufrdeco_decoding_data_state::factor_reference, bufr_sequence_index_range::first, bufrdeco_decoding_data_state::fixed_ccitt, bufr_replicator::ixdel, bufr_replicator::ixrep, bufrdeco_decoding_data_state::local_bit_reserved, bufr_sequence::lseq, bufrdeco_compressed_ref::mask, bufrdeco_bitmap_array::nba, bufrdeco_compressed_data_references::nd, bufr_replicator::ndesc, bufr_sequence::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_bitmap::ns1, bufrdeco_decoding_data_state::quality_active, bufrdeco_compressed_ref::ref0, bufrdeco_compressed_data_references::refs, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufrdeco_expanded_tree::seq, bufrdeco_compressed_ref::seq, bufr_sequence::sons, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_decoding_data_state::subs_active, bufrdeco::tree, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_parse_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function: