sol-types.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 <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <sol-common-buildopts.h>
#include <sol-vector.h>

#ifdef __cplusplus
extern "C" {
#endif

#define _SOL_TYPE_CHECK(type, var, value) \
    ({ type var = (value); var; })

#define SOL_TYPE_CHECK(type, value) \
    _SOL_TYPE_CHECK(type, __dummy_ ## __COUNTER__, (value))

#ifndef SSIZE_MAX

#define SSIZE_MAX LONG_MAX
#endif

#ifndef SSIZE_MIN

#define SSIZE_MIN LONG_MIN
#endif

typedef struct sol_direction_vector {
    double x; 
    double y; 
    double z; 
    double min; 
    double max; 
} sol_direction_vector;

bool sol_direction_vector_eq(const struct sol_direction_vector *var0, const struct sol_direction_vector *var1);

typedef struct sol_location {
    double lat; 
    double lon; 
    double alt; 
} sol_location;

typedef struct sol_rgb {
    uint32_t red; 
    uint32_t green; 
    uint32_t blue; 
    uint32_t red_max; 
    uint32_t green_max; 
    uint32_t blue_max; 
} sol_rgb;

bool sol_rgb_eq(const struct sol_rgb *var0, const struct sol_rgb *var1);

int sol_rgb_set_max(struct sol_rgb *color, uint32_t max_value);

typedef struct sol_drange {
    double val; 
    double min; 
    double max; 
    double step; 
} sol_drange;

typedef struct sol_drange_spec {
    double min; 
    double max; 
    double step; 
} sol_drange_spec;

#define SOL_DRANGE_INIT() \
    { \
        .val = 0, \
        .min = -DBL_MAX, \
        .max = DBL_MAX, \
        .step = DBL_MIN \
    }

#define SOL_DRANGE_INIT_VALUE(value_) \
    { \
        .val = value_, \
        .min = -DBL_MAX, \
        .max = DBL_MAX, \
        .step = DBL_MIN \
    }

int sol_drange_add(const struct sol_drange *var0, const struct sol_drange *var1, struct sol_drange *result);

int sol_drange_div(const struct sol_drange *var0, const struct sol_drange *var1, struct sol_drange *result);

int sol_drange_mod(const struct sol_drange *var0, const struct sol_drange *var1, struct sol_drange *result);

int sol_drange_mul(const struct sol_drange *var0, const struct sol_drange *var1, struct sol_drange *result);

int sol_drange_sub(const struct sol_drange *var0, const struct sol_drange *var1, struct sol_drange *result);


bool sol_drange_eq(const struct sol_drange *var0, const struct sol_drange *var1);

int sol_drange_compose(const struct sol_drange_spec *spec, double value, struct sol_drange *result);

typedef struct sol_irange {
    int32_t val; 
    int32_t min; 
    int32_t max; 
    int32_t step; 
} sol_irange;

typedef struct sol_irange_spec {
    int32_t min; 
    int32_t max; 
    int32_t step; 
} sol_irange_spec;

#define SOL_IRANGE_INIT() \
    { \
        .val = 0, \
        .min = INT32_MIN, \
        .max = INT32_MAX, \
        .step = 1 \
    }

#define SOL_IRANGE_INIT_VALUE(value_) \
    { \
        .val = value_, \
        .min = INT32_MIN, \
        .max = INT32_MAX, \
        .step = 1 \
    }

int sol_irange_add(const struct sol_irange *var0, const struct sol_irange *var1, struct sol_irange *result);

int sol_irange_div(const struct sol_irange *var0, const struct sol_irange *var1, struct sol_irange *result);

int sol_irange_mod(const struct sol_irange *var0, const struct sol_irange *var1, struct sol_irange *result);

int sol_irange_mul(const struct sol_irange *var0, const struct sol_irange *var1, struct sol_irange *result);

int sol_irange_sub(const struct sol_irange *var0, const struct sol_irange *var1, struct sol_irange *result);

bool sol_irange_eq(const struct sol_irange *var0, const struct sol_irange *var1);

int sol_irange_compose(const struct sol_irange_spec *spec, int32_t value, struct sol_irange *result);

struct sol_blob_type;

typedef struct sol_blob {
    const struct sol_blob_type *type; 
    struct sol_blob *parent; 
    void *mem; 
    size_t size; 
    uint16_t refcnt; 
} sol_blob;

typedef struct sol_blob_type {
#ifndef SOL_NO_API_VERSION
#define SOL_BLOB_TYPE_API_VERSION (1)
    uint16_t api_version; 
    uint16_t sub_api; 
#endif
    void (*free)(struct sol_blob *blob); 
} sol_blob_type;

extern const struct sol_blob_type SOL_BLOB_TYPE_DEFAULT;

extern const struct sol_blob_type SOL_BLOB_TYPE_NO_FREE_DATA;

extern const struct sol_blob_type SOL_BLOB_TYPE_NO_FREE;

struct sol_blob *sol_blob_new(const struct sol_blob_type *type, struct sol_blob *parent, const void *mem, size_t size);

int sol_blob_setup(struct sol_blob *blob, const struct sol_blob_type *type, const void *mem, size_t size);

struct sol_blob *sol_blob_ref(struct sol_blob *blob);

void sol_blob_unref(struct sol_blob *blob);

void sol_blob_set_parent(struct sol_blob *blob, struct sol_blob *parent);

static inline struct sol_blob *
sol_blob_new_dup(const void *mem, size_t size)
{
    struct sol_blob *blob;
    void *v;

    if (!mem)
        return NULL;

    v = malloc(size);
    if (!v)
        return NULL;

    memcpy(v, mem, size);

    blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, v, size);
    if (!blob)
        goto fail;

    return blob;

fail:
    free(v);
    return NULL;
}

#define SOL_BLOB_NEW_DUP(mem_) sol_blob_new_dup((&mem_), sizeof(mem_))

static inline struct sol_blob *
sol_blob_new_dup_str(const char *str)
{
    if (!str)
        return NULL;

    return sol_blob_new_dup(str, strlen(str) + 1);
}

typedef struct sol_key_value {
    const char *key; 
    const char *value; 
} sol_key_value;

#ifdef __cplusplus
}
#endif