C++ JSON_INDENT函数代码示例

void ZnpActorPublishDeviceLqi(WORD nAddress, BYTE nLqi)
{
	PDEVICEINFO pDevice;
	if (pZnpActor == NULL) return;
	pDevice = DeviceFind(nAddress);
	if (pDevice == NULL) return;
	json_t* eventJson = json_object();
	json_t* paramsJson = json_object();
	char* macIdString = IeeeToString(pDevice->IeeeAddr);
	json_t* macIdJson = json_string(macIdString);
	json_t* lqiJson = NULL;
	free(macIdString);
	json_t* protocolJson = json_string("zigbee");
	if (nLqi > LQI_LIMIT)
		lqiJson = json_integer(1);
	else
		lqiJson = json_integer(0);
	json_object_set(paramsJson, "macId", macIdJson);
	json_object_set(paramsJson, "protocol", protocolJson);
	json_object_set(paramsJson, "signal_strength", lqiJson);
	json_object_set(eventJson, "params", paramsJson);
	char* eventMessage = json_dumps(eventJson, JSON_INDENT(4) | JSON_REAL_PRECISION(4));
	//char* topicName = ActorMakeTopicName(pZnpActor->guid, "/:event/device_signal");
	char* topicName = ActorMakeTopicName("event/", pZnpActor->guid, "/device_signal");
	ActorSend(pZnpActor, topicName, eventMessage, NULL, FALSE, topicName);
	json_decref(lqiJson);
	json_decref(protocolJson);
	json_decref(macIdJson);
	json_decref(paramsJson);
	json_decref(eventJson);
	free(topicName);
	free(eventMessage);
}

void ZnpActorPublishEndpointAddedEvent(IEEEADDRESS macId, BYTE endpoint, WORD deviceId, WORD deviceType)
{
	if (pZnpActor == NULL) return;
	json_t* eventJson = json_object();
	json_t* paramsJson = json_object();
	char* eventMessage;
	char* topicName;
	char* macIdString = IeeeToString(macId);
	json_t* macJson = json_string(macIdString);
	free(macIdString);
	json_object_set(paramsJson, "macId", macJson);
	json_decref(macJson);
	char* endpointString = malloc(20);
	sprintf(endpointString, "%d", endpoint);
	json_t* endpointJson = json_string(endpointString);
	free(endpointString);
	json_object_set(paramsJson, "endpoint", endpointJson);
	json_decref(endpointJson);
	json_t* deviceClassJson;
	deviceClassJson = DevDesMakeDeviceClassJson(deviceId, deviceType);
	json_object_set(paramsJson, "class", deviceClassJson);
	json_decref(deviceClassJson);
	json_t* protocolJson = json_string("zigbee");
	json_object_set(paramsJson, "protocol", protocolJson);
	json_decref(protocolJson);
	json_object_set(eventJson, "params", paramsJson);
	json_decref(paramsJson);
	eventMessage = json_dumps(eventJson, JSON_INDENT(4) | JSON_REAL_PRECISION(4));
	json_decref(eventJson);
	//topicName = ActorMakeTopicName(pZnpActor->guid, "/:event/endpoint_added");
	topicName = ActorMakeTopicName("event/", pZnpActor->guid, "/endpoint_added");
	ActorSend(pZnpActor, topicName, eventMessage, NULL, FALSE, topicName);
	free(eventMessage);
	free(topicName);
}

