C++ (Cpp) SOL_BUFFER_DECLARE_STATIC 예제들

예제 #1

파일: simple-client.c 프로젝트: Achint08/soletta

static bool
reply_cb(struct sol_coap_server *server, struct sol_coap_packet *req,
    const struct sol_network_link_addr *cliaddr, void *data)
{
    struct sol_str_slice *path = data;
    static int count;
    struct sol_buffer *buf;
    size_t offset;

    SOL_BUFFER_DECLARE_STATIC(addr, SOL_INET_ADDR_STRLEN);

    if (!req || !cliaddr) //timeout
        return false;

    sol_network_link_addr_to_str(cliaddr, &addr);

    SOL_INF("Got response from %.*s\n", SOL_STR_SLICE_PRINT(sol_buffer_get_slice(&addr)));

    sol_coap_packet_get_payload(req, &buf, &offset);
    SOL_INF("Payload: %.*s\n", (int)(buf->used - offset),
        (char *)sol_buffer_at(buf, offset));

    if (++count == 10)
        disable_observing(req, server, path, cliaddr);

    return true;
}

예제 #2

파일: connect-paired.c 프로젝트: amandawrcoelho/soletta

static void
on_disconnect(void *user_data, struct sol_bt_conn *conn)
{
    SOL_BUFFER_DECLARE_STATIC(str, SOL_BLUETOOTH_ADDR_STRLEN);

    sol_network_link_addr_to_str(sol_bt_conn_get_addr(conn), &str);

    SOL_INF("Disconnected from device %.*s, trying again", (int)str.used, (char *)str.data);
}

예제 #3

파일: connect-paired.c 프로젝트: amandawrcoelho/soletta

static bool
on_connect(void *user_data, struct sol_bt_conn *conn)
{
    SOL_BUFFER_DECLARE_STATIC(str, SOL_BLUETOOTH_ADDR_STRLEN);

    sol_network_link_addr_to_str(sol_bt_conn_get_addr(conn), &str);

    SOL_INF("Connected to device %.*s", (int)str.used, (char *)str.data);

    return true;
}

예제 #4

파일: simple-server.c 프로젝트: Achint08/soletta

static int
light_resource_to_rep(const struct sol_coap_resource *resource,
    bool state, struct sol_buffer *buf)
{
    SOL_BUFFER_DECLARE_STATIC(buffer, 64);
    int r;

    r = sol_coap_uri_path_to_buf(resource->path, &buffer, 0, NULL);
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf,
        OC_CORE_ELEM_JSON_START, (char *)sol_buffer_steal(&buffer, NULL));
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf,
        OC_CORE_PROP_JSON_NUMBER, "power", 100);
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf, OC_CORE_JSON_SEPARATOR);
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf,
        OC_CORE_PROP_JSON_STRING, "name", "Soletta LAMP!");
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf, OC_CORE_JSON_SEPARATOR);
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf,
        OC_CORE_PROP_JSON_BOOLEAN, "state", state ? "true" : "false" );
    SOL_INT_CHECK(r, < 0, r);

    r = sol_buffer_append_printf(buf, OC_CORE_ELEM_JSON_END);
    SOL_INT_CHECK(r, < 0, r);

    return 0;
}

예제 #5

파일: test-util.c 프로젝트: amandawrcoelho/soletta

static void
test_uuid_functions(void)
{
    SOL_BUFFER_DECLARE_STATIC(buf, 37);
    struct sol_str_slice
        uuid_uh = SOL_STR_SLICE_LITERAL("9FD636DD-FF84-4075-8AE7-D55F2F7BA190"),
        uuid_lh = SOL_STR_SLICE_LITERAL("9fd636dd-ff84-4075-8ae7-d55f2f7ba190"),
        uuid_u = SOL_STR_SLICE_LITERAL("9FD636DDFF8440758AE7D55F2F7BA190"),
        uuid_l = SOL_STR_SLICE_LITERAL("9fd636ddff8440758ae7d55f2f7ba190"),
        uuid_invalid = SOL_STR_SLICE_LITERAL("9fd6-6dd1ff841407518ae71d5-f2f7ba190"),
        uuid_invalid2 = SOL_STR_SLICE_LITERAL("9fd636ddff8440758ae7d55-2f7ba190"),
        uuid_invalid3 = SOL_STR_SLICE_LITERAL("9fd636ddff8440758ae7d552f7ba190");
    const uint8_t uuid_bytes[16] = { 0x9F, 0xD6, 0x36, 0xDD, 0xFF, 0x84, 0x40,
                                     0x75, 0x8A, 0xE7, 0xD5, 0x5F, 0x2F, 0x7B,
                                     0xA1, 0x90 };

    //UUID string to bytes
    ASSERT_INT_EQ(sol_util_uuid_bytes_from_string(uuid_uh, &buf), 0);
    ASSERT_INT_EQ(buf.used, sizeof(uuid_bytes));
    ASSERT_INT_EQ(memcmp(buf.data, uuid_bytes, sizeof(uuid_bytes)), 0);

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_bytes_from_string(uuid_lh, &buf), 0);
    ASSERT_INT_EQ(buf.used, sizeof(uuid_bytes));
    ASSERT_INT_EQ(memcmp(buf.data, uuid_bytes, sizeof(uuid_bytes)), 0);

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_bytes_from_string(uuid_u, &buf), 0);
    ASSERT_INT_EQ(buf.used, sizeof(uuid_bytes));
    ASSERT_INT_EQ(memcmp(buf.data, uuid_bytes, sizeof(uuid_bytes)), 0);

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_bytes_from_string(uuid_l, &buf), 0);
    ASSERT_INT_EQ(buf.used, sizeof(uuid_bytes));
    ASSERT_INT_EQ(memcmp(buf.data, uuid_bytes, sizeof(uuid_bytes)), 0);

    //UUID bytes to string
    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_string_from_bytes(true, true, uuid_bytes,
        &buf), 0);
    ASSERT(sol_str_slice_str_eq(uuid_uh, buf.data));

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_string_from_bytes(true, false, uuid_bytes,
        &buf), 0);
    ASSERT(sol_str_slice_str_eq(uuid_u, buf.data));

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_string_from_bytes(false, true, uuid_bytes,
        &buf), 0);
    ASSERT(sol_str_slice_str_eq(uuid_lh, buf.data));

    buf.used = 0;
    ASSERT_INT_EQ(sol_util_uuid_string_from_bytes(false, false, uuid_bytes,
        &buf), 0);
    ASSERT(sol_str_slice_str_eq(uuid_l, buf.data));

    //UUID validation
    ASSERT(sol_util_uuid_str_is_valid(uuid_uh));
    ASSERT(sol_util_uuid_str_is_valid(uuid_lh));
    ASSERT(sol_util_uuid_str_is_valid(uuid_u));
    ASSERT(sol_util_uuid_str_is_valid(uuid_l));

    ASSERT(!sol_util_uuid_str_is_valid(uuid_invalid));
    ASSERT(!sol_util_uuid_str_is_valid(uuid_invalid2));
    ASSERT(!sol_util_uuid_str_is_valid(uuid_invalid3));
}