---

dt_stream_validator.c

Go to the documentation of this file.

#include "dt_stream_validator.h"

#include "dt_stream_base.h"
#include "dt_buf.h"

#include <assert.h>
#include <stdlib.h>


typedef struct
{
   dt_writer  base;
   dt_buf     buf;
   dt_writer* delegate;
} dt_writer_validator;

static void    dt_writer_validator_free( dt_writer* obj );
static dt_bool dt_writer_validator_write( dt_writer* obj, dt_stream_step const* step );


dt_writer* dt_create_validator_writer( dt_writer* delegate )
{
   dt_writer_validator* ans
               = (dt_writer_validator*)malloc(sizeof(dt_writer_validator));
   if( ans )
   {
      dt_init_writer_base( & ans->base, & dt_writer_validator_free, & dt_writer_validator_write );
      ans->delegate = delegate;
      if( dt_buf_init( & ans->buf ) )
      {
         if( dt_buf_append( & ans->buf, 'I' ) )
            return & ans->base;
         dt_buf_free( & ans->buf );
      }
      free( ans );
   }
   return 00;
}

static void dt_writer_validator_free(dt_writer* obj)
{
   dt_writer_validator* o = (dt_writer_validator*)obj;
   dt_buf_free( & o->buf );
   free( o );
}

static dt_bool dt_writer_validator_write(dt_writer* obj, dt_stream_step const* step)
{
   dt_writer_validator* o = (dt_writer_validator*)obj;
   dt_byte enclosure;

   assert( o->buf.strEnd > o->buf.begin );

   if(   ( ! step->key  &&  !! step->key_len )
      || ( ! step->val  &&  !! step->val_len )
      ) return 0; /*throw invalid data pointers */

   enclosure = o->buf.strEnd[-1];
   switch( enclosure )
   {
   case 'I':   o->buf.begin[0] = 'B'; /* initialization --> mark Bottom of stack */
               break;

   case 'B':   if ( step->kind != dt_end )
                  return 0;/*throw("Received new data while expecting end of visit."); */
               break;
   
   case 'X':   return 0;/*throw("Unexpected visitor call after end of visit."); */

   default:    assert( enclosure=='A' || enclosure=='R' );
   }


   switch( step->kind )
   {
   default:          return 0;/*throw("ValidationVisitor::visit : unknown data type"); */

   case dt_leaf:     if( ! step->val )
                        return 0;/*throw("Missing data value while visiting a leaf node"); */
                     break;

   case dt_rec_in:   if( ! dt_buf_append(& o->buf, 'R') ) return 0;/*OUT OF MEM */
                        break;

   case dt_rec_out:  if( 'R' != enclosure )
                        return 0;/*throw("Unexpected end of record"); */
                     -- o->buf.strEnd;
                     enclosure = '?';  /* key (re)transmission is not expected */
                     break;

   case dt_arr_in:   if( ! dt_buf_append(& o->buf, 'A') ) return 0;/*OUT OF MEM */
                        break;

   case dt_arr_out:  if( 'A' != enclosure )
                        return 0;/*throw("Unexpected end of array"); */
                     -- o->buf.strEnd;
                     enclosure = '?';  /* key (re)transmission is not expected */
                     break;

   case dt_end:      if( 'B' != enclosure && 'I' != enclosure )
                        return 0;/*throw("Unexpected end of visit"); */
                     o->buf.begin[0] = 'X';
                     break;
   }


   if( !! step->key )
   {
      if( 'R' != enclosure  &&  '?' != enclosure )
         return 0;/*throw("Unexpected key received out of a record."); */
   }
   else
   {
      if( 'R' == enclosure )
         return 0;/*throw("Key identifier missing within a record."); */
   }


   if( !! step->val  &&  step->kind != dt_leaf )
      return 0;/*throw("Unexpected data value while not visiting a leaf node."); */


   return (! o->delegate)  ||  dt_write( o->delegate, step );
}


dt_bool dt_validator_writer_completed( dt_writer* validator )
{
   dt_writer_validator* o = (dt_writer_validator*)validator;
   return   o->base.free_impl == & dt_writer_validator_free /* type-check */
         && o->buf.begin[0] == 'X';
}

---