---

dt_stream_tree.c

Go to the documentation of this file.

#include "dt_stream_tree.h"
#include "dt_stream_base.h"

#include "dt_node_impl.h"

#include <malloc.h>
#include <ctype.h>
#include <assert.h>


dt_bool dt_stream_subtree( dt_stream_step* step, dt_node const* src, dt_writer* dst )
{
   assert( dt_node_is_valid(src) );
   switch( src->kind )
   {
   default:
         return 0;
   case dt_leaf_node: {
         step->kind    = dt_leaf;
         step->val     = src->buf.begin;
         step->val_len = src->buf.strEnd - step->val;
         return dt_write( dst, step );
     }
   case dt_arr_node: {
         arr_item *scan, *end;
         step->kind    = dt_arr_in;
         step->val     = 00;
         step->val_len = 0;
         if( ! dt_write( dst, step ) ) return 0;
         
         assert( (src->buf.strEnd - src->buf.begin)%sizeof(arr_item) == 0 );
         scan = (arr_item*)src->buf.begin;
         end  = (arr_item*)src->buf.strEnd;
         step->key     = 00;
         step->key_len = 0;
         for(  ; scan != end ; ++scan )
            if( ! dt_stream_subtree( step, *scan, dst ) ) return 0;
         step->kind    = dt_arr_out;
         step->key     = 00;
         step->key_len = 0;
         step->val     = 00;
         step->val_len = 0;
         return dt_write( dst, step );
      }
   case dt_rec_node: {
         rec_item *scan, *end;
         step->kind    = dt_rec_in;
         step->val     = 00;
         step->val_len = 0;
         if( ! dt_write( dst, step ) ) return 0;
         
         assert( (src->buf.strEnd - src->buf.begin)%sizeof(rec_item) == 0 );
         scan = (rec_item*)src->buf.begin;
         end  = (rec_item*)src->buf.strEnd;
         for(  ; scan != end ; ++scan )
         {
            step->key     = scan->key;
            step->key_len = scan->key_len;
            if( ! dt_stream_subtree( step, scan->node, dst ) ) return 0;
         }         
         step->kind    = dt_rec_out;
         step->key     = 00;
         step->key_len = 0;
         step->val     = 00;
         step->val_len = 0;
         return dt_write( dst, step );
      }
   }
}


dt_bool dt_stream_tree( dt_node const* src, dt_writer* dst )
{
   dt_stream_step step;
   step.key     = 00;
   step.key_len = 0;
   if( ! dt_stream_subtree( &step, src, dst ) ) return 0;

   step.kind    = dt_end;
   step.key     = 00;
   step.key_len = 0;
   step.val     = 00;
   step.val_len = 0;
   return dt_write( dst, &step );
}


typedef struct
{
   dt_writer  base;  
   dt_node**  root;  
   dt_buf     stack; 
} dt_writer_tree;

static void    dt_writer_tree_free( dt_writer* obj );
static dt_bool dt_writer_tree_write( dt_writer* obj, dt_stream_step const* step );

dt_writer* dt_create_tree_writer( dt_node** root )
{
   dt_writer_tree* ans = (dt_writer_tree*)malloc(sizeof(dt_writer_tree));

   assert( *root == 00 ); /* as caller will later have to assume that node is valid & to be destroyed */

   if( ans )
   {
      dt_init_writer_base( & ans->base, & dt_writer_tree_free, & dt_writer_tree_write );
      ans->root = root;
      if( dt_buf_init( & ans->stack ) )
         return & ans->base;
      free( ans );
   }
   return 00;
}

static void dt_writer_tree_free( dt_writer* obj )
{
   dt_writer_tree* o = (dt_writer_tree*)obj;
   dt_buf_free( & o->stack );
   free( o );
}

static dt_bool dt_writer_tree_write( dt_writer* obj, dt_stream_step const* step )
{
   dt_writer_tree* o = (dt_writer_tree*)obj;
   dt_node* node;

   switch( step->kind )
   {
   default:          return 0;

   case dt_leaf:     node = dt_make_leaf( step->val, step->val_len );
                     break;

   case dt_rec_in:   node = dt_make_rec();
                     break;

   case dt_arr_in:   node = dt_make_arr();
                     break;

   case dt_rec_out:
   case dt_arr_out:  if( o->stack.strEnd - o->stack.begin < sizeof(dt_node*) )
                        return 0;
                     o->stack.strEnd -= sizeof(dt_node*);
                     return 1;

   case dt_end:      return 1;
   }

   if( !! o->root ) /* first node is to be stored in root specified by caller */
   {
      *o->root = node; /* ownership of root node is now passed into caller-provided storate */
      o->root = 00;
   }
   else { /* node is to be stored within its parent */
      dt_node* parent;

      if( o->stack.strEnd - o->stack.begin < sizeof(dt_node*) )
         return 0;

      parent = ((dt_node**)o->stack.strEnd)[-1];
 
      if( !! step->key ) /* identifies whether we are in a record */
      {
         if( ! dt_rec_put( parent, step->key, step->key_len, node ) ) return 0;
      }
      else
         { if( ! dt_arr_append( parent, node ) ) return 0; }
      /* ownership of node has now been passed to parent, or it was released by failed call. */
   }

   return   ( step->kind == dt_leaf )
         || dt_buf_append_data( & o->stack, & node, sizeof(node) );
}

---