Beispiel #1
0
static void JsonAddPacketvars(const Packet *p, json_t *js_vars)
{
    if (p == NULL || p->pktvar == NULL) {
        return;
    }
    json_t *js_pktvars = NULL;
    PktVar *pv = p->pktvar;
    while (pv != NULL) {
        if (pv->key || pv->id > 0) {
            if (js_pktvars == NULL) {
                js_pktvars = json_array();
                if (js_pktvars == NULL)
                    break;
            }
            json_t *js_pair = json_object();
            if (js_pair == NULL) {
                break;
            }

            if (pv->key != NULL) {
                uint32_t offset = 0;
                uint8_t keybuf[pv->key_len + 1];
                PrintStringsToBuffer(keybuf, &offset,
                        sizeof(keybuf),
                        pv->key, pv->key_len);
                uint32_t len = pv->value_len;
                uint8_t printable_buf[len + 1];
                offset = 0;
                PrintStringsToBuffer(printable_buf, &offset,
                        sizeof(printable_buf),
                        pv->value, pv->value_len);
                json_object_set_new(js_pair, (char *)keybuf,
                        json_string((char *)printable_buf));
            } else {
                const char *varname = VarNameStoreLookupById(pv->id, VAR_TYPE_PKT_VAR);
                uint32_t len = pv->value_len;
                uint8_t printable_buf[len + 1];
                uint32_t offset = 0;
                PrintStringsToBuffer(printable_buf, &offset,
                        sizeof(printable_buf),
                        pv->value, pv->value_len);

                json_object_set_new(js_pair, varname,
                        json_string((char *)printable_buf));
            }
            json_array_append_new(js_pktvars, js_pair);
        }
        pv = pv->next;
    }
    if (js_pktvars) {
        json_object_set_new(js_vars, "pktvars", js_pktvars);
    }
}
Beispiel #2
0
void graph_response_newLinkDataResponse(req_t * req, json_t * request,
					json_t * response, int32_t requestId,
					void *sweb, req_store_t * req_store)
{

	if (strcmp
	    (json_string_value(json_object_get(response, "ack")), "ok") == 0) {

		json_t *link = json_object_get(request, "link");

		json_t *web_resp = json_object();
		json_object_set_new(web_resp, "type",
				    json_string("newLinkData"));
		//TODO at the moment only the original node gets the update, which is good enough for me
		json_t *sessionIds = json_array();
		json_array_append
		    (sessionIds, json_object_get(req->request, "sessionId"));
		json_object_set_new(web_resp, "sessionIds", sessionIds);

		json_t *newData = json_object();
		json_t *newLinkData = json_array();
		json_array_append(newLinkData, link);
		json_object_set_new(newData, "newLinkData", newLinkData);

		json_object_set_new(web_resp, "newData", newData);

		zmsg_t *res = zmsg_new();
		char *web_res_str = json_dumps(web_resp,
					       JSON_COMPACT);
		printf("\nbroker:sweb sent: %s\n", web_res_str);
		zmsg_addstr(res, web_res_str);
		free(web_res_str);
		zmsg_wrap(res, req->address);
		zmsg_send(&res, sweb);
		json_decref(web_resp);
	} else {
	}
	request_store_delete(req_store, requestId);

}
Beispiel #3
0
int tid_req_add_path(TID_REQ *req,
		     const char *this_system, unsigned port)
{
  char *path_element = talloc_asprintf(req, "%s:%u",
				       this_system, port);
  if (!req->path) {
    req->path = json_array();
    if (!req->path)
      return -1;
    tid_req_cleanup_json(req, req->path);
  }
  return json_array_append( req->path, json_string(path_element));
}
Beispiel #4
0
TID_REQ *tid_req_new()
{
  TID_REQ *req = talloc_zero(NULL, TID_REQ);
  if(!req)
    return NULL;
  talloc_set_destructor(req, destroy_tid_req);
  req->json_references = json_array();
  assert(req->json_references);
  req->conn = -1;
  req->free_conn = 1;
  req->request_id = NULL;
  return req;
}
Beispiel #5
0
static json_t *
json_string_or_array(int nr, char **items)
{
    if (nr == 1) {
        return json_string(items[0]);
    }
    json_t *result = json_array();
    int i;
    for (i = 0; i < nr; ++i) {
        json_array_append_new(result, json_string(items[i]));
    }
    return result;
}
Beispiel #6
0
/**
 * @param  search   The search result
 */
