static int
raptor_json_serialize_end(raptor_serializer* serializer)
{
  raptor_json_context* context = (raptor_json_context*)serializer->context;
  char* value;
  
  raptor_json_writer_newline(context->json_writer);

  if(context->is_resource) {
    /* start outer object */
    raptor_json_writer_start_block(context->json_writer, '{');
    raptor_json_writer_newline(context->json_writer);
    
    raptor_avltree_visit(context->avltree,
                         raptor_json_serialize_avltree_visit,
                         serializer);

    /* end last triples block */
    if(context->last_statement) {
      raptor_json_writer_newline(context->json_writer);
      raptor_json_writer_end_block(context->json_writer, ']');
      raptor_json_writer_newline(context->json_writer);
      
      raptor_json_writer_end_block(context->json_writer, '}');
      raptor_json_writer_newline(context->json_writer);
    }
  } else {
    /* end triples array */
    raptor_json_writer_end_block(context->json_writer, ']');
    raptor_json_writer_newline(context->json_writer);
  }


  value = RAPTOR_OPTIONS_GET_STRING(serializer, RAPTOR_OPTION_JSON_EXTRA_DATA);
  if(value) {
    raptor_iostream_write_byte(',', serializer->iostream);
    raptor_json_writer_newline(context->json_writer);
    raptor_iostream_string_write(value, serializer->iostream);
    raptor_json_writer_newline(context->json_writer);
  }


  /* end outer object */
  raptor_json_writer_end_block(context->json_writer, '}');
  raptor_json_writer_newline(context->json_writer);

  /* end callback */
  if(RAPTOR_OPTIONS_GET_STRING(serializer, RAPTOR_OPTION_JSON_CALLBACK))
    raptor_iostream_counted_string_write((const unsigned char*)");", 2,
                                         serializer->iostream);

  return 0;
}
Exemple #2
0
int
main(int argc, char *argv[])
{
    raptor_world *world;
    const char *program = raptor_basename(argv[0]);
#define ITEM_COUNT 8
    const char *items[ITEM_COUNT+1] = { "ron", "amy", "jen", "bij", "jib", "daj", "jim", "def", NULL };
#define DELETE_COUNT 2
    const char *delete_items[DELETE_COUNT+1] = { "jen", "jim", NULL };
#define RESULT_COUNT (ITEM_COUNT-DELETE_COUNT)
    const char *results[RESULT_COUNT+1] = { "amy", "bij", "daj", "def", "jib", "ron", NULL};

    raptor_avltree* tree;
    raptor_avltree_iterator* iter;
    visit_state vs;
    int i;

    world = raptor_new_world();
    if(!world || raptor_world_open(world))
        exit(1);

    tree = raptor_new_avltree(compare_strings,
                              NULL, /* no free as they are static pointers above */
                              0);
    if(!tree) {
        fprintf(stderr, "%s: Failed to create tree\n", program);
        exit(1);
    }
    for(i = 0; items[i]; i++) {
        int rc;
        void* node;

#if RAPTOR_DEBUG > 1
        fprintf(stderr, "%s: Adding tree item '%s'\n", program, items[i]);
#endif

        rc = raptor_avltree_add(tree, (void*)items[i]);
        if(rc) {
            fprintf(stderr,
                    "%s: Adding tree item %d '%s' failed, returning error %d\n",
                    program, i, items[i], rc);
            exit(1);
        }

#ifdef RAPTOR_DEBUG
        raptor_avltree_check(tree);
#endif

        node = raptor_avltree_search(tree, (void*)items[i]);
        if(!node) {
            fprintf(stderr,
                    "%s: Tree did NOT contain item %d '%s' as expected\n",
                    program, i, items[i]);
            exit(1);
        }
    }

#if RAPTOR_DEBUG > 1
    fprintf(stderr, "%s: Printing tree\n", program);
    vs.fh = stderr;
    vs.count = 0;
    raptor_avltree_visit(tree, print_string, &vs);

    fprintf(stderr, "%s: Dumping tree\n", program);
    raptor_avltree_dump(tree, stderr);
#endif



    for(i = 0; delete_items[i]; i++) {
        int rc;

#if RAPTOR_DEBUG > 1
        fprintf(stderr, "%s: Deleting tree item '%s'\n", program, delete_items[i]);
#endif

        rc = raptor_avltree_delete(tree, (void*)delete_items[i]);
        if(!rc) {
            fprintf(stderr,
                    "%s: Deleting tree item %d '%s' failed, returning error %d\n",
                    program, i, delete_items[i], rc);
            exit(1);
        }

#ifdef RAPTOR_DEBUG
        raptor_avltree_check(tree);
#endif
    }


#if RAPTOR_DEBUG > 1
    fprintf(stderr, "%s: Walking tree forwards via iterator\n", program);
#endif
    iter = raptor_new_avltree_iterator(tree, NULL, NULL, 1);
    for(i = 0; 1; i++) {
        const char* data = (const char*)raptor_avltree_iterator_get(iter);
        const char* result = results[i];
        if((!data && data != result) || (data && strcmp(data, result))) {
            fprintf(stderr, "%3d: Forwards iterator expected '%s' but found '%s'\n",
                    i, result, data);
            exit(1);
        }
#if RAPTOR_DEBUG > 1
        fprintf(stderr, "%3d: Got '%s'\n", i, data);
#endif
        if(raptor_avltree_iterator_next(iter))
            break;
        if(i > RESULT_COUNT) {
            fprintf(stderr, "Forward iterator did not end on result %i as expected\n", i);
            exit(1);
        }
    }
    raptor_free_avltree_iterator(iter);


#if RAPTOR_DEBUG > 1
    fprintf(stderr, "%s: Checking tree\n", program);
#endif
    vs.count = 0;
    vs.results = results;
    vs.failed = 0;
    raptor_avltree_visit(tree, check_string, &vs);
    if(vs.failed) {
        fprintf(stderr, "%s: Checking tree failed\n", program);
        exit(1);
    }


    for(i = 0; results[i]; i++) {
        const char* result = results[i];
        char* data = (char*)raptor_avltree_remove(tree, (void*)result);
        if(!data) {
            fprintf(stderr, "%s: remove %i failed at item '%s'\n", program, i,
                    result);
            exit(1);
        }
        if(strcmp(data, result)) {
            fprintf(stderr, "%s: remove %i returned %s not %s as expected\n", program,
                    i, data, result);
            exit(1);
        }
    }


#if RAPTOR_DEBUG > 1
    fprintf(stderr, "%s: Freeing tree\n", program);
#endif
    raptor_free_avltree(tree);

    raptor_free_world(world);

    /* keep gcc -Wall happy */
    return(0);
}