sol-oic.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <sol-common-buildopts.h>
#include <sol-vector.h>
#include <sol-str-slice.h>
#include "sol-coap.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct sol_oic_platform_info {
#ifndef SOL_NO_API_VERSION
#define SOL_OIC_PLATFORM_INFO_API_VERSION (1)
    uint16_t api_version; 
#endif

    /* All fields are required by the spec.  Some of the fields are
     * obtained in runtime (such as system time, OS version), and are
     * not user-specifiable.
     */

    struct sol_str_slice platform_id;
    struct sol_str_slice manufacturer_name;
    struct sol_str_slice manufacturer_url;
    struct sol_str_slice model_number;
    struct sol_str_slice manufacture_date;
    struct sol_str_slice platform_version;
    struct sol_str_slice hardware_version;
    struct sol_str_slice firmware_version;
    struct sol_str_slice support_url;

    /* Read-only fields. */

    struct sol_str_slice os_version;
    struct sol_str_slice system_time;
} sol_oic_platform_info;

enum sol_oic_resource_flag {
    SOL_OIC_FLAG_NONE = 0,
    SOL_OIC_FLAG_DISCOVERABLE = 1 << 0,
    SOL_OIC_FLAG_OBSERVABLE = 1 << 1,
    SOL_OIC_FLAG_ACTIVE = 1 << 2,
    SOL_OIC_FLAG_SLOW = 1 << 3,
    SOL_OIC_FLAG_SECURE = 1 << 4,
    SOL_OIC_FLAG_DISCOVERABLE_EXPLICIT = 1 << 5,
};

typedef struct sol_oic_device_info {
#ifndef SOL_NO_API_VERSION
#define SOL_OIC_DEVICE_INFO_API_VERSION (1)
    uint16_t api_version; 
#endif

    struct sol_str_slice device_name;
    struct sol_str_slice spec_version;
    struct sol_str_slice device_id;
    struct sol_str_slice data_model_version;
} sol_oic_device_info;

enum sol_oic_repr_type {
    SOL_OIC_REPR_TYPE_UINT, 
    SOL_OIC_REPR_TYPE_INT, 
    SOL_OIC_REPR_TYPE_SIMPLE, 
    SOL_OIC_REPR_TYPE_TEXT_STRING, 
    SOL_OIC_REPR_TYPE_BYTE_STRING, 
    SOL_OIC_REPR_TYPE_HALF_FLOAT, 
    SOL_OIC_REPR_TYPE_FLOAT, 
    SOL_OIC_REPR_TYPE_DOUBLE, 
    SOL_OIC_REPR_TYPE_BOOL, 
    SOL_OIC_REPR_TYPE_UNSUPPORTED 
};

typedef struct sol_oic_repr_field {
    enum sol_oic_repr_type type;
    const char *key;
    union {
        uint64_t v_uint;
        int64_t v_int;
        uint8_t v_simple;
        struct sol_str_slice v_slice;
        float v_float;
        double v_double;
        void *v_voidptr;
        bool v_boolean;
    };
} sol_oic_repr_field;

#define SOL_OIC_REPR_FIELD(key_, type_, ...) \
    (struct sol_oic_repr_field){.type = (type_), .key = (key_), { __VA_ARGS__ } }

#define SOL_OIC_REPR_UINT(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_UINT, .v_uint = (value_))

#define SOL_OIC_REPR_INT(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_INT, .v_int = (value_))

#define SOL_OIC_REPR_BOOL(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_BOOL, .v_boolean = !!(value_))

#define SOL_OIC_REPR_SIMPLE(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_SIMPLE, .v_simple = (value_))

#define SOL_OIC_REPR_TEXT_STRING(key_, value_, len_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_TEXT_STRING, .v_slice = SOL_STR_SLICE_STR((value_), (len_)))

#define SOL_OIC_REPR_BYTE_STRING(key_, value_, len_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_BYTE_STRING, .v_slice = SOL_STR_SLICE_STR((value_), (len_)))

#define SOL_OIC_REPR_HALF_FLOAT(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_HALF_FLOAT, .v_voidptr = (void *)(value_))

#define SOL_OIC_REPR_FLOAT(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_FLOAT, .v_float = (value_))

#define SOL_OIC_REPR_DOUBLE(key_, value_) \
    SOL_OIC_REPR_FIELD(key_, SOL_OIC_REPR_TYPE_DOUBLE, .v_double = (value_))

struct sol_oic_map_writer;
typedef struct sol_oic_map_writer sol_oic_map_writer;

enum sol_oic_map_type {
    SOL_OIC_MAP_NO_CONTENT,
    SOL_OIC_MAP_CONTENT,
};

typedef struct sol_oic_map_reader {
    const void *parser;
    const void *ptr;
    const uint32_t remaining;
    const uint16_t extra;
    const uint8_t type;
    const uint8_t flags;
} sol_oic_map_reader;

struct sol_oic_request;
typedef struct sol_oic_request sol_oic_request;

struct sol_oic_response;
typedef struct sol_oic_response sol_oic_response;

enum sol_oic_map_loop_reason {
    SOL_OIC_MAP_LOOP_OK = 0,
    SOL_OIC_MAP_LOOP_ERROR
};

enum sol_oic_map_loop_reason sol_oic_map_loop_init(const struct sol_oic_map_reader *map, struct sol_oic_map_reader *iterator, struct sol_oic_repr_field *repr);

bool sol_oic_map_loop_next(struct sol_oic_repr_field *repr, struct sol_oic_map_reader *iterator, enum sol_oic_map_loop_reason *reason);

int sol_oic_map_append(struct sol_oic_map_writer *oic_map_writer, struct sol_oic_repr_field *repr);

int sol_oic_map_set_type(struct sol_oic_map_writer *oic_map_writer, enum sol_oic_map_type type);

int sol_oic_map_get_type(struct sol_oic_map_writer *oic_map_writer, enum sol_oic_map_type *type);

void sol_oic_repr_field_clear(struct sol_oic_repr_field *field);

#define SOL_OIC_MAP_LOOP(map_, current_, iterator_, end_reason_) \
    for (end_reason_ = sol_oic_map_loop_init(map_, iterator_, current_); \
        end_reason_ == SOL_OIC_MAP_LOOP_OK && \
        sol_oic_map_loop_next(current_, iterator_, &end_reason_);)

#ifdef SOL_LOG_ENABLED
void sol_oic_payload_debug(struct sol_coap_packet *pkt);
#else
static inline void
sol_oic_payload_debug(struct sol_coap_packet *pkt)
{
}
#endif

#ifdef __cplusplus
}
#endif