static void get_search(sp_search *search)
{
        int i;
        json_t *json = json_object();

        json_t *tracks = json_array();
        json_object_set_new(json, "tracks", tracks);
        for (i = 0; i < sp_search_num_tracks(search); ++i){
            json_array_append_new(tracks, get_track(sp_search_track(search, i)));
        }
        json_object_set_new_nocheck(json, "query", json_string_nocheck(sp_search_query(search)));
        cmd_sendresponse(json, 200);
}
Beispiel #7
0
json_t * bck_host_file_read(json_t * obj)
{
	char * interface = (char *)json_string_value(json_object_get(obj,"int"));
	char * date = (char *)json_string_value(json_object_get(obj,"hostfile"));
	char * filename;
	filename = (char *)calloc(SIZE,sizeof(char));
	sprintf(filename,"/etc/statistics/darkstat/%s_hosts_%s.txt",date,interface);
	//printf("This is the file name to read: %s\n",filename);
	json_t * ret = json_array();
	ret = get_top_hosts(filename);
	free(filename);
	return(ret);
}
Beispiel #8
0
char * MessageBuilder::buildRegister( int port, char const** hears, int hearsSize, char const** plays, int playsSize ) const
{
	json_t *array = json_array();
	json_array_append_new(array, json_string("register"));
	json_array_append_new(array, json_string(lemmaId));
	json_array_append_new(array, json_integer(port));
  string_array_append_new(array, hears, hearsSize);
  string_array_append_new(array, plays, playsSize);

  char * string = json_dumps(array, 0);
	json_decref(array);
	return string;
}
Beispiel #9
0
char * MessageBuilder::buildMarco(const char* roomName)
{
	json_t *array = json_array();
	json_array_append_new(array, json_string("marco"));
	json_array_append_new(array, json_string(lemmaId));
	json_array_append_new(array, json_string(roomName));
	json_array_append_new(array, json_string("cpp"));
	json_array_append_new(array, json_string("1.1"));

  char * string = json_dumps(array, 0);
	json_decref(array);
	return string;
}
Beispiel #10
0
/**
 * Initializes the device type by getting its uid, name and description
 */
json_t * b_device_type_init () {
  json_t * options = json_array();
  json_array_append_new(options, json_pack("{ssssssso}", "name", "uri", "type", "string", "description", "uri to connect to the device", "optional", json_false()));
  json_array_append_new(options, json_pack("{ssssssso}", "name", "baud", "type", "numeric", "description", "speed of the device communication", "optional", json_false()));
  json_array_append_new(options, json_pack("{ssssssso}", "name", "do_not_check_certificate", "type", "boolean", "description", "check the certificate of the device if needed", "optional", json_true()));
  json_array_append_new(options, json_pack("{ssssssso}", "name", "device_specified", "type", "string", "description", "specified by the device when connected for the first time, then must be sent back at every other connection", "optional", json_true()));
  return json_pack("{sissssssso}", 
                    "result", WEBSERVICE_RESULT_OK,
                    "uid", "00-00-00", 
                    "name", "Another Mock Device", 
                    "description", "This is another mock device, for development and debug purposes", 
                    "options", options);
}
Beispiel #11
0
static void test_chaos()
{
    json_malloc_t orig_malloc;
    json_free_t orig_free;
    json_t *json = NULL;
    json_t *obj = json_object();
    json_t *arr1 = json_array();
    json_t *arr2 = json_array();
    json_t *txt = json_string("test");
    json_t *intnum = json_integer(1);
    json_t *dblnum = json_real(0.5);
    char *dumptxt = NULL;
    json_t *dumpobj = json_pack("{s:[iiis], s:s}",
        "key1", 1, 2, 3, "txt",
        "key2", "v2");
    int keyno;

    if (!obj || !arr1 || !arr2 || !txt || !intnum || !dblnum || !dumpobj)
        fail("failed to allocate basic objects");

    json_get_alloc_funcs(&orig_malloc, &orig_free);
    json_set_alloc_funcs(chaos_malloc, chaos_free);

    chaos_loop_new_value(json, json_pack("{s:s}", "key", "value"));
    chaos_loop_new_value(json, json_pack("{s:[]}", "key"));
    chaos_loop_new_value(json, json_pack("[biIf]", 1, 1, (json_int_t)1, 1.0));
    chaos_loop_new_value(json, json_pack("[s*,s*]", "v1", "v2"));
    chaos_loop_new_value(json, json_pack("o", json_incref(txt)));
    chaos_loop_new_value(json, json_pack("O", txt));
    chaos_loop_new_value(json, json_pack("s++", "a",
        "long string to force realloc",
        "another long string to force yet another reallocation of the string because "
        "that's what we are testing."));

    chaos_loop(test_unpack(),,);

    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)),,);
    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1) | JSON_SORT_KEYS),,);
    chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt); dumptxt = NULL;);