void ZnpActorPublishDeviceErrorEvent(IEEEADDRESS macId, WORD error)
{
	if (pZnpActor == NULL) return;
	json_t* eventJson = json_object();
	json_t* paramsJson = json_object();
	char* macIdString = IeeeToString(macId);
	json_t* macIdJson = json_string(macIdString);
	free(macIdString);
	json_t* protocolJson = json_string("zigbee");
	char* errorMessage = malloc(50);
	sprintf(errorMessage, "%s%d","error.actor.", error);
	json_t* errorJson = json_string(errorMessage);
	free(errorMessage);
	json_object_set(paramsJson, "macId", macIdJson);
	json_object_set(paramsJson, "protocol", protocolJson);
	json_object_set(paramsJson, "error", errorJson);
	json_object_set(eventJson, "params", paramsJson);
	char* eventMessage = json_dumps(eventJson, JSON_INDENT(4) | JSON_REAL_PRECISION(4));
	//char* topicName = ActorMakeTopicName(pZnpActor->guid, "/:event/device_error");
	char* topicName = ActorMakeTopicName("event/", pZnpActor->guid, "/device_error");
	ActorSend(pZnpActor, topicName, eventMessage, NULL, FALSE, topicName);
	json_decref(errorJson);
	json_decref(protocolJson);
	json_decref(macIdJson);
	json_decref(paramsJson);
	json_decref(eventJson);
	free(topicName);
	free(eventMessage);
}