Beispiel #12
0
json_t* dump_headers(const nghttp2_nv *nva, size_t nvlen)
{
  json_t *headers;
  size_t i;

  headers = json_array();
  for(i = 0; i < nvlen; ++i) {
    json_array_append_new(headers,
                          dump_header(nva[i].name, nva[i].namelen,
                                      nva[i].value, nva[i].valuelen));
  }
  return headers;
}
Beispiel #13
0
int32 rf_evt_pack_json(json_t *result, const int32 *evt_types, rf_evt_svc_t *service)
{
	int32 i = 0;
	json_t *types_array = NULL;
	json_t *listener = NULL;
	json_t *status = NULL;

	json_object_add(result, RMM_JSON_ODATA_CONTEXT, json_string(service->links.odata_context));
	json_object_add(result, RMM_JSON_ODATA_ID, json_string(service->links.odata_id));
	add_json_string(result, RMM_JSON_ODATA_TYPE, service->fixed.odata_type);
	add_json_string(result, RMM_JSON_RF_ID, service->fixed.id);
	add_json_string(result, RMM_JSON_RF_NAME, service->fixed.name);

	status = json_object();
	if (status != NULL) {
		add_json_string(status, RMM_JSON_RF_STATUS_STATE, service->fixed.status.state);
		add_json_string(status, RMM_JSON_RF_STATUS_HEALTH, service->fixed.status.health);
	}
	json_object_add(result, RMM_JSON_RF_STATUS, status);

	if (service->fixed.service_enabled)
		json_object_add(result, RMM_JSON_RF_SERVICE_ENABLED, json_true());
	else
		json_object_add(result, RMM_JSON_RF_SERVICE_ENABLED, json_false());

	add_json_integer(result, RMM_JSON_RF_DELIVERY_RETRY, service->fixed.retry);

	add_json_integer(result, RMM_JSON_RF_DELIVERY_RETRY_INTERVAL, service->fixed.retry_interval);


	types_array = json_array();
	if (types_array == NULL)
		return -1;

	for (i = 0;  i < MAX_EVT_ACTION_NUM; i++) {
		if (evt_types[i] == 0)
			continue;

		json_array_add(types_array, json_string((int8 *)rf_evt_msg[i].type_name));
	}
	json_object_add(result, RMM_JSON_RF_SUPPORTED_EVT_TYPES, types_array);

	listener = json_object();
	if (listener == NULL) 
		return -1;

	add_json_string(listener, RMM_JSON_ODATA_ID, service->links.subscriptions);
	json_object_add(result, RMM_JSON_RF_SUBSCRIPTION, listener);

	return 0;
}
Beispiel #14
0
json_t *json_pack_updates (unsigned flags) {
  json_t *a = json_array ();
  
  if (flags & TGL_UPDATE_CREATED) {
    assert (json_array_append (a, json_string ("created")) >= 0);
  }  
  if (flags & TGL_UPDATE_DELETED) {
    assert (json_array_append (a, json_string ("deleted")) >= 0);
  }  
  if (flags & TGL_UPDATE_PHONE) {
    assert (json_array_append (a, json_string ("phone")) >= 0);
  }
  if (flags & TGL_UPDATE_CONTACT) {
    assert (json_array_append (a, json_string ("contact")) >= 0);
  }
  if (flags & TGL_UPDATE_PHOTO) {
    assert (json_array_append (a, json_string ("photo")) >= 0);
  }
  if (flags & TGL_UPDATE_BLOCKED) {
    assert (json_array_append (a, json_string ("blocked")) >= 0);
  }
  if (flags & TGL_UPDATE_REAL_NAME) {
    assert (json_array_append (a, json_string ("real_name")) >= 0);
  }
  if (flags & TGL_UPDATE_NAME) {
    assert (json_array_append (a, json_string ("name")) >= 0);
  }
  if (flags & TGL_UPDATE_REQUESTED) {
    assert (json_array_append (a, json_string ("requested")) >= 0);
  }
  if (flags & TGL_UPDATE_WORKING) {
    assert (json_array_append (a, json_string ("working")) >= 0);
  }
  if (flags & TGL_UPDATE_FLAGS) {
    assert (json_array_append (a, json_string ("flags")) >= 0);
  }
  if (flags & TGL_UPDATE_TITLE) {
    assert (json_array_append (a, json_string ("title")) >= 0);
  }
  if (flags & TGL_UPDATE_ADMIN) {
    assert (json_array_append (a, json_string ("admin")) >= 0);
  }
  if (flags & TGL_UPDATE_MEMBERS) {
    assert (json_array_append (a, json_string ("members")) >= 0);
  }
  if (flags & TGL_UPDATE_USERNAME) {
    assert (json_array_append (a, json_string ("username")) >= 0);
  }

  return a;
}
Beispiel #15
0
void Patch::writeChannels(json_t *jContainer, vector<channel_t> *channels)
{
  json_t *jChannels = json_array();
  for (unsigned i=0; i<channels->size(); i++) {
    json_t    *jChannel = json_object();
    channel_t  channel  = channels->at(i);
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_TYPE,                 json_integer(channel.type));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_INDEX,                json_integer(channel.index));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_COLUMN,               json_integer(channel.column));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MUTE,                 json_integer(channel.mute));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MUTE_S,               json_integer(channel.mute_s));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_SOLO,                 json_integer(channel.solo));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_VOLUME,               json_real(channel.volume));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PAN_LEFT,             json_real(channel.panLeft));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PAN_RIGHT,            json_real(channel.panRight));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN,              json_boolean(channel.midiIn));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KEYPRESS,     json_integer(channel.midiInKeyPress));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KEYREL,       json_integer(channel.midiInKeyRel));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KILL,         json_integer(channel.midiInKill));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_ARM,          json_integer(channel.midiInArm));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_VOLUME,       json_integer(channel.midiInVolume));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_MUTE,         json_integer(channel.midiInMute));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_SOLO,         json_integer(channel.midiInSolo));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L,           json_boolean(channel.midiOutL));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_PLAYING,   json_integer(channel.midiOutLplaying));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_MUTE,      json_integer(channel.midiOutLmute));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_SOLO,      json_integer(channel.midiOutLsolo));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_SAMPLE_PATH,          json_string(channel.samplePath.c_str()));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_KEY,                  json_integer(channel.key));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MODE,                 json_integer(channel.mode));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_BEGIN,                json_integer(channel.begin));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_END,                  json_integer(channel.end));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_BOOST,                json_real(channel.boost));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_REC_ACTIVE,           json_integer(channel.recActive));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PITCH,                json_real(channel.pitch));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_READ_ACTIONS, json_integer(channel.midiInReadActions));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_PITCH,        json_integer(channel.midiInPitch));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT,             json_integer(channel.midiOut));
    json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_CHAN,        json_integer(channel.midiOutChan));
    json_array_append_new(jChannels, jChannel);

    writeActions(jChannel, &channel.actions);

#ifdef WITH_VST

    writePlugins(jChannel, &channel.plugins, PATCH_KEY_CHANNEL_PLUGINS);

#endif
  }
  json_object_set_new(jContainer, PATCH_KEY_CHANNELS, jChannels);
}
Beispiel #16
0
static json_t *
json_symarray(struct nh_symdef *array, int len)
{
    int i;
    json_t *jarr, *jobj;

    jarr = json_array();
    for (i = 0; i < len; i++) {
        jobj =
            json_pack("[s,i,i]", array[i].symname, array[i].ch, array[i].color);
        json_array_append_new(jarr, jobj);
    }
    return jarr;
}
Beispiel #17
0
static void fsmonitor_callback(fsdiff_t *diff, void *data) {
    item_t *item = (item_t *)data;

    json_t *json = json_array();
    int count = fsdiff_count(diff);
    for (int i = 0; i < count; ++i)
        json_array_append(json, json_string(fsdiff_get(diff, i)));
    fsdiff_free(diff);

    change_t *change = (change_t *)malloc(sizeof(change_t));
    change->id = json_incref(item->id);
    change->diff = json;
    invoke_on_main_thread(fsmonitor_callback_main_thread, change);
}
Beispiel #18
0
json_t*
bser2json(bser_t* bser)
{
    if (bser_is_integer(bser)) {
        json_int_t v = bser_integer_value(bser);
        return json_integer(v);
    } else if (bser_is_real(bser)) {
        double v = bser_real_value(bser);
        return json_real(v);
    } else if (bser_is_true(bser)) {
        return json_true();
    } else if (bser_is_false(bser)) {
        return json_false();
    } else if (bser_is_null(bser)) {
        return json_null();
    } else if (bser_is_string(bser)) {
        size_t length;
        const char* str = bser_string_value(bser, &length);
        char* dup = strndup(str, length);
        json_t* string = json_string(dup);
        free(dup);
        return string;
    } else if (bser_is_array(bser)) {
        size_t length = bser_array_size(bser);
        json_t* array = json_array();
        for (int i = 0; i < length; ++i) {
            json_array_append_new(array, bser2json(bser_array_get(bser, i)));
        }
        return array;
    } else if (bser_is_object(bser)) {
        size_t length = bser_object_size(bser);
        json_t* object = json_object();
        for (int i = 0; i < length; ++i) {
            size_t key_length;
            bser_t* key = bser_object_key_at(bser, i);
            assert(bser_is_string(key));
            bser_t* value = bser_object_value_at(bser, i);
            if (!bser_is_no_field(value)) {
                const char* key_chars = bser_string_value(key, &key_length);
                assert(key_chars != NULL && *key_chars != '\0');
                char* key_dup = strndup(key_chars, key_length);
                json_object_set_new(object, key_dup, bser2json(value));
                free(key_dup);
            }
        }
        return object;
    } else {
        return NULL;
    }
}
Beispiel #19
0
static void get_playlist_subscribers(sp_playlist *playlist,
                                     struct evhttp_request *request,
                                     void *userdata) {
  assert(sp_playlist_is_loaded(playlist));
  sp_subscribers *subscribers = sp_playlist_subscribers(playlist);
  json_t *array = json_array();

  for (int i = 0; i < subscribers->count; i++) {
    char *subscriber = subscribers->subscribers[i];
    json_array_append_new(array, json_string(subscriber));
  }

  send_reply_json(request, HTTP_OK, "OK", array);
}
Beispiel #20
0
void Patch::writeActions(json_t *jContainer, vector<action_t> *actions)
{
  json_t *jActions = json_array();
  for (unsigned k=0; k<actions->size(); k++) {
    json_t   *jAction = json_object();
    action_t  action  = actions->at(k);
    json_object_set_new(jAction, PATCH_KEY_ACTION_TYPE,    json_integer(action.type));
    json_object_set_new(jAction, PATCH_KEY_ACTION_FRAME,   json_integer(action.frame));
    json_object_set_new(jAction, PATCH_KEY_ACTION_F_VALUE, json_real(action.fValue));
    json_object_set_new(jAction, PATCH_KEY_ACTION_I_VALUE, json_integer(action.iValue));
    json_array_append_new(jActions, jAction);
  }
  json_object_set_new(jContainer, PATCH_KEY_CHANNEL_ACTIONS, jActions);
}
Beispiel #21
0
static json_t *json_array_deep_copy(json_t *array)
{
    json_t *result;
    unsigned int i;

    result = json_array();
    if(!result)
        return NULL;

    for(i = 0; i < json_array_size(array); i++)
        json_array_append_new(result, json_deep_copy(json_array_get(array, i)));

    return result;
}
Beispiel #22
0
Json::Json( json_type v ): data(NULL)
{
	switch ( v )
	{
		case JSON_ARRAY:	data = json_array();		break;
		case JSON_OBJECT:	data = json_object();		break;
		case JSON_FALSE:	data = json_boolean(false);	break;
		case JSON_TRUE:		data = json_boolean(true);	break;
		case JSON_INTEGER:	data = json_integer(0);		break;
		case JSON_REAL:		data = json_real(0);		break;
		case JSON_STRING:	data = json_string("");		break;
		default:			data = json_null();			break;
	}
}
Beispiel #23
0
static json_t *create_array()
{
    json_t *array;

    array = json_array();
    if(!array)
        fail("unable to create an array");

    if(json_array_append_new(array, json_integer(1)) ||
       json_array_append_new(array, json_integer(2)))
        fail("unable to append array values");

    return array;
}
Beispiel #24
0
json_t *pug_module_dump(pug_module_t *module) {
  json_t *jmodule = json_object();
  json_object_set(jmodule, "name", json_bstring(module->name));

  json_t *jfunctions = json_array();
  for (int i = 0; i < vector_pug_function_size(&module->functions); i++) {
    pug_function_t *function = vector_pug_function_get(&module->functions, i);
    json_t *jfunction = pug_function_dump(function);
    json_array_append(jfunctions, jfunction);
  }
  json_object_set(jmodule, "functions", jfunctions);

  return jmodule;
}
Beispiel #25
0
static void _json_write(FILE * file, json_t json, unsigned int depth)
{
    switch (json_type(json)) {
    case ARRAY:
        _json_write_array(file, json_array(json), depth);
        break;
    case OBJECT:
        _json_write_object(file, json_object(json), depth);
        break;
    case STRING:
        _json_write_string(file, json_string(json));
        break;
    };
}
void pilot::JSONFileHandler::startArrayWrite(const char* name, size_t, bool) {
	auto array = json_array();

	if (json_is_array(_currentEl)) {
		// We are in an array, section must be unnamed
		Assertion(name == nullptr, "Inside an array there can be no named section!");
		json_array_append_new(_currentEl, array);
	} else {
		Assertion(name != nullptr, "Section outside of arrays must be named!");
		json_object_set_new(_currentEl, name, array);
	}
	_currentEl = array;
	_elementStack.push_back(_currentEl);
}
Beispiel #27
0
static json_t *json_array_copy(json_t *array)
{
    json_t *result;
    size_t i;

    result = json_array();
    if(!result)
        return NULL;

    for(i = 0; i < json_array_size(array); i++)
        json_array_append(result, json_array_get(array, i));

    return result;
}
Beispiel #28
0
json_t *
fields_to_json(int fields)
{
    json_t *result = json_array();
    int i = 0;
    int mask;
    for (mask = 1; mask < WATCHMAN_FIELD_END; mask *= 2) {
        if (fields & mask) {
            json_array_append_new(result, json_string(fields_str[i]));
        }
        ++i;
    }
    return result;
}
Beispiel #29
0
json_t *pug_function_dump(pug_function_t *function) {
  json_t *jfunction = json_object();
  json_object_set(jfunction, "name", json_bstring(function->name));

  json_t *jarguments = json_array();
  for (int i = 0; i < vector_pug_argument_size(&function->arguments); i++) {
    pug_argument_t *argument = vector_pug_argument_get(&function->arguments, i);
    json_t *jargument = json_object();
    json_object_set(jargument, "name", json_bstring(argument->name));
    json_array_append(jarguments, jargument);
  }
  json_object_set(jfunction, "arguments", jarguments);
  return jfunction;
}
Beispiel #30
0
void LoopCacheSave(JSON Root)
{
    EXCLUSIVE_ACQUIRE(LockLoops);

    // Create the root JSON objects
    const JSON jsonLoops = json_array();
    const JSON jsonAutoLoops = json_array();

    // Write all entries
    for(auto & itr : loops)
    {
        const LOOPSINFO & currentLoop = itr.second;
        JSON currentJson = json_object();

        json_object_set_new(currentJson, "module", json_string(currentLoop.mod));
        json_object_set_new(currentJson, "start", json_hex(currentLoop.start));
        json_object_set_new(currentJson, "end", json_hex(currentLoop.end));
        json_object_set_new(currentJson, "depth", json_integer(currentLoop.depth));
        json_object_set_new(currentJson, "parent", json_hex(currentLoop.parent));

        if(currentLoop.manual)
            json_array_append_new(jsonLoops, currentJson);
        else
            json_array_append_new(jsonAutoLoops, currentJson);
    }

    // Append a link to the global root
    if(json_array_size(jsonLoops))
        json_object_set(Root, "loops", jsonLoops);

    if(json_array_size(jsonAutoLoops))
        json_object_set(Root, "autoloops", jsonAutoLoops);

    // Release memory/references
    json_decref(jsonLoops);
    json_decref(jsonAutoLoops);
}