int janus_websockets_send_message(void *transport, void *request_id, gboolean admin, json_t *message) {
	if(message == NULL)
		return -1;
	if(transport == NULL) {
		g_free(message);
		return -1;
	}
	/* Make sure this is not related to a closed /freed WebSocket session */
	janus_mutex_lock(&old_wss_mutex);
	janus_websockets_client *client = (janus_websockets_client *)transport;
	if(g_list_find(old_wss, client) != NULL) {
		g_free(message);
		message = NULL;
		transport = NULL;
	} else if(!client->context || !client->wsi) {
		g_free(message);
		message = NULL;
	}
	if(message == NULL) {
		janus_mutex_unlock(&old_wss_mutex);
		return -1;
	}
	janus_mutex_lock(&client->mutex);
	/* Convert to string and enqueue */
	char *payload = json_dumps(message, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
	g_async_queue_push(client->messages, payload);
	libwebsocket_callback_on_writable(client->context, client->wsi);
	janus_mutex_unlock(&client->mutex);
	janus_mutex_unlock(&old_wss_mutex);
	json_decref(message);
	return 0;
}

/* encode_json : encode the exnode in the JSON format n dump it in string
 * dir : directory name
 * parent_id : parent directory id
 * return : JSON dump of exnode
 *
 */
char *encode_json(const char *dir, const char *parent_id){
	
	if(dir == NULL){
		fprintf(stderr, "Invalid directory name \n");
		return NULL;
	}
	
	// create json object
	json_t *json_exnode = json_object();
	json_object_set(json_exnode, "name", json_string(dir));
	json_object_set(json_exnode, "created", json_integer(time(NULL)));
	json_object_set(json_exnode, "modified", json_integer(time(NULL)));
	json_object_set(json_exnode, "mode", json_string("directory"));
	json_object_set(json_exnode, "size", json_integer(0));

	if (parent_id == NULL) {
	  json_object_set(json_exnode, "parent", json_null());
	}
	else {
	  json_t *pobj = json_object();
	  json_object_set(pobj, "href", json_string(parent_id));
	  json_object_set(pobj, "rel", json_string("full"));
	  json_object_set(json_exnode, "parent", pobj);
	}
	
	return json_dumps(json_exnode, JSON_INDENT(1));
}

bool w_state_save(void)
{
  json_t *state;
  w_jbuffer_t buffer;
  int fd = -1;
  char tmpname[WATCHMAN_NAME_MAX];
  bool result = false;

  if (dont_save_state) {
    return true;
  }

  pthread_mutex_lock(&state_lock);

  state = json_object();

  if (!w_json_buffer_init(&buffer)) {
    w_log(W_LOG_ERR, "save_state: failed to init json buffer\n");
    goto out;
  }

  snprintf(tmpname, sizeof(tmpname), "%sXXXXXX",
      watchman_state_file);
  fd = w_mkstemp(tmpname);
  if (fd == -1) {
    w_log(W_LOG_ERR, "save_state: unable to create temporary file: %s\n",
        strerror(errno));
    goto out;
  }

  json_object_set_new(state, "version", json_string(PACKAGE_VERSION));

  /* now ask the different subsystems to fill out the state */
  if (!w_root_save_state(state)) {
    goto out;
  }

  /* we've prepared what we're going to save, so write it out */
  w_json_buffer_write(&buffer, fd, state, JSON_INDENT(4));

  /* atomically replace the old contents */
  result = rename(tmpname, watchman_state_file) == 0;

out:
  if (state) {
    json_decref(state);
  }
  w_json_buffer_free(&buffer);
  if (fd != -1) {
    if (!result) {
      // If we didn't succeed, remove our temporary file
      unlink(tmpname);
    }
    close(fd);
  }

  pthread_mutex_unlock(&state_lock);

  return result;
}

void ZnpActorPublishDeviceDataEvent(IEEEADDRESS macId, BYTE endPoint, BYTE nDataCount, PZNPACTORDATA *pData)
{
	if (pZnpActor == NULL) return;
	json_t* eventJson = json_object();
	json_t* paramsJson = json_object();
	char* macIdString = IeeeToString(macId);
	json_t* macIdJson = json_string(macIdString);
	free(macIdString);
	char* endpointString = malloc(20);
	sprintf(endpointString, "%d", endPoint);
	json_t* endpointJson = json_string(endpointString);
	free(endpointString);
	json_t* protocolJson = json_string("zigbee");
	json_object_set(paramsJson, "macId", macIdJson);
	json_object_set(paramsJson, "endpoint", endpointJson);
	json_object_set(paramsJson, "protocol", protocolJson);
	json_decref(macIdJson);
	json_decref(endpointJson);
	json_decref(protocolJson);
	json_t* dataJson;
	json_t* valueJson;
	dataJson = json_object();
	BYTE nIndex = 0;
	while (nDataCount > 0)
	{
		switch (pData[nIndex]->nDataType)
		{
		case ZNP_DATA_TYPE_INTERGER:
			valueJson = json_integer((int)(*((int*)(pData[nIndex]->value))));
			break;
		case ZNP_DATA_TYPE_FLOAT:
			valueJson = json_real((double)(*((double*)(pData[nIndex]->value))));
			break;
		case ZNP_DATA_TYPE_STRING:
			valueJson = json_string(pData[nIndex]->value);
			break;
		default:
			json_decref(dataJson);
			json_decref(paramsJson);
			json_decref(eventJson);
			return;
			break;
		}
		json_object_set(dataJson, pData[nIndex]->dataName, valueJson);
		json_decref(valueJson);
		nDataCount--;
		nIndex++;
	}
	json_object_set(paramsJson, "data", dataJson);
	json_decref(dataJson);
	json_object_set(eventJson, "params", paramsJson);
	json_decref(paramsJson);
	char* eventMessage = json_dumps(eventJson, JSON_INDENT(4) | JSON_REAL_PRECISION(4));
	json_decref(eventJson);
	//char* topicName = ActorMakeTopicName(pZnpActor->guid, "/:event/device_data");
	char* topicName = ActorMakeTopicName("event/", pZnpActor->guid, "/device_data");
	ActorSend(pZnpActor, topicName, eventMessage, NULL, FALSE, topicName);
	free(topicName);
	free(eventMessage);
}

static struct MHD_Response *
send_metric(struct brubeck_server *server, const char *url)
{
    static const char *metric_types[] = {
        "gauge", "meter", "counter", "histogram", "timer", "internal"
    };
    static const char *expire_status[] = {
        "disabled", "inactive", "active"
    };

    struct brubeck_metric *metric = safe_lookup_metric(
                                        server, url + strlen("/metric/"));

    if (metric) {
        json_t *mj = json_pack("{s:s, s:s, s:i, s:s}",
                               "key", metric->key,
                               "type", metric_types[metric->type],
#if METRIC_SHARD_SPECIFIER
                               "shard", (int)metric->shard,
#else
                               "shard", 0,
#endif
                               "expire", expire_status[metric->expire]
                              );

        char *jsonr = json_dumps(mj, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
        json_decref(mj);
        return MHD_create_response_from_data(
                   strlen(jsonr), jsonr, 1, 0);
    }

    return NULL;
}

void janus_echotest_hangup_media(janus_plugin_session *handle) {
	JANUS_LOG(LOG_INFO, "No WebRTC media anymore\n");
	if(stopping || !initialized)
		return;
	janus_echotest_session *session = (janus_echotest_session *)handle->plugin_handle;
	if(!session) {
		JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");
		return;
	}
	if(session->destroyed)
		return;
	/* Send an event to the browser and tell it's over */
	json_t *event = json_object();
	json_object_set_new(event, "echotest", json_string("event"));
	json_object_set_new(event, "result", json_string("done"));
	char *event_text = json_dumps(event, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
	json_decref(event);
	JANUS_LOG(LOG_VERB, "Pushing event: %s\n", event_text);
	int ret = gateway->push_event(handle, &janus_echotest_plugin, NULL, event_text, NULL, NULL);
	JANUS_LOG(LOG_VERB, "  >> %d (%s)\n", ret, janus_get_api_error(ret));
	g_free(event_text);
	/* Reset controls */
	session->audio_active = TRUE;
	session->video_active = TRUE;
	session->bitrate = 0;
}

void SubmitContext::submitBlock(blktemplate_t *blockTemplate,
                                const PrimecoinBlockHeader &header,
                                unsigned dataId)
{
  json_t *jsonBlock =
    blkmk_submit_jansson(blockTemplate,
                         (unsigned char*)&header,
                         dataId,
                         __builtin_bswap32(header.nonce),
                         header.multiplier,
                         header.multiplier[0]+1);
  char *request = json_dumps(jsonBlock, JSON_INDENT(2));
  json_delete(jsonBlock);
  
  _response.clear();
  logFormattedWrite(_log, "submit request: %s", request);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
  if (curl_easy_perform(curl) != CURLE_OK) {
    logFormattedWrite(_log, "block send error!!!");
  } else {
    logFormattedWrite(_log, "response: %s");
  }
  
  free(request);
}

static
void
cd_JSONRequest (struct evhttp_request* request, CDServer* server)
{
    struct evbuffer* buffer = evhttp_request_get_input_buffer(request);
    char*            text   = CD_alloc(evbuffer_get_length(buffer) + 1);

    evbuffer_remove(buffer, text, evbuffer_get_length(buffer));

    json_error_t error;
    json_t*      input  = json_loads(text, 0, &error);
    json_t*      output = json_object();

    printf("%s\n", text);

    if (evhttp_request_get_command(request) != EVHTTP_REQ_POST) {
        goto error;
    }

    if (input == NULL) {
        SERR(server, "RPC.JSON: error on line %d: %s", error.line, error.text);

        goto error;
    }

    CD_EventDispatch(server, "RPC.JSON", input, output);

done: {
        char*            outString = json_dumps(output, JSON_INDENT(2));
        struct evbuffer* outBuffer = evbuffer_new();

        evbuffer_add_printf(outBuffer, "%s", outString);

        evhttp_send_reply(request, HTTP_OK, "OK", outBuffer);

        evbuffer_free(outBuffer);
        free(outString);
        json_delete(output);
        json_delete(input);
        CD_free(text);

        return;
    }

error: {
        evhttp_send_error(request, HTTP_INTERNAL, "Internal server error");

        CD_free(text);

        if (input) {
            json_delete(input);
        }

        if (output) {
            json_delete(output);
        }

        return;
    }
}

void on_list_update(struct DSLink *link, ref_t *req_ref, json_t *resp) {
    (void) link;
    RequestHolder *holder = req_ref->data;

    json_t *updates = json_object_get(resp, "updates");
    size_t index;
    json_t *value;

    const char* path = json_string_value(json_object_get(holder->req, "path"));

    printf("======= List %s =======\n", path);
    json_array_foreach(updates, index, value) {
        json_t *name = json_array_get(value, 0);
        json_t *val = json_array_get(value, 1);

        if (val->type == JSON_ARRAY || val->type == JSON_OBJECT) {
            char *data = json_dumps(val, JSON_INDENT(0));
            printf("%s = %s\n", json_string_value(name), data);
            dslink_free(data);
        } else if (val->type == JSON_STRING) {
            printf("%s = %s\n", json_string_value(name), json_string_value(val));
        } else if (val->type == JSON_INTEGER) {
            printf("%s = %lli\n", json_string_value(name), json_integer_value(val));
        } else if (val->type == JSON_REAL) {
            printf("%s = %f\n", json_string_value(name), json_real_value(val));
        } else if (val->type == JSON_NULL) {
            printf("%s = NULL\n", json_string_value(name));
        } else if (val->type == JSON_TRUE) {
            printf("%s = true\n", json_string_value(name));
        } else if (val->type == JSON_FALSE) {
            printf("%s = false\n", json_string_value(name));
        } else {
            printf("%s = (Unknown Type)\n", json_string_value(name));
        }
    }

void saveRevenueMovements(char * save_path)
{
    json_t * json_revenue = json_object();
    
    json_t * array = json_array();

    json_t * json_total = json_real(total);
    
    for (struct revenue * revenue = firstRevenueMovement; revenue!=0; revenue=revenue->next)
    {
        json_array_append(array, createRevenueArray(revenue));
    }
    
    int i  = json_object_set(json_revenue, "total", json_total);
    
    int j  = json_object_set(json_revenue, "revenue", array);
    
    if (i == -1 || j == -1)
    {
        printf("errore non è possibile scrivere il file");
    }
    
    json_dump_file(json_revenue, strcat(save_path, "/revenue.json"), JSON_INDENT(3));
    
}

static int send_metric(struct mg_connection *conn)
{
	static const char *metric_types[] = {
		"gauge", "meter", "counter", "histogram", "timer", "internal"
	};
	static const char *expire_status[] = {
		"disabled", "inactive", "active"
	};

	struct brubeck_server *server = conn->server_param;
	struct brubeck_metric *metric = safe_lookup_metric(
			server, conn->uri + strlen("/metric/"));

	if (metric) {
		json_t *mj = json_pack("{s:s, s:s, s:i, s:s}",
			"key", metric->key,
			"type", metric_types[metric->type],
#if METRIC_SHARD_SPECIFIER
			"shard", (int)metric->shard,
#else
			"shard", 0,
#endif
			"expire", expire_status[metric->expire]
		);

		send_headers(conn);
		json_dump_callback(mj, &dump_json, (void *)conn,
				JSON_INDENT(4) | JSON_PRESERVE_ORDER);
		json_decref(mj);
		return MG_TRUE;
	}

	return MG_FALSE;
}

char *janus_serial_query_session(janus_plugin_session *handle) {
	if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized)) {
		return NULL;
	}	
	janus_serial_session *session = (janus_serial_session *)handle->plugin_handle;
	if(!session) {
		JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");
		return NULL;
	}
	/* In the echo test, every session is the same: we just provide some configure info */
	json_t *info = json_object();
	json_object_set_new(info, "audio_active", json_string(session->audio_active ? "true" : "false"));
	json_object_set_new(info, "video_active", json_string(session->video_active ? "true" : "false"));
	json_object_set_new(info, "bitrate", json_integer(session->bitrate));
	if(session->arc || session->vrc) {
		json_t *recording = json_object();
		if(session->arc && session->arc->filename)
			json_object_set_new(recording, "audio", json_string(session->arc->filename));
		if(session->vrc && session->vrc->filename)
			json_object_set_new(recording, "video", json_string(session->vrc->filename));
		json_object_set_new(info, "recording", recording);
	}
	json_object_set_new(info, "slowlink_count", json_integer(session->slowlink_count));
	json_object_set_new(info, "destroyed", json_integer(session->destroyed));
	char *info_text = json_dumps(info, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
	json_decref(info);
	return info_text;
}