Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_factory.h
|
/**
* File: data_writer_factory.h
* Author: AWTK Develop Team
* Brief: data writer factory
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_WRITER_FACTORY_H
#define TK_DATA_WRITER_FACTORY_H
#include "tkc/darray.h"
#include "tkc/data_writer.h"
BEGIN_C_DECLS
typedef data_writer_t* (*data_writer_create_t)(const char* args);
/**
* @class data_writer_factory_t
* data writer工厂。
*
*/
typedef struct _data_writer_factory_t {
/*private*/
darray_t creators;
} data_writer_factory_t;
/**
* @method data_writer_factory
* 获取缺省的data writer工厂对象。
* @annotation ["constructor"]
* @return {data_writer_factory_t*} 返回data writer工厂对象。
*/
data_writer_factory_t* data_writer_factory(void);
/**
* @method data_writer_factory_set
* 设置缺省的data writer工厂对象。
* @param {data_writer_factory_t*} factory data writer工厂对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_writer_factory_set(data_writer_factory_t* factory);
/**
* @method data_writer_factory_create
* 创建data writer工厂对象。
* @annotation ["constructor"]
*
* @return {data_writer_factory_t*} 返回data writer工厂对象。
*/
data_writer_factory_t* data_writer_factory_create(void);
/**
* @method data_writer_factory_register
* 注册data writer创建函数。
* @param {data_writer_factory_t*} factory writer工厂对象。
* @param {const char*} protocol 协议(如file)。
* @param {data_writer_create_t} create data writer创建函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_writer_factory_register(data_writer_factory_t* factory, const char* protocol,
data_writer_create_t create);
/**
* @method data_writer_factory_create_writer
* 创建指定类型的data writer对象。
* @annotation ["constructor"]
* @param {data_writer_factory_t*} factory data writer工厂对象。
* @param {const char*} url URL。
*
* @return {data_writer_t*} 返回data writer对象。
*/
data_writer_t* data_writer_factory_create_writer(data_writer_factory_t* factory, const char* url);
/**
* @method data_writer_factory_destroy
* 析构并释放data writer工厂对象。
* @param {data_writer_factory_t*} factory data writer工厂对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_writer_factory_destroy(data_writer_factory_t* factory);
END_C_DECLS
#endif /*TK_DATA_WRITER_FACTORY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/buffer.h
|
/**
* File: buffer.h
* Author: AWTK Develop Team
* Brief: buffer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-15 Li XianJing <[email protected]> created
*
*/
#ifndef TK_BUFFER_H
#define TK_BUFFER_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class wbuffer_t
* Write Buffer。用于数据打包。
*
* 示例：
*
* ```c
* uint8_t buff[128];
* wbuffer_t wbuffer;
* rbuffer_t rbuffer;
* const char* str = NULL;
* wbuffer_init(&wbuffer, buff, sizeof(buff));
*
* wbuffer_write_string(&wbuffer, "hello awtk");
*
* rbuffer_init(&rbuffer, wbuffer.data, wbuffer.cursor);
* rbuffer_read_string(&rbuffer, &str);
* ```
*
* ```c
* wbuffer_t wbuffer;
* wbuffer_init_extendable(&wbuffer);
*
* wbuffer_write_string(&wbuffer, "hello awtk");
*
* wbuffer_deinit(&wbuffer);
* ```
* > 如果初始化为extendable，则最后需要调用wbuffer\_deinit释放资源。
*
*
*/
typedef struct _wbuffer_t {
/**
* @property {uint8_t*} data
* @annotation ["readable"]
* 数据缓冲区。用于保存写入的数据。
*/
uint8_t* data;
/**
* @property {uint32_t} cursor
* @annotation ["readable"]
* 当前写入位置。
*/
uint32_t cursor;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 数据缓冲区最大容量。
*/
uint32_t capacity;
/**
* @property {bool_t} extendable
* @annotation ["readable"]
* 容量不够时是否支持自动扩展。
*/
bool_t extendable;
} wbuffer_t;
/**
* @method wbuffer_init
* 初始wbuffer对象。
* @annotation ["constructor"]
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {void*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {wbuffer_t*} wbuffer对象本身。
*/
wbuffer_t* wbuffer_init(wbuffer_t* wbuffer, void* data, uint32_t capacity);
/**
* @method wbuffer_init_extendable
* 初始化可自动扩展的wbuffer对象。使用完成后需要调用wbuffer\_deinit释放资源。
*
* @annotation ["constructor"]
* @param {wbuffer_t*} wbuffer wbuffer对象。
*
* @return {wbuffer_t*} wbuffer对象本身。
*/
wbuffer_t* wbuffer_init_extendable(wbuffer_t* wbuffer);
/**
* @method wbuffer_create
* 创建wbuffer对象。
* @annotation ["constructor"]
* @param {void*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {wbuffer_t*} wbuffer对象本身。
*/
wbuffer_t* wbuffer_create(void* data, uint32_t capacity);
/**
* @method wbuffer_create_extendable
* 创建可自动扩展的wbuffer对象。
*
* @annotation ["constructor"]
*
* @return {wbuffer_t*} wbuffer对象本身。
*/
wbuffer_t* wbuffer_create_extendable(void);
/**
* @method wbuffer_rewind
* 重置当前写入位置。
* @annotation ["constructor"]
* @param {wbuffer_t*} wbuffer wbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_rewind(wbuffer_t* wbuffer);
/**
* @method wbuffer_extend_capacity
* 扩展缓冲区至指定的大小。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_extend_capacity(wbuffer_t* wbuffer, uint32_t capacity);
/**
* @method wbuffer_deinit
* 释放资源。
* @param {wbuffer_t*} wbuffer wbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_deinit(wbuffer_t* wbuffer);
/**
* @method wbuffer_destroy
* 销毁wbuffer对象。
* @param {wbuffer_t*} wbuffer wbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_destroy(wbuffer_t* wbuffer);
/**
* @method wbuffer_skip
* 跳过指定的长度。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {int32_t} delta 跳过的偏移量，正数往前负数往回跳。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_skip(wbuffer_t* wbuffer, int32_t delta);
/**
* @method wbuffer_write_int8
* 写入int8数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {int8_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_int8(wbuffer_t* wbuffer, int8_t value);
/**
* @method wbuffer_write_int16
* 写入int16数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {int16_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_int16(wbuffer_t* wbuffer, int16_t value);
/**
* @method wbuffer_write_int32
* 写入int32数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {int32_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_int32(wbuffer_t* wbuffer, int32_t value);
/**
* @method wbuffer_write_int64
* 写入int64数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {int64_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_int64(wbuffer_t* wbuffer, int64_t value);
/**
* @method wbuffer_write_uint8
* 写入uint8数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint8_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_uint8(wbuffer_t* wbuffer, uint8_t value);
/**
* @method wbuffer_write_uint16
* 写入uint16数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint16_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_uint16(wbuffer_t* wbuffer, uint16_t value);
/**
* @method wbuffer_write_uint32
* 写入uint32数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint32_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_uint32(wbuffer_t* wbuffer, uint32_t value);
/**
* @method wbuffer_write_uint64
* 写入uint64数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint64_t} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_uint64(wbuffer_t* wbuffer, uint64_t value);
/**
* @method wbuffer_write_float
* 写入float数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {float} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_float(wbuffer_t* wbuffer, float value);
/**
* @method wbuffer_write_double
* 写入double数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {double} value 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_double(wbuffer_t* wbuffer, double value);
/**
* @method wbuffer_write_binary
* 写入指定长度的二进制数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {const void*} data 要写入的数据。
* @param {uint32_t} size 要写入的数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_binary(wbuffer_t* wbuffer, const void* data, uint32_t size);
/**
* @method wbuffer_write_value
* 写入value数据。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {const value_t*} v 要写入的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_value(wbuffer_t* wbuffer, const value_t* v);
/**
* @method wbuffer_write_string
* 写入字符串。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {const char*} data 要写入的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wbuffer_write_string(wbuffer_t* wbuffer, const char* data);
/**
* @method wbuffer_has_room
* 是否还有空间。
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {uint32_t} size 空间大小。
*
* @return {bool_t} 返回FALSE表示无，否则表示有。
*/
bool_t wbuffer_has_room(wbuffer_t* wbuffer, uint32_t size);
/**
* @class rbuffer_t
* Read Buffer。用于数据解包。
*
* 示例：
*
* ```c
* uint8_t buff[128];
* wbuffer_t wbuffer;
* rbuffer_t rbuffer;
* const char* str = NULL;
* wbuffer_init(&wbuffer, buff, sizeof(buff));
*
* wbuffer_write_string(&wbuffer, "hello awtk");
*
* rbuffer_init(&rbuffer, wbuffer.data, wbuffer.cursor);
* rbuffer_read_string(&rbuffer, &str);
* ```
*/
typedef struct _rbuffer_t {
/**
* @property {const uint8_t*} data
* @annotation ["readable"]
* 数据缓冲区。
*/
const uint8_t* data;
/**
* @property {uint32_t} cursor
* @annotation ["readable"]
* 当前读取位置。
*/
uint32_t cursor;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 缓存区的容量。
*/
uint32_t capacity;
} rbuffer_t;
/**
* @method rbuffer_init
* 初始rbuffer对象。
* @annotation ["constructor"]
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {const void*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {rbuffer_t*} rbuffer对象本身。
*/
rbuffer_t* rbuffer_init(rbuffer_t* rbuffer, const void* data, uint32_t capacity);
/**
* @method rbuffer_create
* 创建rbuffer对象。
* @annotation ["constructor"]
* @param {const void*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {rbuffer_t*} rbuffer对象本身。
*/
rbuffer_t* rbuffer_create(const void* data, uint32_t capacity);
/**
* @method rbuffer_has_more
* 判断是否还有数据可读。
* @param {rbuffer_t*} rbuffer rbuffer对象。
*
* @return {bool_t} 返回TRUE表示还有数据可读，否则表示无数据可读。
*/
bool_t rbuffer_has_more(rbuffer_t* rbuffer);
/**
* @method rbuffer_rewind
* 重置当前读取位置。
* @annotation ["constructor"]
* @param {rbuffer_t*} rbuffer rbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_rewind(rbuffer_t* rbuffer);
/**
* @method rbuffer_skip
* 跳过指定的长度。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {int32_t} offset 跳过的偏移量，正数往前负数往回跳。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_skip(rbuffer_t* rbuffer, int32_t offset);
/**
* @method rbuffer_read_uint8
* 读取uint8数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint8_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_uint8(rbuffer_t* rbuffer, uint8_t* value);
/**
* @method rbuffer_read_uint16
* 读取uint16数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint16_t*} value 读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_uint16(rbuffer_t* rbuffer, uint16_t* value);
/**
* @method rbuffer_read_uint32
* 读取uint32数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint32_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_uint32(rbuffer_t* rbuffer, uint32_t* value);
/**
* @method rbuffer_read_uint64
* 读取uint64数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint64_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_uint64(rbuffer_t* rbuffer, uint64_t* value);
/**
* @method rbuffer_read_int8
* 读取int8数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {int8_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_int8(rbuffer_t* rbuffer, int8_t* value);
/**
* @method rbuffer_read_int16
* 读取int16数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {int16_t*} value 读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_int16(rbuffer_t* rbuffer, int16_t* value);
/**
* @method rbuffer_read_int32
* 读取int32数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {int32_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_int32(rbuffer_t* rbuffer, int32_t* value);
/**
* @method rbuffer_read_int64
* 读取int64数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {int64_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_int64(rbuffer_t* rbuffer, int64_t* value);
/**
* @method rbuffer_read_float
* 读取float数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {float*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_float(rbuffer_t* rbuffer, float* value);
/**
* @method rbuffer_read_double
* 读取double数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {double*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_double(rbuffer_t* rbuffer, double* value);
/**
* @method rbuffer_read_binary
* 读取指定长度的二进制数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {void*} data 返回读取的数据。
* @param {uint32_t} size 读取的数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_binary(rbuffer_t* rbuffer, void* data, uint32_t size);
/**
* @method rbuffer_read_value
* 读取value数据。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {value_t*} v 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_value(rbuffer_t* rbuffer, value_t* v);
/**
* @method rbuffer_read_string
* 读取字符串。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {const char**} str 返回字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_read_string(rbuffer_t* rbuffer, const char** str);
/**
* @method rbuffer_peek_uint8
* 读取uint8数据，但不改变cursor的位置。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint8_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_peek_uint8(rbuffer_t* rbuffer, uint8_t* value);
/**
* @method rbuffer_peek_uint16
* 读取uint16数据，但不改变cursor的位置。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint16_t*} value 返回读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_peek_uint16(rbuffer_t* rbuffer, uint16_t* value);
/**
* @method rbuffer_peek_uint32
* 读取uint32数据，但不改变cursor的位置。
* @param {rbuffer_t*} rbuffer rbuffer对象。
* @param {uint32_t*} value 读取的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_peek_uint32(rbuffer_t* rbuffer, uint32_t* value);
/**
* @method rbuffer_deinit
* 释放rbuffer资源。
* @param {rbuffer_t*} rbuffer rbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_deinit(rbuffer_t* rbuffer);
/**
* @method rbuffer_destroy
* 销毁rbuffer对象。
* @param {rbuffer_t*} rbuffer rbuffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rbuffer_destroy(rbuffer_t* rbuffer);
#define load_uint32(p, v) \
(v) = (p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24)); \
p += 4;
#define load_int32(p, v) load_uint32(p, v)
#define save_uint32(p, v) \
p[0] = (v & 0xff); \
p[1] = (v >> 8) & 0xff; \
p[2] = (v >> 16) & 0xff; \
p[3] = (v >> 24) & 0xff; \
p += 4;
#define save_int32(p, v) save_uint32(p, v)
#define load_uint16(p, v) \
(v) = (p[0] | (p[1] << 8)); \
p += 2;
#define save_uint16(p, v) \
p[0] = (v & 0xff); \
p[1] = (v >> 8) & 0xff; \
p += 2;
#define load_uint8(p, v) \
(v) = p[0]; \
p += 1;
#define save_uint8(p, v) \
p[0] = v; \
p += 1;
END_C_DECLS
#endif /*TK_BUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_thread.h
|
/**
* File: action_thread.h
* Author: AWTK Develop Team
* Brief: action_thread
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ACTION_THREAD_H
#define TK_ACTION_THREAD_H
#include "tkc/thread.h"
#include "tkc/waitable_action_queue.h"
BEGIN_C_DECLS
struct _action_thread_t;
typedef struct _action_thread_t action_thread_t;
typedef ret_t (*action_thread_on_idle_t)(void* ctx, action_thread_t* thread);
typedef ret_t (*action_thread_on_quit_t)(void* ctx, action_thread_t* thread);
/**
* @class action_thread_t
* 执行action的线程。
*
*> 每个线程都有一个action queue，可以是共享的queue，也可以是私有的queue。
*/
struct _action_thread_t {
/**
* @property {tk_thread_t*} thread
* @annotation ["readable"]
* 线程对象。
*/
tk_thread_t* thread;
/**
* @property {waitable_action_queue_t*} queue
* @annotation ["readable"]
* action queue。
*/
waitable_action_queue_t* queue;
/**
* @property {uint32_t} executed_actions_nr
* @annotation ["readable"]
* 已经执行action的个数。
*/
uint32_t executed_actions_nr;
/*private*/
/*请求退出*/
bool_t quit;
/*已经退出*/
bool_t quited;
/*是否是共享的queue*/
bool_t is_shared_queue;
void* on_idle_ctx;
void* on_quit_ctx;
action_thread_on_idle_t on_idle;
action_thread_on_quit_t on_quit;
};
/**
* @method action_thread_create
* @annotation ["constructor"]
* 创建action_thread对象。
*
* @return {action_thread_t*} action_thread对象。
*/
action_thread_t* action_thread_create(void);
/**
* @method action_thread_create_ex
* @annotation ["constructor"]
* 创建action_thread对象。
*
* @param {const char*} name 名称。
* @param {uint32_t} stack_size 栈的大小。
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {action_thread_t*} action_thread对象。
*/
action_thread_t* action_thread_create_ex(const char* name, uint32_t stack_size,
tk_thread_priority_t priority);
/**
* @method action_thread_create_with_queue
* @annotation ["constructor"]
* 创建action_thread对象。
*
* @param {waitable_action_queue_t*} queue queue对象。
*
* @return {action_thread_t*} action_thread对象。
*/
action_thread_t* action_thread_create_with_queue(waitable_action_queue_t* queue);
/**
* @method action_thread_create_with_queue_ex
* @annotation ["constructor"]
* 创建action_thread对象。
*
* @param {waitable_action_queue_t*} queue queue对象。
* @param {const char*} name 名称。
* @param {uint32_t} stack_size 栈的大小。
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {action_thread_t*} action_thread对象。
*/
action_thread_t* action_thread_create_with_queue_ex(waitable_action_queue_t* queue,
const char* name, uint32_t stack_size,
tk_thread_priority_t priority);
/**
* @method action_thread_exec
* 让线程执行action。
*
* @param {action_thread_t*} thread action_thread对象。
* @param {qaction_t*} action action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_exec(action_thread_t* thread, qaction_t* action);
/**
* @method action_thread_set_on_idle
* 设置空闲时的回调函数。
*
* @param {action_thread_t*} thread action_thread对象。
* @param {action_thread_on_idle_t} on_idle 空闲时的回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_set_on_idle(action_thread_t* thread, action_thread_on_idle_t on_idle,
void* ctx);
/**
* @method action_thread_set_on_quit
* 设置退出时的回调函数。
*
* @param {action_thread_t*} thread action_thread对象。
* @param {action_thread_on_quit_t} on_quit 退出时的回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_set_on_quit(action_thread_t* thread, action_thread_on_quit_t on_quit,
void* ctx);
/**
* @method action_thread_destroy
* 销毁。
*
* @param {action_thread_t*} thread action_thread对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_destroy(action_thread_t* thread);
END_C_DECLS
#endif /*TK_ACTION_THREAD_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/plugin_manager.h
|
/**
* File: plugin_manager.h
* Author: AWTK Develop Team
* Brief: plugin manager
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-10-12 Li XianJing <[email protected]> created
*
*/
#ifndef TK_PLUGIN_MANAGER_H
#define TK_PLUGIN_MANAGER_H
#include "tkc/dl.h"
#include "tkc/darray.h"
typedef ret_t (*plugin_get_init_func_name_t)(char func_name[TK_NAME_LEN + 1], const char* name);
typedef ret_t (*plugin_get_deinit_func_name_t)(char func_name[TK_NAME_LEN + 1], const char* name);
/**
* @class plugin_manager_t
* 插件管理器。
*/
typedef struct _plugin_manager_t {
/*private*/
char* path;
darray_t plugins;
plugin_get_init_func_name_t get_init;
plugin_get_deinit_func_name_t get_deinit;
} plugin_manager_t;
BEGIN_C_DECLS
/**
* @method plugin_manager_create
* 创建插件管理器。
*
* @param {const char*} path 插件所在的目录。
* @param {plugin_get_init_func_name_t} get_init 获取初始化函数的函数名。为NULL时使用"init"。
* @param {plugin_get_deinit_func_name_t} get_deinit 获取~初始化函数的函数名。为NULL时使用"deinit"。
*
* @return {plugin_manager_t*} 动态链接库对象。
*/
plugin_manager_t* plugin_manager_create(const char* path, plugin_get_init_func_name_t get_init,
plugin_get_deinit_func_name_t get_deinit);
/**
* @method plugin_manager_refresh
* 重新扫描目录中的插件，加载没有加载的插件。
*
* @param {plugin_manager_t*} plugin_manager plugin_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t plugin_manager_refresh(plugin_manager_t* plugin_manager);
/**
* @method plugin_manager_reload
* 卸载所有插件并重新加载。
*
* @param {plugin_manager_t*} plugin_manager plugin_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t plugin_manager_reload(plugin_manager_t* plugin_manager);
/**
* @method plugin_manager_dump
* 显示所有的插件。
*
* @param {plugin_manager_t*} plugin_manager plugin_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t plugin_manager_dump(plugin_manager_t* plugin_manager);
/**
* @method plugin_manager_exist
* 检查指定的插件是否存在。
*
* @param {plugin_manager_t*} plugin_manager plugin_manager对象。
* @param {const char*} lib_name 动态库的名称。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t plugin_manager_exist(plugin_manager_t* plugin_manager, const char* lib_name);
/**
* @method plugin_manager_destroy
* 卸载全部插件，并销毁插件管理器对象。
* @param {plugin_manager_t*} plugin_manager plugin_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t plugin_manager_destroy(plugin_manager_t* plugin_manager);
/*插件初始化的函数名*/
#define TK_PLUGIN_INIT "init"
/*插件~初始化的函数名*/
#define TK_PLUGIN_DEINIT "deinit"
END_C_DECLS
#endif /*TK_PLUGIN_MANAGER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_thread_pool.h
|
/**
* File: action_thread_pool.h
* Author: AWTK Develop Team
* Brief: action_thread_pool
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ACTION_THREAD_POOL_H
#define TK_ACTION_THREAD_POOL_H
#include "tkc/action_thread.h"
BEGIN_C_DECLS
/**
* @class action_thread_pool_t
* action线程池。
*/
typedef struct _action_thread_pool_t {
/**
* @property {uint32_t} max_thread_nr
* @annotation ["readable"]
* 最大线程数。
*/
uint32_t max_thread_nr;
/**
* @property {uint32_t} min_idle_nr
* @annotation ["readable"]
* 最小空闲线程数
*/
uint32_t min_idle_nr;
/**
* @property {uint32_t} stack_size
* @annotation ["readable"]
* 线程池中的线程栈大小
*/
uint32_t stack_size;
/**
* @property {tk_thread_priority_t} priority
* @annotation ["readable"]
* 线程池中的线程优先级
*/
tk_thread_priority_t priority;
/*private*/
tk_mutex_t* mutex;
waitable_action_queue_t* queue;
action_thread_t* threads[1];
} action_thread_pool_t;
/**
* @method action_thread_pool_create
* @annotation ["constructor"]
* 创建action_thread_pool对象。
*
* @param {uint16_t} max_thread_nr 最大线程数。
* @param {uint16_t} min_idle_nr 最小空闲线程数(必须大于0)。
*
* @return {action_thread_pool_t*} action_thread_pool对象。
*/
action_thread_pool_t* action_thread_pool_create(uint16_t max_thread_nr, uint16_t min_idle_nr);
/**
* @method action_thread_pool_create_ex
* @annotation ["constructor"]
* 创建action_thread_pool对象。
*
* @param {uint16_t} max_thread_nr 最大线程数。
* @param {uint16_t} min_idle_nr 最小空闲线程数(必须大于0)。
* @param {uint32_t} stack_size 栈的大小。
* @param {tk_thread_priority_t} priority 优先级
*
* @return {action_thread_pool_t*} action_thread_pool对象。
*/
action_thread_pool_t* action_thread_pool_create_ex(uint16_t max_thread_nr, uint16_t min_idle_nr,
uint32_t stack_size,
tk_thread_priority_t priority);
/**
* @method action_thread_pool_exec
* 执行action。
*
* @param {action_thread_pool_t*} thread_pool action_thread_pool对象。
* @param {qaction_t*} action action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_pool_exec(action_thread_pool_t* thread_pool, qaction_t* action);
/**
* @method action_thread_pool_destroy
* 销毁。
*
* @param {action_thread_pool_t*} thread_pool action_thread_pool对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_thread_pool_destroy(action_thread_pool_t* thread_pool);
END_C_DECLS
#endif /*TK_ACTION_THREAD_POOL_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem.h
|
/**
* File: mem.h
* Author: AWTK Develop Team
* Brief: memory manager functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TKMEM_MANAGER_H
#define TK_TKMEM_MANAGER_H
#include "tkc/types_def.h"
#ifdef WITH_WASM
void* realloc(void* ptr, size_t size);
#define TKMEM_ALLOC(size) malloc(size)
#define TKMEM_CALLOC(nmemb, size) calloc(nmemb, size)
#define TKMEM_REALLOC(p, size) realloc(p, size)
#define TKMEM_FREE(p) \
free((void*)p); \
p = NULL
#define TKMEM_ZALLOC(type) (type*)TKMEM_CALLOC(1, sizeof(type))
#define TKMEM_REALLOCT(type, p, n) (type*)realloc(p, (n) * sizeof(type))
#define TKMEM_ZALLOCN(type, n) (type*)calloc(n, sizeof(type))
#else
#include "tkc/platform.h"
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
typedef ret_t (*tk_mem_on_out_of_memory_t)(void* ctx, uint32_t tried_times, uint32_t need_size);
void* tk_calloc(uint32_t nmemb, uint32_t size, const char* func, uint32_t line);
void* tk_realloc(void* ptr, uint32_t size, const char* func, uint32_t line);
void* tk_alloc(uint32_t size, const char* func, uint32_t line);
void tk_free(void* ptr);
/**
* @class tk_mem_t
* @annotation ["fake"]
* 内存管理相关的宏和函数。
*
* 示例：
*
* ```c
* char* str = (char*)TKMEM_ALLOC(100);
* ...
* TKMEM_FREE(str);
* ```
*
* ```c
* char* str = (char*)TKMEM_ALLOC(100);
* ...
* str = (char*)TKMEM_REALLOC(str, 128);
* ...
* TKMEM_FREE(str);
* ```
*/
/**
* @method TKMEM_ALLOC
* @export tk_alloc
* 分配一块内存。
*
* @annotation ["macro"]
* @param {uint32_t} size 内存大小。
*
* @return {void*} 成功返回内存块首地址，失败返回NULL。
*/
#define TKMEM_ALLOC(size) tk_alloc(size, __FUNCTION__, __LINE__)
/**
* @method TKMEM_CALLOC
* @export tk_calloc
* 分配一块内存，并将内容清零。
*
* @annotation ["macro"]
* @param {uint32_t} nmemb 内存块数量。
* @param {uint32_t} size 每一块的大小。
*
* @return {void*} 成功返回内存块首地址，失败返回NULL。
*/
#define TKMEM_CALLOC(nmemb, size) tk_calloc(nmemb, size, __FUNCTION__, __LINE__)
/**
* @method TKMEM_REALLOC
* @export tk_realloc
* 重新分配一块内存，如果原来的内存块大于等于需要的空间，直接返回原来的内存块。
*
* @annotation ["macro"]
* @param {void*} p 原来的内存地址。
* @param {uint32_t} size 每一块的大小。
*
* @return {void*} 成功返回内存块首地址，失败返回NULL。
*/
#define TKMEM_REALLOC(p, size) tk_realloc(p, size, __FUNCTION__, __LINE__)
/**
* @method TKMEM_FREE
* @export tk_free
* 释放内存。
*
* @annotation ["macro"]
* @param {void*} p 内存地址。
*
* @return {void} 无。
*/
#ifdef WITH_CPPCHECK
#define TKMEM_FREE tk_free
#else
#define TKMEM_FREE(p) \
{ \
tk_free((void*)p); \
p = NULL; \
}
#endif /*WITH_CPPCHECK*/
/*helpler*/
#define TKMEM_ZALLOC(type) (type*)tk_calloc(1, sizeof(type), __FUNCTION__, __LINE__)
#define TKMEM_ZALLOCN(type, n) (type*)tk_calloc(n, sizeof(type), __FUNCTION__, __LINE__)
#define TKMEM_REALLOCT(type, p, n) (type*)tk_realloc(p, (n) * sizeof(type), __FUNCTION__, __LINE__)
/**
* @method tk_mem_dump
* 显示内存信息。
*
* @return {void} 返回void。
*/
void tk_mem_dump(void);
/**
* @method tk_mem_set_on_out_of_memory
* 设置内存耗尽时的处理函数。
* @param {tk_mem_on_out_of_memory_t} on_out_of_memory 回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mem_set_on_out_of_memory(tk_mem_on_out_of_memory_t on_out_of_memory, void* ctx);
/**
* @method tk_mem_init
* @export none
* 初始化内存。
*
* @param {void*} buffer 内存地址。
* @param {uint32_t} size 内存长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mem_init(void* buffer, uint32_t size);
/**
* @method tk_mem_init_ex
* @export none
* 初始化内存，支持多块不连续的内存。
* >最后一个参数必须为NULL。
*
* 示例：
* ```c
* tk_mem_init_ex(mem1, sizeof(mem1), mem2, sizeof(mem2), mem3, sizeof(mem3), NULL);
* ```
*
* @param {void*} buffer 内存地址。
* @param {uint32_t} size 内存长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mem_init_ex(void* buffer, uint32_t size, ...);
/**
* @method tk_mem_init_stage2
* 初始化互斥和oom。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mem_init_stage2(void);
/**
* @method tk_mem_is_valid_addr
* 检查给定的地址是否是一个有效的heap地址。
* > 用于辅助发现内存问题。
*
* @param {void*} addr 内存地址。
*
* @return {bool_t} 返回FALSE一定是无效地址，返回TRUE在PC则不太确定。
*/
bool_t tk_mem_is_valid_addr(void* addr);
#define TK_IS_VALID_ADDR(addr) tk_mem_is_valid_addr(addr)
END_C_DECLS
#endif /*WITH_WASM*/
#endif /*TK_TKMEM_MANAGER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/time_now.c
|
/**
* File: time.h
* Author: AWTK Develop Team
* Brief: time
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/time_now.h"
#include "tkc/platform.h"
#ifndef HAS_GET_TIME_US64
uint64_t get_time_us64() {
return get_time_ms64() * 1000;
}
#endif /*HAS_GET_TIME_US64*/
uint64_t time_now_us(void) {
return get_time_us64();
}
uint64_t time_now_ms(void) {
return get_time_ms64();
}
uint64_t time_now_s(void) {
return get_time_ms64() / 1000;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_array.h
|
/**
* File: object_array.h
* Author: AWTK Develop Team
* Brief: object array
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-19 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_ARRAY_H
#define TK_OBJECT_ARRAY_H
#include "tkc/object.h"
#include "tkc/value.h"
BEGIN_C_DECLS
/**
* @class object_array_t
* @parent tk_object_t
* @annotation ["scriptable"]
*
* 简单的动态数组，内部存放value对象。
*
* 访问时属性名称为：
*
* * "size"/"length" 用于获取数组的长度。
* * index 用于访问属性，-1可以用来追加新元素。
*
*/
typedef struct _object_array_t {
tk_object_t object;
/**
* @property {uint32_t} size
* @annotation ["readable", "scriptable"]
* 属性个数。
*
*/
uint32_t size;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 属性数组的容量。
*
*/
uint32_t capacity;
/**
* @property {value_t*} props
* @annotation ["readable"]
* 属性数组。
*
*/
value_t* props;
} object_array_t;
/**
* @method object_array_create
*
* 创建对象。
*
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_array_create(void);
/**
* @method object_array_clone
*
* 克隆对象。
*
* @annotation ["constructor"]
* @param {tk_object_t*} o 被克隆的对象。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_array_clone(tk_object_t* o);
/**
* @method object_array_unref
*
* for script gc
* @param {tk_object_t*} obj 对象。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_unref(tk_object_t* obj);
/**
* @method object_array_clear_props
*
* 清除全部属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_clear_props(tk_object_t* obj);
/**
* @method object_array_insert
*
* 在指定位置插入一个元素。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {uint32_t} index 位置。
* @param {const value_t*} v 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_insert(tk_object_t* obj, uint32_t index, const value_t* v);
/**
* @method object_array_push
*
* 追加一个元素。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {const value_t*} v 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_push(tk_object_t* obj, const value_t* v);
/**
* @method object_array_index_of
*
* 查找元素出现的第一个位置。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {const value_t*} v 值。
*
* @return {int32_t} 如果找到返回其位置，否则返回-1。
*
*/
int32_t object_array_index_of(tk_object_t* obj, const value_t* v);
/**
* @method object_array_last_index_of
*
* 查找元素出现的最后一个位置。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {const value_t*} v 值。
*
* @return {int32_t} 如果找到返回其位置，否则返回-1。
*
*/
int32_t object_array_last_index_of(tk_object_t* obj, const value_t* v);
/**
* @method object_array_remove
*
* 在指定位置删除一个元素。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {uint32_t} index 位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_remove(tk_object_t* obj, uint32_t index);
/**
* @method object_array_remove_value
*
* 删除指定的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {value_t*} v 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_remove_value(tk_object_t* obj, value_t* v);
/**
* @method object_array_get_and_remove
*
* 在指定位置删除一个元素，并返回它。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {uint32_t} index 位置。
* @param {value_t*} v 用于返回值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_get_and_remove(tk_object_t* obj, uint32_t index, value_t* v);
/**
* @method object_array_pop
*
* 弹出最后一个元素。
* @param {tk_object_t*} obj 对象。
* @param {value_t*} v 返回值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_pop(tk_object_t* obj, value_t* v);
/**
* @method object_array_shift
*
* 弹出第一个元素。
* @param {tk_object_t*} obj 对象。
* @param {value_t*} v 返回值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_array_shift(tk_object_t* obj, value_t* v);
/**
* @method object_array_get
* 获取指定序数的元素。
* @param {tk_object_t*} obj 数组对象。
* @param {uint32_t} i 序数。
* @param {value_t*} v 返回的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_get(tk_object_t* obj, uint32_t i, value_t* v);
/**
* @method object_array_set
* 设置指定序数的元素。
* @param {tk_object_t*} obj 数组对象。
* @param {uint32_t} i 序数。
* @param {const value_t*} v 元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_set(tk_object_t* obj, uint32_t i, const value_t* v);
/**
* @method object_array_create_with_str
* @annotation ["constructor"]
*
* 通过字符串构建数组。
* @param {const char*} str 字符串
* @param {const char*} sep 分隔符。
* @param {value_type_t} type 类型。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* object_array_create_with_str(const char* str, const char* sep, value_type_t type);
/**
* @method object_array_join
* 使用分隔符把各个元素拼接起来。
* @param {tk_object_t*} obj 数组对象。
* @param {const char*} sep 分隔符。
* @param {str_t*} result 生成的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_join(tk_object_t* obj, const char* sep, str_t* result);
/**
* @method object_array_min
* 查找最小值。
* @param {tk_object_t*} obj 数组对象。
* @param {value_t*} result 结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_min(tk_object_t* obj, value_t* result);
/**
* @method object_array_max
* 查找最大值。
* @param {tk_object_t*} obj 数组对象。
* @param {value_t*} result 结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_max(tk_object_t* obj, value_t* result);
/**
* @method object_array_sum
* 求和。
* @param {tk_object_t*} obj 数组对象。
* @param {value_t*} result 结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_sum(tk_object_t* obj, value_t* result);
/**
* @method object_array_avg
* 求平均值。
* @param {tk_object_t*} obj 数组对象。
* @param {value_t*} result 结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_avg(tk_object_t* obj, value_t* result);
/**
* @method object_array_dup
* @annotation ["constructor"]
*
* 复制部分或全部元素。
* @param {tk_object_t*} obj 数组对象。
* @param {uint32_t} start 开始的位置。
* @param {uint32_t} end 结束的位置(不包含)。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* object_array_dup(tk_object_t* obj, uint32_t start, uint32_t end);
/**
* @method object_array_sort
* 排序。
* @param {tk_object_t*} obj 数组对象。
* @param {tk_compare_t} cmp 比较函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_sort(tk_object_t* obj, tk_compare_t cmp);
/**
* @method object_array_sort_as_int
* 按整数排序。
* @param {tk_object_t*} obj 数组对象。
* @param {bool_t} ascending 升序或降序。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_sort_as_int(tk_object_t* obj, bool_t ascending);
/**
* @method object_array_sort_as_double
* 按浮点数排序。
* @param {tk_object_t*} obj 数组对象。
* @param {bool_t} ascending 升序或降序。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_sort_as_double(tk_object_t* obj, bool_t ascending);
/**
* @method object_array_sort_as_str
* 按字符串排序。
* @param {tk_object_t*} obj 数组对象。
* @param {bool_t} ascending 升序或降序。
* @param {bool_t} ignore_case 是否忽略大小写。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_sort_as_str(tk_object_t* obj, bool_t ascending, bool_t ignore_case);
/**
* @method object_array_reverse
* 反向。
* @param {tk_object_t*} obj 数组对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_array_reverse(tk_object_t* obj);
/**
* @method object_array_cast
* 转换为object_array对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_array对象。
*
* @return {object_array_t*} object_array对象。
*/
object_array_t* object_array_cast(tk_object_t* obj);
#define OBJECT_ARRAY(obj) object_array_cast(obj)
#define TK_OBJECT_ARRAY_PROP_SIZE "size"
#define TK_OBJECT_ARRAY_PROP_LENGTH "length"
#define OBJECT_ARRRAY_TYPE "object_array"
END_C_DECLS
#endif /*TK_OBJECT_ARRAY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_manager_default.h
|
/**
* File: event_source_manager_default.h
* Author: AWTK Develop Team
* Brief: event manager manager implement with default
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-29 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_SOURCE_MANAGER_DEFAULT_H
#define TK_EVENT_SOURCE_MANAGER_DEFAULT_H
#include "tkc/event_source_manager.h"
BEGIN_C_DECLS
/**
* @class event_source_manager_default_t
* @parent event_source_manager_t
* @annotation ["fake"]
*
* 缺省的事件源管理器。
*
*/
/**
* @method event_source_manager_default_create
* 创建事件源管理器。
*
* @return {event_source_manager_t*} 返回事件源管理器对象。
*
*/
event_source_manager_t* event_source_manager_default_create(void);
END_C_DECLS
#endif /*TK_EVENT_SOURCE_MANAGER_DEFAULT_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_queue.h
|
/**
* File: action_queue.h
* Author: AWTK Develop Team
* Brief: action_queue
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-06 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ACTION_QUEUE_H
#define TK_ACTION_QUEUE_H
#include "tkc/qaction.h"
BEGIN_C_DECLS
typedef struct _action_queue_t {
uint16_t r;
uint16_t w;
uint16_t full;
uint16_t capacity;
qaction_t* actions[1];
} action_queue_t;
/**
* @method action_queue_create
* @annotation ["constructor"]
* 创建action_queue对象。
*
* @param {uint16_t} capacity action的容量。
*
* @return {action_queue_t*} action_queue对象。
*/
action_queue_t* action_queue_create(uint16_t capacity);
/**
* @method action_queue_recv
* 接收一个请求。
*
* @param {action_queue_t*} q action_queue对象。
* @param {qaction_t**} action 用于返回action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_queue_recv(action_queue_t* q, qaction_t** action);
/**
* @method action_queue_send
* 发送一个请求。
*
* @param {action_queue_t*} q action_queue对象。
* @param {qaction_t*} action action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_queue_send(action_queue_t* q, qaction_t* action);
/**
* @method action_queue_destroy
* 销毁。
*
* @param {action_queue_t*} q action_queue对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_queue_destroy(action_queue_t* q);
END_C_DECLS
#endif /*TK_ACTION_QUEUE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_manager_default.c
|
/**
* File: event_source_manager_default.c
* Author: AWTK Develop Team
* Brief: event manager_default manager_default
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-29 Li XianJing <[email protected]> created
*
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif /*WIN32_LEAN_AND_MEAN*/
#include "tkc/mem.h"
#include "tkc/platform.h"
#include "tkc/event_source_manager_default.h"
#ifdef WITH_SOCKET
#ifdef WIN32
#include "windows.h"
#include <winsock2.h>
#include <ws2tcpip.h>
typedef int socklen_t;
#else
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#endif /*WIN32*/
static ret_t event_source_manager_default_dispatch_fds(event_source_manager_t* manager,
uint64_t sleep_time) {
fd_set fdsr;
uint32_t i = 0;
int32_t fd = 0;
int32_t ret = 0;
int32_t max_fd = -1;
struct timeval tv = {0, 0};
event_source_t* iter = NULL;
event_source_t** sources = NULL;
return_value_if_fail(manager != NULL, 0);
FD_ZERO(&fdsr);
tv.tv_sec = sleep_time / 1000000;
tv.tv_usec = (sleep_time % 1000000);
sources = (event_source_t**)(manager->dispatching_sources.elms);
for (i = 0; i < manager->dispatching_sources.size; i++) {
iter = sources[i];
fd = event_source_get_fd(iter);
if (fd >= 0) {
FD_SET(fd, &fdsr);
if (fd > max_fd) {
max_fd = fd;
}
}
}
if (max_fd < 0) {
return RET_OK;
}
ret = select(max_fd + 1, &fdsr, NULL, NULL, &tv);
if (ret < 0) {
perror("select");
return RET_FAIL;
} else if (ret == 0) {
return RET_TIMEOUT;
}
for (i = 0; i < manager->dispatching_sources.size; i++) {
iter = sources[i];
if (darray_find(&manager->sources, iter) == NULL) {
continue;
}
fd = event_source_get_fd(iter);
if (fd >= 0) {
if (FD_ISSET(fd, &fdsr)) {
ret_t r = event_source_dispatch(iter);
if (r == RET_REMOVE) {
event_source_manager_remove(manager, iter);
}
}
}
}
return RET_OK;
}
#else
static ret_t event_source_manager_default_dispatch_fds(event_source_manager_t* manager,
uint64_t sleep_time) {
return RET_OK;
}
#endif /*WITH_SOCKET*/
static ret_t event_source_manager_default_dispatch_no_fd(event_source_manager_t* manager) {
uint32_t i = 0;
int32_t fd = 0;
event_source_t* iter = NULL;
event_source_t** sources = NULL;
return_value_if_fail(manager != NULL, RET_BAD_PARAMS);
sources = (event_source_t**)(manager->dispatching_sources.elms);
for (i = 0; i < manager->dispatching_sources.size; i++) {
iter = sources[i];
if (darray_find(&manager->sources, iter) == NULL) {
continue;
}
fd = event_source_get_fd(iter);
if (fd >= 0) {
continue;
}
if (event_source_check(iter) == RET_OK) {
ret_t r = event_source_dispatch(iter);
if (r == RET_REMOVE) {
event_source_manager_remove(manager, iter);
}
}
}
return RET_OK;
}
static ret_t event_source_manager_default_dispatch(event_source_manager_t* manager) {
uint64_t sleep_time = event_source_manager_get_wakeup_time(manager);
ret_t ret = event_source_manager_default_dispatch_fds(manager, sleep_time);
/*dispatch_no_fd不会失败，保留dispatch_fds的错误给调用者。*/
event_source_manager_default_dispatch_no_fd(manager);
return ret;
}
static ret_t event_source_manager_default_destroy(event_source_manager_t* manager) {
return_value_if_fail(manager != NULL && manager->dispatch != NULL, RET_BAD_PARAMS);
memset(manager, 0x00, sizeof(event_source_manager_t));
TKMEM_FREE(manager);
return RET_OK;
}
event_source_manager_t* event_source_manager_default_create(void) {
event_source_manager_t* manager = TKMEM_ZALLOC(event_source_manager_t);
return_value_if_fail(manager != NULL, NULL);
event_source_manager_init(manager);
manager->dispatch = event_source_manager_default_dispatch;
manager->destroy = event_source_manager_default_destroy;
event_source_manager_set_min_sleep_time(manager, TK_DEFAULT_WAIT_TIME);
return manager;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/url.h
|
/**
* File: url.h
* Author: AWTK Develop Team
* Brief: URL parser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-25 Li XianJing <[email protected]> created
*
*/
#ifndef TK_URL_H
#define TK_URL_H
#include "tkc/object.h"
BEGIN_C_DECLS
/**
* @class url_t
* URL
*/
typedef struct _url_t {
/**
* @property {char*} schema
* @annotation ["readable"]
* schema。
*/
char* schema;
/**
* @property {char*} user_name
* @annotation ["readable"]
* 用户名。
*/
char* user_name;
/**
* @property {char*} password
* @annotation ["readable"]
* 密码。
*/
char* password;
/**
* @property {char*} host
* @annotation ["readable"]
* 主机名。
*/
char* host;
/**
* @property {char*} path
* @annotation ["readable"]
* 路径。
*/
char* path;
/**
* @property {int32_t} port
* @annotation ["readable"]
* 端口。
*/
int32_t port;
/**
* @property {tk_object_t*} params
* @annotation ["readable"]
* 参数集合。
*/
tk_object_t* params;
/*private*/
str_t url;
bool_t fixed_port;
} url_t;
/**
* @method url_create
* 创建URL对象。
*
* @param {const char*} surl 字符串格式的URL。
*
* @return {url_t*} 返回URL对象。
*/
url_t* url_create(const char* surl);
/**
* @method url_set_schema
* 设置schema。
*
* @param {url_t*} url url对象。
* @param {const char*} schema schema。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_schema(url_t* url, const char* schema);
/**
* @method url_set_user_name
* 设置用户名。
*
* @param {url_t*} url url对象。
* @param {const char*} user_name 用户名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_user_name(url_t* url, const char* user_name);
/**
* @method url_set_password
* 设置密码。
*
* @param {url_t*} url url对象。
* @param {const char*} password 密码。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_password(url_t* url, const char* password);
/**
* @method url_set_host
* 设置主机名。
*
* @param {url_t*} url url对象。
* @param {const char*} host 主机名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_host(url_t* url, const char* host);
/**
* @method url_set_port
* 设置端口。
*
* @param {url_t*} url url对象。
* @param {int32_t} port 端口。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_port(url_t* url, int32_t port);
/**
* @method url_set_path
* 设置路径。
*
* @param {url_t*} url url对象。
* @param {const char*} path 路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_path(url_t* url, const char* path);
/**
* @method url_set_param
* 设置参数。
*
* @param {url_t*} url url对象。
* @param {const char*} name 参数名。
* @param {const char*} value 参数值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_set_param(url_t* url, const char* name, const char* value);
/**
* @method url_get_param
* 获取参数。
*
* @param {url_t*} url url对象。
* @param {const char*} name 参数名。
*
* @return {const char*} 返回指定参数名的参数值。
*/
const char* url_get_param(url_t* url, const char* name);
/**
* @method url_get_param_int32
* 获取参数。
*
* @param {url_t*} url url对象。
* @param {const char*} name 参数名。
* @param {int32_t} defvalue 默认值。
*
* @return {int32_t} 返回指定参数名的参数值。
*/
int32_t url_get_param_int32(url_t* url, const char* name, int32_t defvalue);
/**
* @method url_get_param_bool
* 获取参数。
*
* @param {url_t*} url url对象。
* @param {const char*} name 参数名。
* @param {bool_t} defvalue 默认值。
*
* @return {bool_t} 返回指定参数名的参数值。
*/
bool_t url_get_param_bool(url_t* url, const char* name, bool_t defvalue);
/**
* @method url_to_string
* 格式化成字符串。
*
*>返回的字符串在URL对象销毁或下一次调用本函数时失效。
*
* @param {url_t*} url url对象。
*
* @return {const char*} 返回字符串格式的URL。
*/
const char* url_to_string(url_t* url);
/**
* @method url_destroy
* 销毁url对象。
* @param {url_t*} url url对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t url_destroy(url_t* url);
END_C_DECLS
#endif /*TK_URL_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader.c
|
/**
* File: data_reader.c
* Author: AWTK Develop Team
* Brief: data_reader
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-26 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/data_reader.h"
#include "tkc/data_reader_factory.h"
int32_t data_reader_read(data_reader_t* reader, uint64_t offset, void* data, uint32_t size) {
return_value_if_fail(reader != NULL && reader->vt != NULL && reader->vt->read != NULL, -1);
return_value_if_fail(data != NULL && size > 0, -1);
return reader->vt->read(reader, offset, data, size);
}
uint64_t data_reader_get_size(data_reader_t* reader) {
return_value_if_fail(reader != NULL && reader->vt != NULL && reader->vt->get_size != NULL, 0);
return reader->vt->get_size(reader);
}
ret_t data_reader_destroy(data_reader_t* reader) {
return_value_if_fail(reader != NULL && reader->vt != NULL && reader->vt->destroy != NULL,
RET_BAD_PARAMS);
return reader->vt->destroy(reader);
}
void* data_reader_read_all(const char* url, uint32_t* size) {
uint32_t s = 0;
char* data = NULL;
data_reader_t* reader = data_reader_factory_create_reader(data_reader_factory(), url);
return_value_if_fail(reader != NULL, NULL);
s = data_reader_get_size(reader);
data = TKMEM_ALLOC(s + 1);
if (data != NULL) {
memset(data, 0x00, s + 1);
s = data_reader_read(reader, 0, data, s);
} else {
s = 0;
}
if (size != NULL) {
*size = s;
}
data_reader_destroy(reader);
return data;
}
bool_t data_reader_can_read(const char* url) {
bool_t can = FALSE;
data_reader_t* reader = data_reader_factory_create_reader(data_reader_factory(), url);
if (!reader) {
return FALSE;
}
if (data_reader_get_size(reader) > 0) {
can = TRUE;
}
data_reader_destroy(reader);
return can;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/fps.h
|
/**
* File: fps.h
* Author: AWTK Develop Team
* Brief: calculate fps
*
* Copyright (c) Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-06-25 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FPS_H
#define TK_FPS_H
#include "tkc/time_now.h"
BEGIN_C_DECLS
/**
* @class fps_t
* 用于计算FPS(帧率)。
*/
typedef struct _fps_t {
/*private*/
uint64_t time;
uint32_t count;
uint32_t fps;
} fps_t;
/**
* @method fps_init
* 初始化。
* @export none
* @param {fps_t*} fps fps对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
static inline ret_t fps_init(fps_t* fps) {
return_value_if_fail(fps != NULL, RET_BAD_PARAMS);
memset(fps, 0x00, sizeof(fps_t));
fps->time = time_now_ms();
return RET_OK;
}
/**
* @method fps_inc
* 增加帧数。
* @export none
* @param {fps_t*} fps fps对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
static inline ret_t fps_inc(fps_t* fps) {
return_value_if_fail(fps != NULL, RET_BAD_PARAMS);
fps->count++;
return RET_OK;
}
/**
* @method fps_get
* 获取FPS(帧率)。
* @export none
* @param {fps_t*} fps fps对象。
*
* @return {uint32_t} 返回FPS(帧率)。
*/
static inline uint32_t fps_get(fps_t* fps) {
uint64_t elapse = 0;
uint64_t now = time_now_ms();
return_value_if_fail(fps != NULL, 0);
elapse = now - fps->time;
if (elapse > 200) {
float value = (fps->count * 1000.0f) / (float)elapse;
fps->count = 0;
fps->time = now;
fps->fps = tk_roundi(value);
}
return fps->fps;
}
END_C_DECLS
#endif /*TK_FPS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_timer.c
|
/**
* File: event_source_timer.h
* Author: AWTK Develop Team
* Brief: event source timer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#include "tkc/event_source_timer.h"
static const object_vtable_t s_event_source_timer_vtable = {.type = "event_source_timer",
.desc = "event_source_timer",
.size = sizeof(event_source_timer_t)};
static int32_t event_source_timer_get_fd(event_source_t* source) {
return -1;
}
static ret_t event_source_timer_check(event_source_t* source) {
return RET_OK;
}
static ret_t event_source_timer_dispatch(event_source_t* source) {
event_source_timer_t* event_source_timer = EVENT_SOURCE_TIMER(source);
return timer_manager_dispatch(event_source_timer->timer_manager);
}
uint32_t event_source_timer_get_wakeup_time(event_source_t* source) {
event_source_timer_t* event_source_timer = EVENT_SOURCE_TIMER(source);
uint64_t next_time = timer_manager_next_time(event_source_timer->timer_manager);
int64_t ret = next_time - event_source_timer->timer_manager->get_time();
return ret > 0 ? ret : 0;
}
event_source_t* event_source_timer_create(timer_manager_t* timer_manager) {
tk_object_t* obj = NULL;
event_source_t* event_source = NULL;
event_source_timer_t* event_source_timer = NULL;
return_value_if_fail(timer_manager != NULL, NULL);
obj = tk_object_create(&s_event_source_timer_vtable);
event_source = EVENT_SOURCE(obj);
event_source_timer = EVENT_SOURCE_TIMER(obj);
return_value_if_fail(event_source_timer != NULL, NULL);
event_source_timer->timer_manager = timer_manager;
event_source->check = event_source_timer_check;
event_source->get_fd = event_source_timer_get_fd;
event_source->dispatch = event_source_timer_dispatch;
event_source->get_wakeup_time = event_source_timer_get_wakeup_time;
return event_source;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/hash_table.c
|
/**
* File: hash_table.c
* Author: AWTK Develop Team
* Brief: hash table
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-11-15 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/hash_table.h"
hash_table_t* hash_table_create(uint32_t capacity, tk_destroy_t destroy, tk_compare_t compare,
tk_hash_t hash) {
hash_table_t* hash_table = NULL;
return_value_if_fail(capacity > 0 && hash != NULL && compare != NULL, NULL);
hash_table = TKMEM_ZALLOC(hash_table_t);
return_value_if_fail(hash_table != NULL, NULL);
if (hash_table_init(hash_table, capacity, destroy, compare, hash) == NULL) {
TKMEM_FREE(hash_table);
}
return hash_table;
}
hash_table_t* hash_table_init(hash_table_t* hash_table, uint32_t capacity, tk_destroy_t destroy,
tk_compare_t compare, tk_hash_t hash) {
uint32_t i = 0;
return_value_if_fail(hash_table != NULL, NULL);
return_value_if_fail(capacity > 0 && hash != NULL && compare != NULL, NULL);
memset(hash_table, 0, sizeof(hash_table_t));
hash_table->hash = hash;
hash_table->destroy = destroy;
hash_table->compare = compare;
goto_error_if_fail(
darray_init(&(hash_table->buckets), capacity, (tk_destroy_t)darray_destroy, NULL));
for (i = 0; i < capacity; i++) {
darray_t* arr = darray_create(5, destroy, compare);
goto_error_if_fail(arr != NULL);
ENSURE(darray_push(&(hash_table->buckets), arr) == RET_OK);
}
return hash_table;
error:
hash_table_deinit(hash_table);
return NULL;
}
static darray_t* hash_table_get_array(hash_table_t* hash_table, void* ctx) {
uint32_t index = 0;
return_value_if_fail(hash_table != NULL, NULL);
return_value_if_fail(hash_table->hash != NULL && hash_table->buckets.size > 0, NULL);
index = hash_table->hash(ctx) % hash_table->buckets.size;
return (darray_t*)darray_get(&(hash_table->buckets), index);
}
void* hash_table_find(hash_table_t* hash_table, tk_compare_t cmp, void* ctx) {
darray_t* arr = hash_table_get_array(hash_table, ctx);
return_value_if_fail(arr != NULL, NULL);
return darray_find_ex(arr, cmp, ctx);
}
ret_t hash_table_add(hash_table_t* hash_table, void* data, bool_t replace_if_exist) {
darray_t* arr = hash_table_get_array(hash_table, data);
return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
return darray_sorted_insert(arr, data, hash_table->compare, replace_if_exist);
}
ret_t hash_table_remove(hash_table_t* hash_table, tk_compare_t cmp, void* ctx) {
darray_t* arr = hash_table_get_array(hash_table, ctx);
return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
return darray_remove_ex(arr, hash_table->compare, ctx);
}
ret_t hash_table_remove_all(hash_table_t* hash_table, tk_compare_t cmp, void* ctx) {
uint32_t i = 0;
uint32_t n = 0;
darray_t** arrs = NULL;
return_value_if_fail(hash_table != NULL, RET_BAD_PARAMS);
n = hash_table->buckets.size;
arrs = (darray_t**)(hash_table->buckets.elms);
for (i = 0; i < n; i++) {
darray_t* iter = arrs[i];
darray_remove_all(iter, cmp, ctx);
}
return RET_OK;
}
int32_t hash_table_size(hash_table_t* hash_table) {
uint32_t i = 0;
uint32_t n = 0;
int32_t count = 0;
darray_t** arrs = NULL;
return_value_if_fail(hash_table != NULL, 0);
n = hash_table->buckets.size;
arrs = (darray_t**)(hash_table->buckets.elms);
for (i = 0; i < n; i++) {
darray_t* iter = arrs[i];
count += iter->size;
}
return count;
}
int32_t hash_table_count(hash_table_t* hash_table, tk_compare_t cmp, void* ctx) {
uint32_t i = 0;
uint32_t n = 0;
int32_t count = 0;
darray_t** arrs = NULL;
return_value_if_fail(hash_table != NULL, 0);
n = hash_table->buckets.size;
arrs = (darray_t**)(hash_table->buckets.elms);
for (i = 0; i < n; i++) {
darray_t* iter = arrs[i];
iter->compare = cmp;
count += darray_count(iter, ctx);
iter->compare = hash_table->compare;
}
return count;
}
ret_t hash_table_clear(hash_table_t* hash_table) {
uint32_t i = 0;
uint32_t n = 0;
darray_t** arrs = NULL;
return_value_if_fail(hash_table != NULL, RET_BAD_PARAMS);
n = hash_table->buckets.size;
arrs = (darray_t**)(hash_table->buckets.elms);
for (i = 0; i < n; i++) {
darray_t* iter = arrs[i];
darray_clear(iter);
}
return RET_OK;
}
ret_t hash_table_foreach(hash_table_t* hash_table, tk_visit_t visit, void* ctx) {
uint32_t i = 0;
uint32_t n = 0;
darray_t** arrs = NULL;
return_value_if_fail(hash_table != NULL, RET_BAD_PARAMS);
n = hash_table->buckets.size;
arrs = (darray_t**)(hash_table->buckets.elms);
for (i = 0; i < n; i++) {
darray_t* iter = arrs[i];
ret_t ret = darray_foreach(iter, visit, ctx);
if (ret != RET_OK) {
return ret;
}
}
return RET_OK;
}
ret_t hash_table_deinit(hash_table_t* hash_table) {
return_value_if_fail(hash_table != NULL, RET_BAD_PARAMS);
darray_deinit(&(hash_table->buckets));
memset(hash_table, 0x00, sizeof(hash_table_t));
return RET_OK;
}
ret_t hash_table_destroy(hash_table_t* hash_table) {
return_value_if_fail(hash_table != NULL, RET_BAD_PARAMS);
hash_table_deinit(hash_table);
TKMEM_FREE(hash_table);
return RET_OK;
}
uint32_t hash_table_hash_str(const void* data) {
const char* p = (const char*)data;
uint32_t value = 0;
return_value_if_fail(data != NULL, 0);
while (*p) {
value += *p++;
}
return value;
}
uint32_t hash_table_hash_int(const void* data) {
return tk_pointer_to_int(data);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/int_str.c
|
/**
* File: int_str.c
* Author: AWTK Develop Team
* Brief: map between int and str
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-31 Li XianJing <[email protected]> created
*
*/
#include "tkc/int_str.h"
const char* int_str_value(const int_str_t* items, int32_t name) {
const int_str_t* iter = items;
return_value_if_fail(items != NULL, NULL);
while (iter->value != NULL) {
if (iter->name == name) {
return iter->value;
}
iter++;
}
return NULL;
}
int32_t int_str_name(const int_str_t* items, const char* value, int32_t defval) {
const int_str_t* iter = items;
return_value_if_fail(items != NULL && value != NULL, defval);
while (iter->value != NULL) {
if (tk_str_eq(iter->value, value)) {
return iter->name;
}
iter++;
}
return defval;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/socket_helper_compat.h
|
#ifndef USE_TK_PREFIX
#define tcp_listen tk_tcp_listen
#define tcp_accept tk_tcp_accept
#define tcp_connect tk_tcp_connect
#define udp_listen tk_udp_listen
#define udp_connect tk_udp_connect
#define socket_init tk_socket_init
#define socket_deinit tk_socket_deinit
#define socket_close tk_socket_close
#define socket_bind tk_socket_bind
#define socket_wait_for_data tk_socket_wait_for_data
#define socket_set_blocking tk_socket_set_blocking
#define socket_last_io_has_error tk_socket_last_io_has_error
#define socket_resolve tk_socket_resolve
#endif /*USE_TK_PREFIX*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/timer_manager.c
|
/**
* File: timer_manager
* Author: AWTK Develop Team
* Brief: timer manager
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/timer_manager.h"
static timer_manager_t* s_timer_manager;
timer_manager_t* timer_manager(void) {
return s_timer_manager;
}
ret_t timer_manager_set(timer_manager_t* timer_manager) {
s_timer_manager = timer_manager;
return RET_OK;
}
timer_manager_t* timer_manager_create(timer_get_time_t get_time) {
timer_manager_t* timer_manager = NULL;
return_value_if_fail(get_time != NULL, NULL);
timer_manager = TKMEM_ZALLOC(timer_manager_t);
return_value_if_fail(timer_manager != NULL, NULL);
return timer_manager_init(timer_manager, get_time);
}
timer_manager_t* timer_manager_init(timer_manager_t* timer_manager, timer_get_time_t get_time) {
return_value_if_fail(timer_manager != NULL, NULL);
timer_manager->next_timer_id = TK_INVALID_ID + 1;
timer_manager->last_dispatch_time = get_time();
timer_manager->get_time = get_time;
slist_init(&(timer_manager->timers), (tk_destroy_t)tk_object_unref, timer_info_compare_by_id);
return timer_manager;
}
ret_t timer_manager_deinit(timer_manager_t* timer_manager) {
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
slist_deinit(&(timer_manager->timers));
return RET_OK;
}
ret_t timer_manager_destroy(timer_manager_t* timer_manager) {
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
timer_manager_deinit(timer_manager);
TKMEM_FREE(timer_manager);
return RET_OK;
}
uint32_t timer_manager_get_next_timer_id(timer_manager_t* timer_manager) {
uint32_t next_timer_id = 0;
return_value_if_fail(timer_manager != NULL, TK_INVALID_ID);
do {
next_timer_id = timer_manager->next_timer_id++;
if (next_timer_id == TK_INVALID_ID) {
next_timer_id = timer_manager->next_timer_id++;
}
} while (timer_manager_find(timer_manager, next_timer_id) != NULL);
return next_timer_id;
}
ret_t timer_manager_append(timer_manager_t* timer_manager, timer_info_t* timer) {
return_value_if_fail(timer_manager != NULL && timer != NULL, RET_BAD_PARAMS);
return slist_append(&(timer_manager->timers), timer);
}
uint32_t timer_manager_add(timer_manager_t* timer_manager, timer_func_t on_timer, void* ctx,
uint32_t duration) {
return timer_manager_add_with_type(timer_manager, on_timer, ctx, duration, TIMER_INFO_NORMAL);
}
uint32_t timer_manager_add_with_id(timer_manager_t* timer_manager, uint32_t id,
timer_func_t on_timer, void* ctx, uint32_t duration) {
return timer_manager_add_with_type_and_id(timer_manager, id, on_timer, ctx, duration,
TIMER_INFO_NORMAL, TRUE);
}
uint32_t timer_manager_add_with_type(timer_manager_t* timer_manager, timer_func_t on_timer,
void* ctx, uint32_t duration, uint16_t timer_info_type) {
uint32_t id = timer_manager_get_next_timer_id(timer_manager);
return timer_manager_add_with_type_and_id(timer_manager, id, on_timer, ctx, duration,
timer_info_type, FALSE);
}
uint32_t timer_manager_add_with_type_and_id(timer_manager_t* timer_manager, uint32_t id,
timer_func_t on_timer, void* ctx, uint32_t duration,
uint16_t timer_info_type, bool_t is_check_id) {
timer_info_t* timer = NULL;
return_value_if_fail(on_timer != NULL, TK_INVALID_ID);
return_value_if_fail(id != TK_INVALID_ID, TK_INVALID_ID);
return_value_if_fail(timer_manager != NULL, TK_INVALID_ID);
if (is_check_id) {
if (timer_manager_find(timer_manager, id) != NULL) {
return TK_INVALID_ID;
}
}
timer = timer_info_create(timer_manager, id, on_timer, ctx, duration, timer_info_type);
return_value_if_fail(timer != NULL, TK_INVALID_ID);
return timer->id;
}
ret_t timer_manager_all_remove_by_ctx_and_type(timer_manager_t* timer_manager, uint16_t type,
void* ctx) {
timer_info_t timer;
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
return slist_remove_with_compare(&(timer_manager->timers),
timer_info_init_dummy_with_ctx_and_type(&timer, type, ctx),
timer_info_compare_by_ctx_and_type, -1);
}
ret_t timer_manager_all_remove_by_ctx(timer_manager_t* timer_manager, void* ctx) {
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
return slist_remove_with_compare(&(timer_manager->timers), ctx, timer_info_compare_by_ctx, -1);
}
ret_t timer_manager_remove(timer_manager_t* timer_manager, uint32_t timer_id) {
timer_info_t timer;
return_value_if_fail(timer_id != TK_INVALID_ID, RET_BAD_PARAMS);
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
return slist_remove(&(timer_manager->timers), timer_info_init_dummy(&timer, timer_id));
}
ret_t timer_manager_reset(timer_manager_t* timer_manager, uint32_t timer_id) {
timer_info_t* info = (timer_info_t*)timer_manager_find(timer_manager, timer_id);
return_value_if_fail(info != NULL, RET_NOT_FOUND);
info->start = timer_manager->get_time();
return RET_OK;
}
const timer_info_t* timer_manager_find(timer_manager_t* timer_manager, uint32_t timer_id) {
timer_info_t timer;
return_value_if_fail(timer_id != TK_INVALID_ID, NULL);
return_value_if_fail(timer_manager != NULL, NULL);
return slist_find(&(timer_manager->timers), timer_info_init_dummy(&timer, timer_id));
}
static ret_t timer_manager_dispatch_one(timer_manager_t* timer_manager, uint64_t now,
int32_t delta_time) {
slist_node_t* iter = timer_manager->timers.first;
while (iter != NULL && !timer_info_is_available(TIMER_INFO(iter->data), now)) {
iter = iter->next;
}
if (iter != NULL) {
timer_info_t* timer = (timer_info_t*)tk_object_ref((tk_object_t*)(iter->data));
return_value_if_fail(timer != NULL, RET_BAD_PARAMS);
timer->now = now;
if (!timer->suspend && (timer->start + timer->duration) <= now) {
if (timer_info_on_timer(timer, now) != RET_REPEAT) {
timer_manager_remove(timer_manager, timer->id);
} else {
timer->start = now;
}
}
tk_object_unref((tk_object_t*)timer);
return RET_OK;
}
return RET_DONE;
}
ret_t timer_manager_dispatch(timer_manager_t* timer_manager) {
uint64_t now = 0;
int32_t delta_time = 0;
return_value_if_fail(timer_manager != NULL, RET_BAD_PARAMS);
now = timer_manager->get_time();
delta_time = now - timer_manager->last_dispatch_time;
if (timer_manager->timers.first == NULL) {
timer_manager->last_dispatch_time = now;
return RET_OK;
}
timer_manager->last_dispatch_time = now;
while (timer_manager_dispatch_one(timer_manager, now, delta_time) == RET_OK) {
if (timer_manager->last_dispatch_time != now) {
log_debug("abort dispatch because sub main loop\n");
}
}
return RET_OK;
}
uint32_t timer_manager_count(timer_manager_t* timer_manager) {
return_value_if_fail(timer_manager != NULL, 0);
return slist_size(&(timer_manager->timers));
}
uint64_t timer_manager_next_time(timer_manager_t* timer_manager) {
slist_node_t* iter = NULL;
uint64_t t = timer_manager->get_time() + 0xffff;
return_value_if_fail(timer_manager != NULL, t);
iter = timer_manager->timers.first;
while (iter != NULL) {
timer_info_t* timer = TIMER_INFO(iter->data);
if ((timer->start + timer->duration) < t) {
t = timer->start + timer->duration;
}
iter = iter->next;
}
return t;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/waitable_action_queue.c
|
/**
* File: waitable_action_queue.c
* Author: AWTK Develop Team
* Brief: waitable_action_queue
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-07 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/waitable_action_queue.h"
waitable_action_queue_t* waitable_action_queue_create(uint16_t capacity) {
waitable_action_queue_t* q = TKMEM_ZALLOC(waitable_action_queue_t);
return_value_if_fail(q != NULL, NULL);
q->queue = action_queue_create(capacity);
goto_error_if_fail(q->queue != NULL);
q->mutex = tk_mutex_create();
goto_error_if_fail(q->mutex != NULL);
q->sema_recv = tk_semaphore_create(0, NULL);
goto_error_if_fail(q->sema_recv != NULL);
q->sema_send = tk_semaphore_create(capacity, NULL);
goto_error_if_fail(q->sema_send != NULL);
return q;
error:
if (q != NULL) {
if (q->queue != NULL) {
action_queue_destroy(q->queue);
}
if (q->mutex != NULL) {
tk_mutex_destroy(q->mutex);
}
if (q->sema_recv != NULL) {
tk_semaphore_destroy(q->sema_recv);
}
if (q->sema_send != NULL) {
tk_semaphore_destroy(q->sema_send);
}
TKMEM_FREE(q);
}
return NULL;
}
ret_t waitable_action_queue_recv(waitable_action_queue_t* q, qaction_t** action,
uint32_t timeout_ms) {
ret_t ret = RET_FAIL;
return_value_if_fail(q != NULL && action != NULL, RET_BAD_PARAMS);
if (tk_semaphore_wait(q->sema_recv, timeout_ms) == RET_OK) {
if (tk_mutex_lock(q->mutex) == RET_OK) {
ret = action_queue_recv(q->queue, action);
if (ret == RET_OK) {
ENSURE(tk_semaphore_post(q->sema_send) == RET_OK);
}
ENSURE(tk_mutex_unlock(q->mutex) == RET_OK);
}
}
return ret;
}
ret_t waitable_action_queue_send(waitable_action_queue_t* q, qaction_t* action,
uint32_t timeout_ms) {
ret_t ret = RET_FAIL;
return_value_if_fail(q != NULL && action != NULL, RET_BAD_PARAMS);
if (tk_semaphore_wait(q->sema_send, timeout_ms) == RET_OK) {
if (tk_mutex_lock(q->mutex) == RET_OK) {
ret = action_queue_send(q->queue, action);
assert(ret == RET_OK);
ENSURE(tk_semaphore_post(q->sema_recv) == RET_OK);
ENSURE(tk_mutex_unlock(q->mutex) == RET_OK);
}
}
return ret;
}
ret_t waitable_action_queue_destroy(waitable_action_queue_t* q) {
return_value_if_fail(q != NULL, RET_BAD_PARAMS);
ENSURE(action_queue_destroy(q->queue) == RET_OK);
ENSURE(tk_mutex_destroy(q->mutex) == RET_OK);
ENSURE(tk_semaphore_destroy(q->sema_recv) == RET_OK);
ENSURE(tk_semaphore_destroy(q->sema_send) == RET_OK);
TKMEM_FREE(q);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_array.c
|
/**
* File: object_array.c
* Author: AWTK Develop Team
* Brief: object array
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-10 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/named_value.h"
#include "tkc/object_array.h"
static ret_t object_array_clean_invalid_props(tk_object_t* obj) {
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size > 0) {
uint32_t i = 0;
value_t* dst = o->props;
bool_t changed = FALSE;
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
if (iter->type != VALUE_TYPE_INVALID) {
if (dst != iter) {
memcpy(dst, iter, sizeof(value_t));
}
dst++;
} else {
changed = TRUE;
}
}
o->size = dst - o->props;
if (changed) {
emitter_dispatch_simple_event(EMITTER(o), EVT_ITEMS_CHANGED);
}
}
return RET_OK;
}
ret_t object_array_clear_props(tk_object_t* obj) {
uint32_t i = 0;
object_array_t* o = OBJECT_ARRAY(obj);
event_t e = event_init(EVT_ITEMS_CHANGED, o);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
value_reset(iter);
}
o->size = 0;
emitter_dispatch(EMITTER(o), &e);
return RET_OK;
}
static ret_t object_array_on_destroy(tk_object_t* obj) {
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
object_array_clear_props(obj);
o->capacity = 0;
TKMEM_FREE(o->props);
return RET_OK;
}
static int32_t object_array_compare(tk_object_t* obj, tk_object_t* other) {
return tk_str_cmp(obj->name, other->name);
}
static ret_t object_array_extend(tk_object_t* obj) {
ret_t ret = RET_OOM;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size < o->capacity) {
ret = RET_OK;
} else {
value_t* props = NULL;
uint32_t capacity = o->capacity + (o->capacity >> 1) + 1;
props = TKMEM_REALLOCT(value_t, o->props, capacity);
if (props != NULL) {
o->props = props;
o->capacity = capacity;
ret = RET_OK;
}
}
return ret;
}
ret_t object_array_insert(tk_object_t* obj, uint32_t index, const value_t* v) {
value_t* s = NULL;
value_t* d = NULL;
value_t* p = NULL;
object_array_t* o = OBJECT_ARRAY(obj);
event_t e = event_init(EVT_ITEMS_CHANGED, o);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return_value_if_fail(o != NULL && v != NULL, RET_BAD_PARAMS);
index = tk_min(index, o->size);
return_value_if_fail(object_array_extend(obj) == RET_OK, RET_OOM);
p = o->props + index;
d = o->props + o->size;
s = d - 1;
while (s >= p) {
*d-- = *s--;
}
value_deep_copy(p, v);
o->size++;
emitter_dispatch(EMITTER(o), &e);
return RET_OK;
}
ret_t object_array_push(tk_object_t* obj, const value_t* v) {
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return object_array_insert(obj, o->size, v);
}
static int32_t object_array_parse_index(const char* name) {
if (tk_isdigit(*name)) {
return tk_atoi(name);
} else if (*name == '[') {
return tk_atoi(name + 1);
} else if (tk_str_eq(name, "-1")) {
return -1;
} else {
return -2;
}
}
int32_t object_array_index_of(tk_object_t* obj, const value_t* v) {
int32_t i = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, -1);
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
if (value_equal(iter, v)) {
return i;
}
}
return -1;
}
int32_t object_array_last_index_of(tk_object_t* obj, const value_t* v) {
int32_t i = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, -1);
if (o->size > 0) {
for (i = o->size - 1; i >= 0; i--) {
value_t* iter = o->props + i;
if (value_equal(iter, v)) {
return i;
}
}
}
return -1;
}
ret_t object_array_remove(tk_object_t* obj, uint32_t index) {
return object_array_get_and_remove(obj, index, NULL);
}
ret_t object_array_get_and_remove(tk_object_t* obj, uint32_t index, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (index < o->size) {
value_t* iter = o->props + index;
if (v != NULL) {
*v = *iter;
memset(iter, 0x00, sizeof(*iter));
} else {
value_reset(iter);
}
ret = object_array_clean_invalid_props(obj);
}
return ret;
}
ret_t object_array_shift(tk_object_t* obj, value_t* v) {
return object_array_get_and_remove(obj, 0, v);
}
static ret_t object_array_remove_prop(tk_object_t* obj, const char* name) {
int32_t index = object_array_parse_index(name);
return object_array_remove(obj, index);
}
ret_t object_array_pop(tk_object_t* obj, value_t* v) {
value_t* last = NULL;
object_array_t* o = OBJECT_ARRAY(obj);
event_t e = event_init(EVT_ITEMS_CHANGED, o);
return_value_if_fail(o != NULL && o->size > 0, RET_BAD_PARAMS);
last = o->props + o->size - 1;
*v = *last;
memset(last, 0x00, sizeof(value_t));
o->size--;
emitter_dispatch(EMITTER(o), &e);
return RET_OK;
}
ret_t object_array_set(tk_object_t* obj, uint32_t index, const value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
event_t e = event_init(EVT_ITEMS_CHANGED, o);
return_value_if_fail(object_array_extend(obj) == RET_OK, RET_OOM);
if (index < o->size) {
value_t* iter = o->props + index;
value_reset(iter);
ret = value_deep_copy(iter, v);
emitter_dispatch(EMITTER(o), &e);
} else if (index == 0xffffffff) {
ret = object_array_push(obj, v);
} else {
ret = RET_BAD_PARAMS;
}
return ret;
}
static ret_t object_array_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
int32_t index = -1;
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_set_prop(sub, name, v);
}
index = object_array_parse_index(name);
if (index != -2) {
ret = object_array_set(obj, index, v);
}
return ret;
}
ret_t object_array_get(tk_object_t* obj, uint32_t i, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (i < o->size) {
value_t* iter = o->props + i;
ret = value_copy(v, iter);
}
return ret;
}
static ret_t object_array_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, TK_OBJECT_ARRAY_PROP_LENGTH) || tk_str_eq(name, TK_OBJECT_ARRAY_PROP_SIZE) ||
tk_str_eq(name, TK_OBJECT_PROP_SIZE)) {
value_set_int(v, o->size);
ret = RET_OK;
} else if (tk_str_eq(name, "capacity")) {
value_set_int(v, o->capacity);
ret = RET_OK;
} else if (o->size > 0) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_get_prop(sub, name, v);
}
int32_t index = object_array_parse_index(name);
ret = object_array_get(obj, index, v);
}
return ret;
}
static bool_t object_array_can_exec(tk_object_t* obj, const char* name, const char* args) {
bool_t ret = FALSE;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_can_exec(sub, name, args);
}
return ret;
}
static ret_t object_array_exec(tk_object_t* obj, const char* name, const char* args) {
ret_t ret = RET_NOT_FOUND;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_exec(sub, name, args);
}
return ret;
}
static ret_t object_array_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_OK;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size > 0) {
uint32_t i = 0;
named_value_t nv;
char name[TK_NAME_LEN + 1];
nv.name = name;
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
tk_snprintf(name, TK_NAME_LEN, "%u", i);
value_copy(&(nv.value), iter);
ret = on_prop(ctx, &nv);
if (ret == RET_REMOVE) {
value_reset(iter);
} else if (ret != RET_OK) {
break;
}
}
object_array_clean_invalid_props(obj);
}
return ret;
}
static const object_vtable_t s_object_array_vtable = {
.type = OBJECT_ARRRAY_TYPE,
.desc = OBJECT_ARRRAY_TYPE,
.size = sizeof(object_array_t),
.is_collection = TRUE,
.on_destroy = object_array_on_destroy,
.compare = object_array_compare,
.get_prop = object_array_get_prop,
.set_prop = object_array_set_prop,
.can_exec = object_array_can_exec,
.exec = object_array_exec,
.clone = object_array_clone,
.remove_prop = object_array_remove_prop,
.foreach_prop = object_array_foreach_prop,
.clear_props = object_array_clear_props,
};
static tk_object_t* object_array_create_with_capacity(uint32_t init_capacity) {
tk_object_t* obj = tk_object_create(&s_object_array_vtable);
return_value_if_fail(obj != NULL, NULL);
if (init_capacity > 0) {
object_array_t* o = OBJECT_ARRAY(obj);
ENSURE(o);
o->props = TKMEM_ZALLOCN(value_t, init_capacity);
if (o->props != NULL) {
o->capacity = init_capacity;
}
}
return obj;
}
tk_object_t* object_array_create(void) {
return object_array_create_with_capacity(5);
}
tk_object_t* object_array_clone(tk_object_t* o) {
object_array_t* arr = OBJECT_ARRAY(o);
return_value_if_fail(arr != NULL, NULL);
return object_array_dup(TK_OBJECT(o), 0, arr->size);
}
object_array_t* object_array_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_array_vtable, NULL);
return (object_array_t*)(obj);
}
ret_t object_array_unref(tk_object_t* obj) {
return tk_object_unref(obj);
}
tk_object_t* object_array_create_with_str(const char* str, const char* sep, value_type_t type) {
str_t s;
value_t v;
tk_object_t* obj = NULL;
const char* p = NULL;
const char* end = NULL;
return_value_if_fail(str != NULL && sep != NULL && type != VALUE_TYPE_INVALID, NULL);
obj = object_array_create();
return_value_if_fail(obj != NULL, NULL);
if (str_init(&s, 100) == NULL) {
TK_OBJECT_UNREF(obj);
return NULL;
}
p = str;
do {
end = strstr(p, sep);
if (end != NULL) {
str_set_with_len(&s, p, end - p);
} else {
str_set(&s, p);
}
switch (type) {
case VALUE_TYPE_UINT8: {
value_set_uint8(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(&v, tk_atoul(s.str));
break;
}
case VALUE_TYPE_INT8: {
value_set_int8(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_INT32: {
value_set_int32(&v, tk_atoi(s.str));
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(&v, tk_atoul(s.str));
break;
}
case VALUE_TYPE_FLOAT: {
value_set_float(&v, tk_atof(s.str));
break;
}
case VALUE_TYPE_FLOAT32: {
value_set_float32(&v, tk_atof(s.str));
break;
}
case VALUE_TYPE_DOUBLE: {
value_set_double(&v, tk_atof(s.str));
break;
}
default: {
value_set_str(&v, s.str);
break;
}
}
object_array_push(obj, &v);
if (end != NULL) {
p = end + strlen(sep);
}
} while (end != NULL && *p);
str_reset(&s);
return obj;
}
ret_t object_array_join(tk_object_t* obj, const char* sep, str_t* result) {
str_t s;
uint32_t i = 0;
ret_t ret = RET_OK;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL && sep != NULL && result != NULL, RET_BAD_PARAMS);
str_set(result, "");
if (o->size < 1) {
return RET_OK;
}
str_init(&s, 50);
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
str_from_value(&s, iter);
if (i > 0) {
if (str_append(result, sep) != RET_OK) {
ret = RET_OOM;
break;
}
}
if (str_append(result, s.str) != RET_OK) {
ret = RET_OOM;
break;
}
}
str_reset(&s);
return ret;
}
tk_object_t* object_array_dup(tk_object_t* obj, uint32_t start, uint32_t end) {
uint32_t i = 0;
tk_object_t* dup = NULL;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, NULL);
end = tk_min(end, o->size);
if (start == end || o->size == 0) {
return object_array_create();
}
return_value_if_fail(start < end, NULL);
dup = object_array_create_with_capacity(end - start);
return_value_if_fail(dup != NULL, NULL);
for (i = start; i < end; i++) {
value_t* iter = o->props + i;
object_array_push(dup, iter);
}
return dup;
}
ret_t object_array_remove_value(tk_object_t* obj, value_t* v) {
uint32_t i = 0;
object_array_t* o = OBJECT_ARRAY(obj);
ENSURE(o);
return_value_if_fail(obj != NULL && v != NULL, RET_BAD_PARAMS);
for (i = 0; i < o->size; i++) {
value_t* iter = o->props + i;
if (value_equal(iter, v)) {
return object_array_remove(obj, i);
}
}
return RET_NOT_FOUND;
}
static int value_cmp_as_int(const void* a, const void* b) {
return value_int((const value_t*)a) - value_int((const value_t*)b);
}
static int value_cmp_as_int_r(const void* a, const void* b) {
return value_int((const value_t*)b) - value_int((const value_t*)a);
}
static int value_cmp_as_double(const void* a, const void* b) {
return value_double((const value_t*)a) - value_double((const value_t*)b);
}
static int value_cmp_as_double_r(const void* a, const void* b) {
return value_double((const value_t*)b) - value_double((const value_t*)a);
}
static int value_cmp_as_str(const void* a, const void* b) {
return strcmp(value_str((const value_t*)a), value_str((const value_t*)b));
}
static int value_cmp_as_str_r(const void* a, const void* b) {
return strcmp(value_str((const value_t*)b), value_str((const value_t*)a));
}
static int value_cmp_as_str_i(const void* a, const void* b) {
return strcasecmp(value_str((const value_t*)a), value_str((const value_t*)b));
}
static int value_cmp_as_str_i_r(const void* a, const void* b) {
return strcasecmp(value_str((const value_t*)b), value_str((const value_t*)a));
}
ret_t object_array_sort(tk_object_t* obj, tk_compare_t cmp) {
object_array_t* o = OBJECT_ARRAY(obj);
ENSURE(o);
event_t e = event_init(EVT_ITEMS_CHANGED, o);
return_value_if_fail(obj != NULL && cmp != NULL, RET_BAD_PARAMS);
qsort(o->props, o->size, sizeof(value_t), cmp);
emitter_dispatch(EMITTER(o), &e);
return RET_OK;
}
ret_t object_array_sort_as_int(tk_object_t* obj, bool_t ascending) {
if (ascending) {
return object_array_sort(obj, value_cmp_as_int);
} else {
return object_array_sort(obj, value_cmp_as_int_r);
}
}
ret_t object_array_sort_as_double(tk_object_t* obj, bool_t ascending) {
if (ascending) {
return object_array_sort(obj, value_cmp_as_double);
} else {
return object_array_sort(obj, value_cmp_as_double_r);
}
}
ret_t object_array_sort_as_str(tk_object_t* obj, bool_t ascending, bool_t ignore_case) {
if (ascending) {
if (ignore_case) {
return object_array_sort(obj, value_cmp_as_str_i);
} else {
return object_array_sort(obj, value_cmp_as_str);
}
} else {
if (ignore_case) {
return object_array_sort(obj, value_cmp_as_str_i_r);
} else {
return object_array_sort(obj, value_cmp_as_str_r);
}
}
}
ret_t object_array_min(tk_object_t* obj, value_t* result) {
int32_t i = 0;
double value = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
value_set_double(result, 0);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size == 0) {
return RET_OK;
}
value = value_double(o->props);
for (i = 1; i < o->size; i++) {
double t = value_double(o->props + i);
if (value > t) {
value = t;
}
}
value_set_double(result, value);
return RET_OK;
}
ret_t object_array_max(tk_object_t* obj, value_t* result) {
int32_t i = 0;
double value = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
value_set_double(result, 0);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size == 0) {
return RET_OK;
}
value = value_double(o->props);
for (i = 1; i < o->size; i++) {
double t = value_double(o->props + i);
if (value < t) {
value = t;
}
}
value_set_double(result, value);
return RET_OK;
}
ret_t object_array_sum(tk_object_t* obj, value_t* result) {
int32_t i = 0;
double value = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
value_set_double(result, 0);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
for (i = 0; i < o->size; i++) {
value += value_double(o->props + i);
}
value_set_double(result, value);
return RET_OK;
}
ret_t object_array_avg(tk_object_t* obj, value_t* result) {
int32_t i = 0;
double value = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
value_set_double(result, 0);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size > 0) {
for (i = 0; i < o->size; i++) {
value += value_double(o->props + i);
}
value /= o->size;
}
value_set_double(result, value);
return RET_OK;
}
ret_t object_array_reverse(tk_object_t* obj) {
uint32_t start = 0;
uint32_t end = 0;
object_array_t* o = OBJECT_ARRAY(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->size < 2) {
return RET_OK;
}
start = 0;
end = o->size - 1;
while (start < end) {
value_t v = o->props[start];
o->props[start] = o->props[end];
o->props[end] = v;
start++;
end--;
}
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/value.c
|
/**
* File: value.h
* Author: AWTK Develop Team
* Brief: generic value type
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-27 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/object.h"
bool_t value_bool(const value_t* v) {
return_value_if_fail(v->type != VALUE_TYPE_INVALID, 0);
switch (v->type) {
case VALUE_TYPE_BOOL: {
return v->value.b;
}
case VALUE_TYPE_STRING: {
return tk_atob(v->value.str);
}
case VALUE_TYPE_WSTRING: {
return tk_watob(v->value.wstr);
}
default: {
return value_int(v) ? TRUE : FALSE;
}
}
}
value_t* value_init(value_t* v, uint32_t type) {
v->type = type;
v->free_handle = FALSE;
return v;
}
value_t* value_set_bool(value_t* v, bool_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.b = value;
return value_init(v, VALUE_TYPE_BOOL);
}
value_t* value_set_int8(value_t* v, int8_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.i8 = value;
return value_init(v, VALUE_TYPE_INT8);
}
int8_t value_int8(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_INT8) {
return v->value.i8;
} else {
return (int8_t)value_int(v);
}
}
value_t* value_set_uint8(value_t* v, uint8_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.u8 = value;
return value_init(v, VALUE_TYPE_UINT8);
}
uint8_t value_uint8(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_UINT8) {
return v->value.u8;
} else {
return (uint8_t)value_int(v);
}
}
value_t* value_set_int16(value_t* v, int16_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.i16 = value;
return value_init(v, VALUE_TYPE_INT16);
}
int16_t value_int16(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_INT16) {
return v->value.i16;
} else {
return (int16_t)value_int(v);
}
}
value_t* value_set_uint16(value_t* v, uint16_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.u16 = value;
return value_init(v, VALUE_TYPE_UINT16);
}
uint16_t value_uint16(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_UINT16) {
return v->value.u16;
} else {
return (uint16_t)value_int(v);
}
}
value_t* value_set_int32(value_t* v, int32_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.i32 = value;
return value_init(v, VALUE_TYPE_INT32);
}
int32_t value_int32(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_INT32) {
return v->value.i32;
} else {
return (int32_t)value_int(v);
}
}
value_t* value_set_uint32(value_t* v, uint32_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.u32 = value;
return value_init(v, VALUE_TYPE_UINT32);
}
uint32_t value_uint32(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_UINT32) {
return v->value.u32;
} else if (v->type == VALUE_TYPE_STRING) {
return (uint32_t)tk_atoul(v->value.str);
} else {
return (uint32_t)value_int(v);
}
}
value_t* value_set_int64(value_t* v, int64_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.i64 = value;
return value_init(v, VALUE_TYPE_INT64);
}
int64_t value_int64(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_INT64) {
return v->value.i64;
} else if (v->type == VALUE_TYPE_UINT64) {
return v->value.u64;
} else if (v->type == VALUE_TYPE_STRING) {
return tk_atol(v->value.str);
} else if (v->type == VALUE_TYPE_UINT32) {
return (int64_t)value_uint32(v);
} else if (v->type == VALUE_TYPE_UINT64) {
return (int64_t)value_uint64(v);
} else {
return (int64_t)value_int(v);
}
}
value_t* value_set_uint64(value_t* v, uint64_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.u64 = value;
return value_init(v, VALUE_TYPE_UINT64);
}
uint64_t value_uint64(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_UINT64) {
return v->value.u64;
} else if (v->type == VALUE_TYPE_INT64) {
return v->value.i64;
} else if (v->type == VALUE_TYPE_STRING) {
return tk_atoul(v->value.str);
} else {
return (uint64_t)value_int(v);
}
}
value_t* value_set_pointer(value_t* v, void* value) {
return value_set_pointer_ex(v, value, NULL);
}
value_t* value_set_pointer_ex(value_t* v, void* value, tk_destroy_t destroy) {
return_value_if_fail(v != NULL, NULL);
if (destroy != NULL) {
pointer_ref_t* ref = TKMEM_ZALLOC(pointer_ref_t);
return_value_if_fail(ref != NULL, NULL);
ref->refcount = 1;
ref->destroy = destroy;
ref->data = value;
v->value.ptr_ref = ref;
value_init(v, VALUE_TYPE_POINTER_REF);
v->free_handle = TRUE;
} else {
v->value.ptr = value;
value_init(v, VALUE_TYPE_POINTER);
}
return v;
}
void* value_pointer(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
switch (v->type) {
case VALUE_TYPE_STRING: {
return (void*)(v->value.str);
}
case VALUE_TYPE_WSTRING: {
return (void*)(v->value.wstr);
}
case VALUE_TYPE_OBJECT: {
return (v->value.object);
}
case VALUE_TYPE_POINTER: {
return (v->value.ptr);
}
case VALUE_TYPE_POINTER_REF: {
return (v->value.ptr_ref->data);
}
default:
break;
}
return NULL;
}
value_t* value_set_float(value_t* v, float_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.f = value;
return value_init(v, VALUE_TYPE_FLOAT);
}
float_t value_float(const value_t* v) {
return_value_if_fail(v != NULL, 0);
return_value_if_fail(v->type != VALUE_TYPE_INVALID, 0);
switch (v->type) {
case VALUE_TYPE_BOOL: {
return (float_t)v->value.b;
}
case VALUE_TYPE_INT8: {
return (float_t)v->value.i8;
}
case VALUE_TYPE_UINT8: {
return (float_t)v->value.u8;
}
case VALUE_TYPE_INT16: {
return (float_t)v->value.i16;
}
case VALUE_TYPE_UINT16: {
return (float_t)v->value.u16;
}
case VALUE_TYPE_INT32: {
return (float_t)v->value.i32;
}
case VALUE_TYPE_UINT32: {
return (float_t)v->value.u32;
}
case VALUE_TYPE_INT64: {
return (float_t)v->value.i64;
}
case VALUE_TYPE_UINT64: {
return (float_t)v->value.u64;
}
case VALUE_TYPE_FLOAT: {
return (float_t)v->value.f;
}
case VALUE_TYPE_FLOAT32: {
return (float_t)v->value.f32;
}
case VALUE_TYPE_DOUBLE: {
return (float_t)v->value.f64;
}
case VALUE_TYPE_STRING: {
return (float_t)tk_atof(v->value.str);
}
case VALUE_TYPE_WSTRING: {
return (float_t)tk_watof(v->value.wstr);
}
default:
break;
}
return 0;
}
value_t* value_set_float32(value_t* v, float value) {
return_value_if_fail(v != NULL, NULL);
v->value.f32 = value;
return value_init(v, VALUE_TYPE_FLOAT32);
}
float value_float32(const value_t* v) {
return_value_if_fail(v != NULL, 0);
if (v->type == VALUE_TYPE_FLOAT32) {
return v->value.f32;
} else {
return (float)value_float(v);
}
}
value_t* value_set_double(value_t* v, double value) {
return_value_if_fail(v != NULL, NULL);
v->value.f64 = value;
return value_init(v, VALUE_TYPE_DOUBLE);
}
double value_double(const value_t* v) {
return_value_if_fail(v != NULL, 0);
return_value_if_fail(v->type != VALUE_TYPE_INVALID, 0);
switch (v->type) {
case VALUE_TYPE_INT8: {
return (double)v->value.i8;
}
case VALUE_TYPE_UINT8: {
return (double)v->value.u8;
}
case VALUE_TYPE_INT16: {
return (double)v->value.i16;
}
case VALUE_TYPE_UINT16: {
return (double)v->value.u16;
}
case VALUE_TYPE_INT32: {
return (double)v->value.i32;
}
case VALUE_TYPE_UINT32: {
return (double)v->value.u32;
}
case VALUE_TYPE_INT64: {
return (double)v->value.i64;
}
case VALUE_TYPE_UINT64: {
return (double)v->value.u64;
}
case VALUE_TYPE_FLOAT: {
return (double)v->value.f;
}
case VALUE_TYPE_FLOAT32: {
return (double)v->value.f32;
}
case VALUE_TYPE_DOUBLE: {
return v->value.f64;
}
case VALUE_TYPE_STRING: {
return (double)tk_atof(v->value.str);
}
case VALUE_TYPE_WSTRING: {
return (double)tk_watof(v->value.wstr);
}
case VALUE_TYPE_BOOL: {
return value_bool(v) ? 1 : 0;
}
default:
break;
}
return 0;
}
value_t* value_set_str(value_t* v, const char* value) {
return_value_if_fail(v != NULL, NULL);
v->value.str = value;
return value_init(v, VALUE_TYPE_STRING);
}
value_t* value_dup_str(value_t* v, const char* value) {
return_value_if_fail(v != NULL, NULL);
value_init(v, VALUE_TYPE_STRING);
v->value.str = tk_strdup(value);
v->free_handle = TRUE;
return v;
}
value_t* value_dup_str_with_len(value_t* v, const char* value, uint32_t len) {
return_value_if_fail(v != NULL, NULL);
value_init(v, VALUE_TYPE_STRING);
v->value.str = tk_strndup(value, len);
v->free_handle = TRUE;
return v;
}
value_t* value_set_wstr(value_t* v, const wchar_t* value) {
return_value_if_fail(v != NULL, NULL);
v->value.wstr = value;
return value_init(v, VALUE_TYPE_WSTRING);
}
value_t* value_dup_wstr(value_t* v, const wchar_t* value) {
return_value_if_fail(v != NULL, NULL);
value_init(v, VALUE_TYPE_WSTRING);
v->value.wstr = tk_wstrdup(value);
v->free_handle = TRUE;
return v;
}
const char* value_str(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_STRING, NULL);
return v->value.str;
}
const wchar_t* value_wstr(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_WSTRING, NULL);
return v->value.wstr;
}
ret_t value_copy(value_t* dst, const value_t* src) {
return_value_if_fail(dst != NULL && src != NULL, RET_BAD_PARAMS);
if (dst == src) {
return RET_OK;
}
memcpy(dst, src, sizeof(value_t));
dst->free_handle = FALSE;
return RET_OK;
}
ret_t value_deep_copy(value_t* dst, const value_t* src) {
return_value_if_fail(dst != NULL && src != NULL, RET_BAD_PARAMS);
value_copy(dst, src);
switch (dst->type) {
case VALUE_TYPE_STRING: {
dst->value.str = src->value.str != NULL ? tk_strdup(src->value.str) : NULL;
dst->free_handle = dst->value.str != NULL;
break;
}
case VALUE_TYPE_BINARY:
case VALUE_TYPE_GRADIENT:
case VALUE_TYPE_UBJSON: {
if (src->value.binary_data.data != NULL) {
uint32_t size = src->value.binary_data.size;
void* data = tk_memdup(src->value.binary_data.data, size);
return_value_if_fail(data != NULL, RET_OOM);
dst->free_handle = TRUE;
dst->value.binary_data.data = data;
dst->value.binary_data.size = size;
} else {
dst->free_handle = FALSE;
}
break;
}
case VALUE_TYPE_WSTRING: {
dst->value.wstr = tk_wstrdup(src->value.wstr);
dst->free_handle = dst->value.wstr != NULL;
break;
}
case VALUE_TYPE_OBJECT: {
tk_object_ref(dst->value.object);
dst->free_handle = dst->value.object != NULL;
break;
}
case VALUE_TYPE_POINTER_REF: {
dst->value.ptr_ref->refcount++;
dst->free_handle = TRUE;
break;
}
default:
break;
}
return RET_OK;
}
bool_t value_is_null(value_t* v) {
return v == NULL || v->type == VALUE_TYPE_INVALID;
}
int value_int(const value_t* v) {
return_value_if_fail(v->type != VALUE_TYPE_INVALID, 0);
switch (v->type) {
case VALUE_TYPE_INT8: {
return (int)v->value.i8;
}
case VALUE_TYPE_UINT8: {
return (int)v->value.u8;
}
case VALUE_TYPE_INT16: {
return (int)v->value.i16;
}
case VALUE_TYPE_UINT16: {
return (int)v->value.u16;
}
case VALUE_TYPE_INT32: {
return (int)v->value.i32;
}
case VALUE_TYPE_UINT32: {
return (int)v->value.u32;
}
case VALUE_TYPE_INT64: {
return (int)v->value.i64;
}
case VALUE_TYPE_UINT64: {
return (int)v->value.u64;
}
case VALUE_TYPE_FLOAT: {
return (int)v->value.f;
}
case VALUE_TYPE_FLOAT32: {
return (int)v->value.f32;
}
case VALUE_TYPE_DOUBLE: {
return (int)v->value.f64;
}
case VALUE_TYPE_BOOL: {
return (int)v->value.b;
}
case VALUE_TYPE_STRING: {
return tk_atoi(v->value.str);
}
case VALUE_TYPE_WSTRING: {
return tk_watoi(v->value.wstr);
}
default: {
assert(!"not supported type");
}
}
return 0;
}
bool_t value_equal(const value_t* v, const value_t* other) {
return_value_if_fail(v != NULL && other != NULL, FALSE);
if (v->type != other->type) {
return FALSE;
}
switch (v->type) {
case VALUE_TYPE_INT8: {
return v->value.i8 == other->value.i8;
}
case VALUE_TYPE_UINT8: {
return v->value.u8 == other->value.u8;
}
case VALUE_TYPE_INT16: {
return v->value.i16 == other->value.i16;
}
case VALUE_TYPE_UINT16: {
return v->value.u16 == other->value.u16;
}
case VALUE_TYPE_INT32: {
return v->value.i32 == other->value.i32;
}
case VALUE_TYPE_UINT32: {
return v->value.u32 == other->value.u32;
}
case VALUE_TYPE_INT64: {
return v->value.i64 == other->value.i64;
}
case VALUE_TYPE_BOOL: {
return v->value.b == other->value.b;
}
case VALUE_TYPE_POINTER: {
return v->value.ptr == other->value.ptr;
}
case VALUE_TYPE_POINTER_REF: {
return v->value.ptr_ref == other->value.ptr_ref;
}
case VALUE_TYPE_UINT64: {
return v->value.u64 == other->value.u64;
}
case VALUE_TYPE_FLOAT: {
return tk_fequal(v->value.f, other->value.f32);
}
case VALUE_TYPE_FLOAT32: {
return tk_fequal(v->value.f32, other->value.f32);
}
case VALUE_TYPE_DOUBLE: {
return tk_lfequal(v->value.f64, other->value.f64);
}
case VALUE_TYPE_STRING: {
return (v->value.str == other->value.str) || tk_str_eq(v->value.str, other->value.str);
}
case VALUE_TYPE_WSTRING: {
return (v->value.wstr == other->value.wstr) || tk_wstr_eq(v->value.wstr, other->value.wstr);
}
case VALUE_TYPE_BINARY:
case VALUE_TYPE_GRADIENT:
case VALUE_TYPE_UBJSON: {
return (v->value.binary_data.data == other->value.binary_data.data);
}
case VALUE_TYPE_OBJECT: {
return tk_object_compare(v->value.object, other->value.object) == 0;
}
default:
break;
}
return FALSE;
}
value_t* value_set_int(value_t* v, int32_t value) {
return value_set_int32(v, value);
}
value_t* value_create() {
return TKMEM_ZALLOC(value_t);
}
ret_t value_reset(value_t* v) {
return_value_if_fail(v != NULL, RET_BAD_PARAMS);
if (v->free_handle) {
switch (v->type) {
case VALUE_TYPE_SIZED_STRING: {
TKMEM_FREE(v->value.sized_str.str);
break;
}
case VALUE_TYPE_BINARY:
case VALUE_TYPE_UBJSON:
case VALUE_TYPE_GRADIENT: {
TKMEM_FREE(v->value.binary_data.data);
break;
}
case VALUE_TYPE_STRING: {
TKMEM_FREE(v->value.str);
break;
}
case VALUE_TYPE_WSTRING: {
TKMEM_FREE(v->value.wstr);
break;
}
case VALUE_TYPE_OBJECT: {
tk_object_t* obj = v->value.object;
v->value.object = NULL;
TK_OBJECT_UNREF(obj);
break;
}
case VALUE_TYPE_ID: {
TKMEM_FREE(v->value.id.id);
break;
}
case VALUE_TYPE_FUNC: {
TKMEM_FREE(v->value.func.func);
break;
}
case VALUE_TYPE_POINTER_REF: {
assert(v->value.ptr_ref->refcount >= 1);
v->value.ptr_ref->refcount--;
if (v->value.ptr_ref->refcount == 0) {
v->value.ptr_ref->destroy(v->value.ptr_ref->data);
TKMEM_FREE(v->value.ptr_ref);
v->value.ptr_ref = NULL;
}
break;
}
default:
break;
}
}
memset(v, 0x00, sizeof(value_t));
return RET_OK;
}
ret_t value_destroy(value_t* v) {
return_value_if_fail(v != NULL, RET_BAD_PARAMS);
value_reset(v);
TKMEM_FREE(v);
return RET_OK;
}
value_t* value_set_object(value_t* v, tk_object_t* value) {
return_value_if_fail(v != NULL && value != NULL, NULL);
v->value.object = value;
return value_init(v, VALUE_TYPE_OBJECT);
}
tk_object_t* value_object(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_OBJECT, NULL);
return v->value.object;
}
value_t* value_cast(value_t* value) {
return_value_if_fail(value != NULL, NULL);
return value;
}
value_t* value_set_token(value_t* v, uint32_t value) {
return_value_if_fail(v != NULL, NULL);
v->value.token = value;
return value_init(v, VALUE_TYPE_TOKEN);
}
uint32_t value_token(const value_t* v) {
return_value_if_fail(v != NULL, 0);
return_value_if_fail(v->type == VALUE_TYPE_TOKEN, 0);
return v->value.token;
}
value_t* value_set_sized_str(value_t* v, char* str, uint32_t size) {
return_value_if_fail(v != NULL, NULL);
v->value.sized_str.str = str;
v->value.sized_str.size = size;
return value_init(v, VALUE_TYPE_SIZED_STRING);
}
sized_str_t* value_sized_str(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_SIZED_STRING, NULL);
return (sized_str_t*)&(v->value.sized_str);
}
value_t* value_set_binary_data(value_t* v, void* data, uint32_t size) {
return_value_if_fail(v != NULL, NULL);
v->value.binary_data.data = data;
v->value.binary_data.size = size;
return value_init(v, VALUE_TYPE_BINARY);
}
value_t* value_dup_binary_data(value_t* v, const void* data, uint32_t size) {
void* new_data = NULL;
return_value_if_fail(v != NULL && data != NULL, NULL);
new_data = TKMEM_ALLOC(size);
return_value_if_fail(new_data != NULL, NULL);
memcpy(new_data, data, size);
value_init(v, VALUE_TYPE_BINARY);
v->value.binary_data.data = new_data;
v->value.binary_data.size = size;
v->free_handle = TRUE;
return v;
}
binary_data_t* value_binary_data(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_BINARY || v->type == VALUE_TYPE_GRADIENT ||
v->type == VALUE_TYPE_UBJSON,
NULL);
return (binary_data_t*)&(v->value.binary_data);
}
value_t* value_set_ubjson(value_t* v, void* data, uint32_t size) {
return_value_if_fail(v != NULL, NULL);
v->value.binary_data.data = data;
v->value.binary_data.size = size;
return value_init(v, VALUE_TYPE_UBJSON);
}
binary_data_t* value_ubjson(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_UBJSON, NULL);
return (binary_data_t*)&(v->value.binary_data);
}
value_t* value_set_gradient(value_t* v, void* data, uint32_t size) {
return_value_if_fail(v != NULL, NULL);
v->value.binary_data.data = data;
v->value.binary_data.size = size;
return value_init(v, VALUE_TYPE_GRADIENT);
}
binary_data_t* value_gradient(const value_t* v) {
return_value_if_fail(v != NULL, NULL);
return_value_if_fail(v->type == VALUE_TYPE_GRADIENT, NULL);
return (binary_data_t*)&(v->value.binary_data);
}
const char* value_str_ex(const value_t* v, char* buff, uint32_t size) {
return_value_if_fail(v != NULL && buff != NULL && size > 0, NULL);
if (v->type == VALUE_TYPE_STRING) {
return value_str(v);
} else if (v->type == VALUE_TYPE_DOUBLE || v->type == VALUE_TYPE_FLOAT32 ||
v->type == VALUE_TYPE_FLOAT) {
tk_snprintf(buff, size, "%lf", value_double(v));
} else if (v->type == VALUE_TYPE_WSTRING) {
tk_utf8_from_utf16(value_wstr(v), buff, size);
} else if (v->type == VALUE_TYPE_BOOL) {
tk_snprintf(buff, size, "%s", value_bool(v) ? "true" : "false");
} else if (v->type == VALUE_TYPE_UINT8 || v->type == VALUE_TYPE_UINT16 ||
v->type == VALUE_TYPE_UINT32) {
tk_snprintf(buff, size, "%u", value_uint32(v));
} else if (v->type == VALUE_TYPE_UINT64) {
tk_snprintf(buff, size, "%" PRIu64, value_uint64(v));
} else if (v->type == VALUE_TYPE_INT64) {
tk_snprintf(buff, size, "%" PRId64, value_int64(v));
} else if (v->type == VALUE_TYPE_ID) {
assert(v->value.id.id != NULL);
return v->value.id.id;
} else if (v->type == VALUE_TYPE_BINARY) {
binary_data_t* bin = value_binary_data(v);
if (bin != NULL) {
tk_snprintf(buff, size, "binary(%p:%u)", bin->data, bin->size);
} else {
tk_snprintf(buff, size, "(null)");
}
} else if (v->type == VALUE_TYPE_FUNC) {
return "func";
} else if (v->type == VALUE_TYPE_FUNC_DEF) {
return "func_def";
} else if (v->type == VALUE_TYPE_POINTER || v->type == VALUE_TYPE_POINTER_REF) {
tk_snprintf(buff, size, "%p", value_pointer(v));
} else if (v->type == VALUE_TYPE_OBJECT) {
tk_object_t* obj = value_object(v);
if (obj != NULL) {
tk_snprintf(buff, size, "object(%p:%s)", obj, obj->vt->type);
}
} else if (v->type == VALUE_TYPE_INVALID) {
*buff = '\0';
return TK_VALUE_UNDEFINED;
} else {
tk_snprintf(buff, size, "%d", value_int(v));
}
return buff;
}
uint32_t value_type_size(value_type_t type) {
switch (type) {
case VALUE_TYPE_BOOL: {
return sizeof(bool_t);
}
case VALUE_TYPE_INT8: {
return sizeof(int8_t);
}
case VALUE_TYPE_UINT8: {
return sizeof(uint8_t);
}
case VALUE_TYPE_INT16: {
return sizeof(int16_t);
}
case VALUE_TYPE_UINT16: {
return sizeof(uint16_t);
}
case VALUE_TYPE_INT32: {
return sizeof(int32_t);
}
case VALUE_TYPE_UINT32: {
return sizeof(uint32_t);
}
case VALUE_TYPE_INT64: {
return sizeof(int64_t);
}
case VALUE_TYPE_UINT64: {
return sizeof(uint64_t);
}
case VALUE_TYPE_FLOAT: {
return sizeof(float_t);
}
case VALUE_TYPE_FLOAT32: {
return sizeof(float);
}
case VALUE_TYPE_DOUBLE: {
return sizeof(double);
}
case VALUE_TYPE_OBJECT:
case VALUE_TYPE_STRING:
case VALUE_TYPE_WSTRING:
case VALUE_TYPE_POINTER:
case VALUE_TYPE_POINTER_REF: {
return sizeof(void*);
}
case VALUE_TYPE_BINARY: {
return sizeof(binary_data_t);
}
case VALUE_TYPE_SIZED_STRING: {
return sizeof(sized_str_t);
}
default: {
return sizeof(void*);
}
}
}
const char* value_id(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_ID, NULL);
return v->value.id.id;
}
value_t* value_set_id(value_t* v, const char* value, uint32_t len) {
return_value_if_fail(v != NULL && value != NULL, NULL);
v->value.id.id = tk_strndup(value, len);
v->value.id.index = -1;
v->value.id.suboffset = 0;
value_init(v, VALUE_TYPE_ID);
v->free_handle = TRUE;
return v;
}
void* value_func(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_FUNC, NULL);
return v->value.func.func;
}
value_t* value_set_func(value_t* v, void* value) {
return_value_if_fail(v != NULL && value != NULL, NULL);
v->value.func.func = value;
v->value.func.memo = 0;
return value_init(v, VALUE_TYPE_FUNC);
}
void* value_func_def(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_FUNC_DEF, NULL);
return v->value.ptr;
}
value_t* value_set_func_def(value_t* v, void* value) {
return_value_if_fail(v != NULL && value != NULL, NULL);
v->value.ptr = value;
return value_init(v, VALUE_TYPE_FUNC_DEF);
}
void* value_bitmap(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_BITMAP, NULL);
return v->value.bitmap;
}
value_t* value_set_bitmap(value_t* v, void* bitmap) {
return_value_if_fail(v != NULL && bitmap != NULL, NULL);
v->value.bitmap = bitmap;
return value_init(v, VALUE_TYPE_BITMAP);
}
rect_t* value_rect(const value_t* v) {
return_value_if_fail(v != NULL && v->type == VALUE_TYPE_RECT, NULL);
return (rect_t*)(&(v->value.rect));
}
value_t* value_set_rect(value_t* v, rect_t r) {
return_value_if_fail(v != NULL, NULL);
v->value.rect = r;
return value_init(v, VALUE_TYPE_RECT);
}
/*operations*/
ret_t value_lshift(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
value_set_int8(result, value_int8(v) << n);
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(result, value_uint8(v) << n);
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(result, value_int16(v) << n);
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(result, value_uint16(v) << n);
break;
}
case VALUE_TYPE_INT32: {
value_set_int32(result, value_int32(v) << n);
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(result, value_uint32(v) << n);
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(result, value_int64(v) << n);
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(result, value_uint64(v) << n);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_rshift(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
value_set_int8(result, value_int8(v) >> n);
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(result, value_uint8(v) >> n);
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(result, value_int16(v) >> n);
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(result, value_uint16(v) >> n);
break;
}
case VALUE_TYPE_INT32: {
value_set_int32(result, value_int32(v) >> n);
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(result, value_uint32(v) >> n);
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(result, value_int64(v) >> n);
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(result, value_uint64(v) >> n);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_lshift_r(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
n = n % 8;
value_set_int8(result, (vv >> (8 - n)) | (vv << n));
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
n = n % 8;
value_set_uint8(result, (vv >> (8 - n)) | (vv << n));
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
n = n % 16;
value_set_int16(result, (vv >> (16 - n)) | (vv << n));
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
n = n % 16;
value_set_uint16(result, (vv >> (16 - n)) | (vv << n));
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
n = n % 32;
value_set_int32(result, (vv >> (32 - n)) | (vv << n));
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
n = n % 32;
value_set_uint32(result, (vv >> (32 - n)) | (vv << n));
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
n = n % 64;
value_set_int64(result, (vv >> (64 - n)) | (vv << n));
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
n = n % 64;
value_set_uint64(result, (vv >> (64 - n)) | (vv << n));
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_rshift_r(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
n = n % 8;
value_set_int8(result, (vv << (8 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
n = n % 8;
value_set_uint8(result, (vv << (8 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
n = n % 16;
value_set_int16(result, (vv << (16 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
n = n % 16;
value_set_uint16(result, (vv << (16 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
n = n % 32;
value_set_int32(result, (vv << (32 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
n = n % 32;
value_set_uint32(result, (vv << (32 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
n = n % 64;
value_set_int64(result, (vv << (64 - n)) | (vv >> n));
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
n = n % 64;
value_set_uint64(result, (vv << (64 - n)) | (vv >> n));
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_get_bit(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
bool_t bit = TK_TEST_BIT(vv, n);
value_set_bool(result, bit);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
#define TK_SET_OR_CLEAR_BIT(v, n, b) \
if (b) { \
TK_SET_BIT(v, n); \
} else { \
TK_CLEAR_BIT(v, n); \
}
ret_t value_set_bit(value_t* v, value_t* result, uint32_t n, bool_t bit) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
TK_SET_OR_CLEAR_BIT(vv, n, bit);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_toggle_bit(value_t* v, value_t* result, uint32_t n) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
TK_TOGGLE_BIT(vv, n);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
TK_TOGGLE_BIT(vv, n);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
TK_TOGGLE_BIT(vv, n);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
TK_TOGGLE_BIT(vv, n);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
TK_TOGGLE_BIT(vv, n);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
TK_TOGGLE_BIT(vv, n);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
TK_TOGGLE_BIT(vv, n);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
TK_TOGGLE_BIT(vv, n);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_bit_not(value_t* v, value_t* result) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_BOOL: {
bool_t vv = value_bool(v);
value_set_bool(result, !vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
value_set_int8(result, ~vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
value_set_uint8(result, ~vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
value_set_int16(result, ~vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
value_set_uint16(result, ~vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
value_set_int32(result, ~vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
value_set_uint32(result, ~vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
value_set_int64(result, ~vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
value_set_uint64(result, ~vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_bit_or(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
bool_t vv = value_bool(v) || value_bool(other);
value_set_bool(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v) | value_int8(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v) | value_uint8(other);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v) | value_int16(other);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v) | value_uint16(other);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) | value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) | value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) | value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) | value_uint64(other);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_bit_and(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
bool_t vv = value_bool(v) && value_bool(other);
value_set_bool(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v) & value_int8(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v) & value_uint8(other);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v) & value_int16(other);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v) & value_uint16(other);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) & value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) & value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) & value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) & value_uint64(other);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_bit_xor(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
bool_t vv = value_bool(v) ^ value_bool(other);
value_set_bool(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v) ^ value_int8(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v) ^ value_uint8(other);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v) ^ value_int16(other);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v) ^ value_uint16(other);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) ^ value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) ^ value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) ^ value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) ^ value_uint64(other);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_abs(value_t* v, value_t* result) {
ret_t ret = RET_OK;
return_value_if_fail(v != NULL && result != NULL, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_BOOL: {
bool_t vv = value_bool(v);
value_set_bool(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v);
value_set_int8(result, abs(vv));
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v);
value_set_uint8(result, (vv));
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v);
value_set_int16(result, abs(vv));
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v);
value_set_uint16(result, (vv));
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v);
value_set_int32(result, abs(vv));
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v);
value_set_uint32(result, (vv));
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v);
value_set_int64(result, vv > 0 ? vv : -vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v);
value_set_uint64(result, (vv));
break;
}
case VALUE_TYPE_FLOAT32: {
float vv = value_float32(v);
value_set_float32(result, vv >= 0 ? vv : -vv);
break;
}
case VALUE_TYPE_FLOAT: {
float_t vv = value_float(v);
value_set_float(result, vv >= 0 ? vv : -vv);
break;
}
case VALUE_TYPE_DOUBLE: {
double vv = value_double(v);
value_set_double(result, vv >= 0 ? vv : -vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, v->type);
break;
}
}
return ret;
}
ret_t value_add(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
int8_t vv = value_bool(v) + value_bool(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int16_t vv = value_int8(v) + value_int8(other);
if (vv >= INT8_MIN && vv <= INT8_MAX) {
value_set_int8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_UINT8: {
int16_t vv = value_uint8(v) + value_uint8(other);
if (vv >= 0 && vv <= UINT8_MAX) {
value_set_uint8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_INT16: {
int32_t vv = value_int16(v) + value_int16(other);
if (vv >= INT16_MIN && vv <= INT16_MAX) {
value_set_int16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_UINT16: {
int32_t vv = value_uint16(v) + value_uint16(other);
if (vv >= 0 && vv <= UINT16_MAX) {
value_set_uint16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) + value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) + value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) + value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) + value_uint64(other);
value_set_uint64(result, vv);
break;
}
case VALUE_TYPE_FLOAT32: {
double vv = value_float32(v) + value_float32(other);
value_set_float32(result, vv);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_DOUBLE: {
double vv = value_double(v) + value_double(other);
value_set_double(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, type);
break;
}
}
return ret;
}
ret_t value_sub(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
int8_t vv = value_bool(v) - value_bool(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int16_t vv = value_int8(v) - value_int8(other);
if (vv >= INT8_MIN && vv <= INT8_MAX) {
value_set_int8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_UINT8: {
int16_t vv = value_uint8(v) - value_uint8(other);
if (vv >= 0 && vv <= UINT8_MAX) {
value_set_uint8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_INT16: {
int32_t vv = value_int16(v) - value_int16(other);
if (vv >= INT16_MIN && vv <= INT16_MAX) {
value_set_int16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_UINT16: {
int32_t vv = value_uint16(v) - value_uint16(other);
if (vv >= 0 && vv <= UINT16_MAX) {
value_set_uint16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) - value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) - value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) - value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) - value_uint64(other);
value_set_uint64(result, vv);
break;
}
case VALUE_TYPE_FLOAT32: {
double vv = value_float32(v) - value_float32(other);
value_set_float32(result, vv);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_DOUBLE: {
double vv = value_double(v) - value_double(other);
value_set_double(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, type);
break;
}
}
return ret;
}
ret_t value_mul(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
int8_t vv = value_bool(v) * value_bool(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int16_t vv = value_int8(v) * value_int8(other);
if (vv >= INT8_MIN && vv <= INT8_MAX) {
value_set_int8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_UINT8: {
int16_t vv = value_uint8(v) * value_uint8(other);
if (vv >= 0 && vv <= UINT8_MAX) {
value_set_uint8(result, vv);
} else {
value_set_int16(result, vv);
}
break;
}
case VALUE_TYPE_INT16: {
int32_t vv = value_int16(v) * value_int16(other);
if (vv >= INT16_MIN && vv <= INT16_MAX) {
value_set_int16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_UINT16: {
int32_t vv = value_uint16(v) * value_uint16(other);
if (vv >= 0 && vv <= UINT16_MAX) {
value_set_uint16(result, vv);
} else {
value_set_int32(result, vv);
}
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) * value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) * value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) * value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) * value_uint64(other);
value_set_uint64(result, vv);
break;
}
case VALUE_TYPE_FLOAT32: {
double vv = value_float32(v) * value_float32(other);
value_set_float32(result, vv);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_DOUBLE: {
double vv = value_double(v) * value_double(other);
value_set_double(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, type);
break;
}
}
return ret;
}
ret_t value_div(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
int8_t vv = value_bool(v) / value_bool(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v) / value_int8(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v) / value_uint8(other);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v) / value_int16(other);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v) / value_uint16(other);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) / value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) / value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) / value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) / value_uint64(other);
value_set_uint64(result, vv);
break;
}
case VALUE_TYPE_FLOAT32: {
double vv = value_float32(v) / value_float32(other);
value_set_float32(result, vv);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_DOUBLE: {
double vv = value_double(v) / value_double(other);
value_set_double(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, type);
break;
}
}
return ret;
}
ret_t value_mod(value_t* v, value_t* other, value_t* result) {
ret_t ret = RET_OK;
uint32_t type = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
type = tk_max_int((int)(v->type), (int)(other->type));
switch (type) {
case VALUE_TYPE_BOOL: {
int8_t vv = value_bool(v) % value_bool(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_INT8: {
int8_t vv = value_int8(v) % value_int8(other);
value_set_int8(result, vv);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t vv = value_uint8(v) % value_uint8(other);
value_set_uint8(result, vv);
break;
}
case VALUE_TYPE_INT16: {
int16_t vv = value_int16(v) % value_int16(other);
value_set_int16(result, vv);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t vv = value_uint16(v) % value_uint16(other);
value_set_uint16(result, vv);
break;
}
case VALUE_TYPE_INT32: {
int32_t vv = value_int32(v) % value_int32(other);
value_set_int32(result, vv);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t vv = value_uint32(v) % value_uint32(other);
value_set_uint32(result, vv);
break;
}
case VALUE_TYPE_INT64: {
int64_t vv = value_int64(v) % value_int64(other);
value_set_int64(result, vv);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t vv = value_uint64(v) % value_uint64(other);
value_set_uint64(result, vv);
break;
}
default: {
ret = RET_BAD_PARAMS;
log_debug("%s not supported type:%d\n", __FUNCTION__, type);
break;
}
}
return ret;
}
ret_t value_expt(value_t* v, value_t* other, value_t* result) {
int32_t e = 0;
uint32_t n = 0;
double b = 0;
double r = 0;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
return_value_if_fail(v != NULL && other != NULL, RET_BAD_PARAMS);
b = value_double(v);
if (tk_fequal(b, 0)) {
value_set_double(result, 0);
return RET_OK;
}
e = value_int(other);
if (e == 0) {
value_set_double(result, 1);
return RET_OK;
} else if (e < 0) {
n = -e;
} else {
n = e;
}
r = b;
n--;
/*TODO: optimize*/
while (n > 0) {
r = r * b;
n--;
}
if (e < 0) {
if (tk_fequal(r, 0)) {
value_set_double(result, INFINITY);
} else {
value_set_double(result, 1 / r);
}
} else {
value_set_double(result, r);
}
return RET_OK;
}
ret_t value_min(value_t* arr, uint32_t size, value_t* result) {
uint32_t i = 0;
uint32_t r = 0;
uint32_t type = 0;
return_value_if_fail(arr != NULL && size > 0 && result != NULL, RET_BAD_PARAMS);
type = arr[0].type;
if (type >= VALUE_TYPE_INT8 && type < VALUE_TYPE_UINT64) {
for (i = 0; i < size; i++) {
if (value_int64(arr + i) < value_int64(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_UINT64) {
for (i = 0; i < size; i++) {
if (value_uint64(arr + i) < value_uint64(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_STRING) {
for (i = 0; i < size; i++) {
if (tk_strcmp(value_str(arr + i), value_str(arr + r)) < 0) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_WSTRING) {
for (i = 0; i < size; i++) {
if (tk_wstrcmp(value_wstr(arr + i), value_wstr(arr + r)) < 0) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type >= VALUE_TYPE_FLOAT && type <= VALUE_TYPE_DOUBLE) {
for (i = 0; i < size; i++) {
if (value_double(arr + i) < value_double(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else {
log_warn("not impl for this type");
return RET_NOT_IMPL;
}
}
ret_t value_max(value_t* arr, uint32_t size, value_t* result) {
uint32_t i = 0;
uint32_t r = 0;
uint32_t type = 0;
return_value_if_fail(arr != NULL && size > 0 && result != NULL, RET_BAD_PARAMS);
type = arr[0].type;
if (type >= VALUE_TYPE_INT8 && type < VALUE_TYPE_UINT64) {
for (i = 0; i < size; i++) {
if (value_int64(arr + i) > value_int64(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_UINT64) {
for (i = 0; i < size; i++) {
if (value_uint64(arr + i) > value_uint64(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_STRING) {
for (i = 0; i < size; i++) {
if (tk_strcmp(value_str(arr + i), value_str(arr + r)) > 0) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type == VALUE_TYPE_WSTRING) {
for (i = 0; i < size; i++) {
if (tk_wstrcmp(value_wstr(arr + i), value_wstr(arr + r)) > 0) {
r = i;
}
}
return value_copy(result, arr + r);
} else if (type >= VALUE_TYPE_FLOAT && type <= VALUE_TYPE_DOUBLE) {
for (i = 0; i < size; i++) {
if (value_double(arr + i) > value_double(arr + r)) {
r = i;
}
}
return value_copy(result, arr + r);
} else {
log_warn("not impl for this type");
return RET_NOT_IMPL;
}
}
static const char* s_type_names[] = {[VALUE_TYPE_BOOL] = "bool",
[VALUE_TYPE_INT8] = "int8",
[VALUE_TYPE_INT16] = "int16",
[VALUE_TYPE_INT32] = "int32",
[VALUE_TYPE_INT64] = "int64",
[VALUE_TYPE_UINT8] = "uint8",
[VALUE_TYPE_UINT16] = "uint16",
[VALUE_TYPE_UINT32] = "uint32",
[VALUE_TYPE_UINT64] = "uint64",
[VALUE_TYPE_FLOAT] = "float",
[VALUE_TYPE_FLOAT32] = "float32",
[VALUE_TYPE_DOUBLE] = "double",
[VALUE_TYPE_STRING] = "char*",
[VALUE_TYPE_WSTRING] = "wchar_t*",
[VALUE_TYPE_POINTER] = "pointer",
[VALUE_TYPE_OBJECT] = "object",
[VALUE_TYPE_BINARY] = "binary",
[VALUE_TYPE_UBJSON] = "ubjson",
[VALUE_TYPE_ID] = "id",
[VALUE_TYPE_TOKEN] = "token",
[VALUE_TYPE_RECT] = "rect",
[VALUE_TYPE_FUNC] = "func",
[VALUE_TYPE_GRADIENT] = "gradient",
[VALUE_TYPE_FUNC_DEF] = "func_def",
[VALUE_TYPE_BITMAP] = "bitmap",
[VALUE_TYPE_SIZED_STRING] = "char(with size)*",
[VALUE_TYPE_POINTER_REF] = "pointer ref"};
const char* value_type_name(value_type_t type) {
return s_type_names[type];
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/stream_const.h
|
/**
* File: tk_iostream.h
* Author: AWTK Develop Team
* Brief: input/ouput stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_IOSTREAM_CONST_H
#define TK_IOSTREAM_CONST_H
BEGIN_C_DECLS
#define TK_STREAM_PROP_FD "fd"
#define TK_STREAM_PROP_IS_OK "is_ok"
#define TK_STREAM_PROP_IS_EOS "is_eos"
#define TK_STREAM_PROP_TIMEOUT "timeout"
#define TK_STREAM_PROP_RETRY_TIMES "retry_times"
#define TK_STREAM_PROP_HAS_BUFFERED_DATA "has_buffered_data"
#define TK_STREAM_PROP_COMPRESS_THRESHOLD "compress_threshold"
#define TK_STREAM_CMD_IFLUSH "iflush"
#define TK_STREAM_CMD_OFLUSH "oflush"
#define TK_ISTREAM_DEFAULT_TIMEOUT 3000
#define TK_OSTREAM_DEFAULT_TIMEOUT 1000
END_C_DECLS
#endif /*TK_IOSTREAM_CONST_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/path.h
|
/**
* File: path.h
* Author: AWTK Develop Team
* Brief: path
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-24 Li XianJing <[email protected]> created
*
*/
#ifndef TK_PATH_H
#define TK_PATH_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class path_t
* @annotation ["fake"]
* 路径相关的工具函数。
*/
/**
* @method path_basename
*
* 返回文件名。
*
* @param {const char*} path 路径。
* @param {char*} result 用于返回文件名。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_basename(const char* path, char* result, int32_t size);
/**
* @method path_basename_ex
*
* 返回文件名。
*
* @param {const char*} path 路径。
* @param {bool_t} remove_ext_name 是否去掉扩展名。
* @param {char*} result 用于返回文件名。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_basename_ex(const char* path, bool_t remove_ext_name, char* result, int32_t size);
/**
* @method path_extname
*
* 返回文件扩展名。
*
* @param {const char*} path 路径。
* @param {char*} result 用于返回文件扩展名。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_extname(const char* path, char* result, int32_t size);
/**
* @method path_extname_is
*
* ```c
* assert(path_extname_is("test.jpg", ".jpg"));
* assert(path_extname_is("test.JPG", ".jpg"));
* ```
* 检查是否是指定的扩展名。
*
* @param {const char*} path 路径。
* @param {const char*} extname 扩展名。
*
* @return {bool_t} 返回TRUE表示是，否则表示不是。
*/
bool_t path_extname_is(const char* path, const char* extname);
/**
* @method path_dirname
*
* 返回目录。
*
* @param {const char*} path 路径。
* @param {char*} result 用于返回目录。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_dirname(const char* path, char* result, int32_t size);
/**
* @method path_normalize
*
* 规范路径字符形式。
*
* @param {const char*} path 路径。
* @param {char*} result 用于返回规范后的路径。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_normalize(const char* path, char* result, int32_t size);
/**
* @method path_abs
*
* 返回绝对路径。
*
* @param {const char*} path 路径。
* @param {char*} result 用于返回绝对路径。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_abs(const char* path, char* result, int32_t size);
/**
* @method path_is_abs
*
* 判断路径是否为绝对路径。
*
* @param {const char*} path 路径。
*
* @return {bool_t} 返回FALSE表示不是绝对路径，否则表示是绝对路径。
*/
bool_t path_is_abs(const char* path);
/**
* @method path_build
*
* 构造路径。
*
*> 可变参数为字符串，以NULL参数结束。
*
* @param {char*} result 用于返回路径。
* @param {int32_t} size 缓冲区大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_build(char* result, int32_t size, ...);
/**
* @method path_replace_basename
*
* 替换文件名。
*
* @param {char*} result 用于返回结果。
* @param {int32_t} size 缓冲区大小。
* @param {const char*} filename 原始文件路径。
* @param {const char*} basename 替换后的文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_replace_basename(char* result, int32_t size, const char* filename, const char* basename);
/**
* @method path_replace_extname
*
* 替换文件扩展名。
*
* @param {char*} result 用于返回结果。
* @param {int32_t} size 缓冲区大小。
* @param {const char*} filename 原始文件路径。
* @param {const char*} extname 替换后的文件扩展名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_replace_extname(char* result, int32_t size, const char* filename, const char* extname);
/**
* @method path_cwd
*
* 获取当前所在目录。
*
* @param {char*} path 保存当前所在目录的路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_cwd(char path[MAX_PATH + 1]);
/**
* @method path_exe
*
* 获取可执行文件所在目录。
*
* @param {char*} path 保存可执行文件所在目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_exe(char path[MAX_PATH + 1]);
/**
* @method path_app_root
*
* 获取app所在目录。
*
* @param {char*} path 保存app所在目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_app_root(char path[MAX_PATH + 1]);
/**
* @method path_app_root_ex
*
* 获取app所在目录，并追加subpath到后面。
*
* @param {char*} path 保存app所在目录。
* @param {const char*} subpath 子目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_app_root_ex(char path[MAX_PATH + 1], const char* subpath);
/**
* @method path_exist
*
* 判断目录是否存在。
*
* @param {const char*} path 目录。
*
* @return {bool_t} 返回TRUE表示成功，否则表示失败。
*/
bool_t path_exist(const char* path);
/**
* @method path_remove_last_slash
*
* 去掉后面的/和\\字符。
*
* @param {char*} path 目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_remove_last_slash(char* path);
/**
* @method path_prepend_app_root
* 将前面路径加上app root。
* @param {char*} full_path 用于返回完整路径。
* @param {const char*} path 路径。
*
* @return {const char*} 返回完整路径。
*/
const char* path_prepend_app_root(char full_path[MAX_PATH + 1], const char* path);
/**
* @method path_prepend_temp_path
* 将前面路径加上临时文件目录。
* @param {char*} full_path 用于返回完整路径。
* @param {const char*} path 路径。
*
* @return {const char*} 返回完整路径。
*/
const char* path_prepend_temp_path(char full_path[MAX_PATH + 1], const char* path);
/**
* @method path_prepend_user_storage_path
* 将前面路径加上用户目录。
* @param {char*} full_path 用于返回完整路径。
* @param {const char*} path 路径。
*
* @return {const char*} 返回完整路径。
*/
const char* path_prepend_user_storage_path(char full_path[MAX_PATH + 1], const char* path);
/**
* @method path_abs_normalize
* 将相对路径转换为绝对路径并规范路径字符形式。
* @param {const char*} filename 相对路径。
* @param {char*} result 用于返回绝对路径。
* @param {int32_t} size 缓冲区大小。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_abs_normalize(const char* filename, char* result, int32_t size);
/**
* @method path_expand_vars
* 将路径中的变量展开。
*
*```
* ${app_dir} -> app 文件目录。
* ${temp_dir} -> 临时文件目录。
* ${user_dir} -> 用户目录。
*```
* @param {const char*} filename 相对路径。
* @param {char*} result 用于返回结果。
* @param {int32_t} size 缓冲区大小。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t path_expand_vars(const char* filename, char* result, int32_t size);
/**
* @method path_abs_normalize_with_root
* 将相对路径转换为绝对路径并规范路径字符形式。
* @param {const char*} root 根目录。
* @param {const char*} rel_filename 相对路径。
* @param {char*} filename 用于返回绝对路径。
* @return {const char*} 返回绝对路径。
*/
const char* path_abs_normalize_with_root(const char* root, const char* rel_filename,
char filename[MAX_PATH + 1]);
END_C_DECLS
#endif /*TK_PATH_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/waitable_action_darray.h
|
/**
* File: waitable_action_darray.h
* Author: AWTK Develop Team
* Brief: waitable_action_darray
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-3-25 vih created
*
*/
#ifndef TK_WAITABLE_ACTION_DARRAY_H
#define TK_WAITABLE_ACTION_DARRAY_H
#include "tkc/mutex.h"
#include "tkc/mutex.h"
#include "tkc/darray.h"
#include "tkc/qaction.h"
#include "tkc/semaphore.h"
BEGIN_C_DECLS
/**
* @class waitable_action_darray_t
*
* waitable actionqueue
*/
typedef struct _waitable_action_darray_t {
darray_t* darray;
tk_mutex_t* mutex;
tk_semaphore_t* sema_recv;
tk_semaphore_t* sema_send;
} waitable_action_darray_t;
/**
* @method waitable_action_darray_create
* @annotation ["constructor"]
* 创建waitable_action_darray对象。
*
* @param {uint16_t} capacity action的容量。
*
* @return {waitable_action_darray_t*} waitable_action_darray对象。
*/
waitable_action_darray_t* waitable_action_darray_create(uint16_t capacity);
/**
* @method waitable_action_darray_recv
* 接收一个请求。
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_t**} action 用于返回action对象。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_darray_recv(waitable_action_darray_t* q, qaction_t** action,
uint32_t timeout_ms);
/**
* @method waitable_action_darray_send
* 发送一个请求。
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_t*} action action对象。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_darray_send(waitable_action_darray_t* q, qaction_t* action,
uint32_t timeout_ms);
/**
* @method waitable_action_darray_find
* 查找 qaction
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_exec_t} exec action 中的函数回调
*
* @return {qaction_t*} 返回 qaction_t对象
*/
qaction_t* waitable_action_darray_find(waitable_action_darray_t* q, qaction_exec_t exec);
/**
* @method waitable_action_darray_find_ex
* 查找 qaction
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {tk_compare_t} cmp 比较函数
* @param {void*} ctx 比较函数参数
*
* @return {qaction_t*} 返回 qaction_t对象
*/
qaction_t* waitable_action_darray_find_ex(waitable_action_darray_t* q, tk_compare_t cmp, void* ctx);
/**
* @method waitable_action_darray_replace
* 替换 qaction，旧的 qaction 会被销毁
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_t*} new_action 新的 action 对象
*
* @return {ret_t} 返回 ret_t值
*/
ret_t waitable_action_darray_replace(waitable_action_darray_t* q, qaction_t* new_action);
/**
* @method waitable_action_darray_replace_ex
* 替换 qaction
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_exec_t} exec 旧 action 中的函数回调
* @param {qaction_t*} new_action 新的 action 对象
*
* @return {ret_t} 返回 ret_t值
*/
ret_t waitable_action_darray_replace_ex(waitable_action_darray_t* q, qaction_exec_t exec,
qaction_t* new_action);
/**
* @method waitable_action_darray_remove
* 从 darray 中移除并销毁 qaction 对象
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {qaction_exec_t} exec action 中的函数回调
*
* @return {ret_t} 返回 ret_t值
*/
ret_t waitable_action_darray_remove(waitable_action_darray_t* q, qaction_exec_t exec);
/**
* @method waitable_action_darray_remove_ex
* 从 darray 中移除并销毁 qaction 对象
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
* @param {tk_compare_t} cmp 比较函数
* @param {void*} ctx 比较函数参数
*
* @return {ret_t} 返回 ret_t值
*/
ret_t waitable_action_darray_remove_ex(waitable_action_darray_t* q, tk_compare_t cmp, void* ctx);
/**
* @method waitable_action_darray_destroy
* 销毁。
*
* @param {waitable_action_darray_t*} q waitable_action_darray对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_darray_destroy(waitable_action_darray_t* q);
END_C_DECLS
#endif /*TK_WAITABLE_ACTION_DARRAY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event.c
|
/**
* File: event.c
* Author: AWTK Develop Team
* Brief: event structs
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-03-02 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/event.h"
#include "tkc/time_now.h"
event_t event_init(uint32_t type, void* target) {
event_t e;
memset(&e, 0x00, sizeof(e));
e.type = type;
e.target = target;
e.time = time_now_ms();
e.size = sizeof(e);
return e;
}
event_t* event_cast(event_t* event) {
return event;
}
event_t* event_create(uint32_t type) {
event_t* e = TKMEM_ZALLOC(event_t);
return_value_if_fail(e != NULL, NULL);
*e = event_init(type, NULL);
return e;
}
event_t* event_clone(event_t* event) {
event_t* e = NULL;
return_value_if_fail(event != NULL, NULL);
e = TKMEM_ALLOC(event->size);
return_value_if_fail(e != NULL, NULL);
memcpy(e, event, event->size);
return e;
}
ret_t event_destroy(event_t* event) {
return_value_if_fail(event != NULL, RET_BAD_PARAMS);
TKMEM_FREE(event);
return RET_OK;
}
prop_change_event_t* prop_change_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_PROP_CHANGED || event->type == EVT_PROP_WILL_CHANGE,
NULL);
return (prop_change_event_t*)event;
}
event_t* prop_change_event_init(prop_change_event_t* event, uint32_t type, const char* name,
const value_t* value) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(type, NULL);
event->e.size = sizeof(*event);
event->name = name;
event->value = value;
return (event_t*)(event);
}
progress_event_t* progress_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_PROGRESS, NULL);
return (progress_event_t*)event;
}
event_t* progress_event_init(progress_event_t* event, uint32_t percent) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(EVT_PROGRESS, NULL);
event->e.size = sizeof(*event);
event->percent = percent;
return (event_t*)(event);
}
done_event_t* done_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_DONE, NULL);
return (done_event_t*)event;
}
event_t* done_event_init(done_event_t* event, ret_t result) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(EVT_DONE, NULL);
event->e.size = sizeof(*event);
event->result = result;
return (event_t*)(event);
}
error_event_t* error_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_ERROR, NULL);
return (error_event_t*)event;
}
event_t* error_event_init(error_event_t* event, int32_t code, const char* message) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(EVT_ERROR, NULL);
event->e.size = sizeof(*event);
event->code = code;
event->message = message;
return (event_t*)(event);
}
cmd_exec_event_t* cmd_exec_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_CMD_WILL_EXEC || event->type == EVT_CMD_EXECED ||
event->type == EVT_CMD_CAN_EXEC,
NULL);
return (cmd_exec_event_t*)event;
}
event_t* cmd_exec_event_init(cmd_exec_event_t* event, uint32_t type, const char* name,
const char* value) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(type, NULL);
event->e.size = sizeof(*event);
event->name = name;
event->args = value;
return (event_t*)(event);
}
uint32_t event_get_type(event_t* event) {
return_value_if_fail(event != NULL, EVT_NONE);
return event->type;
}
value_change_event_t* value_change_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type >= EVT_VALUE_WILL_CHANGE && event->type <= EVT_VALUE_CHANGING,
NULL);
return_value_if_fail(event->size == sizeof(value_change_event_t), NULL);
return (value_change_event_t*)event;
}
event_t* value_change_event_init(value_change_event_t* event, uint32_t type, void* target) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(type, target);
event->e.size = sizeof(*event);
return (event_t*)event;
}
log_message_event_t* log_message_event_cast(event_t* event) {
return_value_if_fail(event != NULL, NULL);
return_value_if_fail(event->type == EVT_LOG_MESSAGE, NULL);
return_value_if_fail(event->size == sizeof(log_message_event_t), NULL);
return (log_message_event_t*)event;
}
event_t* log_message_event_init(log_message_event_t* event, tk_log_level_t level,
const char* message) {
return_value_if_fail(event != NULL, NULL);
memset(event, 0x00, sizeof(*event));
event->e = event_init(EVT_LOG_MESSAGE, NULL);
event->e.size = sizeof(*event);
event->level = level;
event->message = message;
return (event_t*)event;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_pool.h
|
/**
* File: mem_pool.h
* Author: AWTK Develop Team
* Brief: mem_pool
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_POOL_H
#define TK_MEM_POOL_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
typedef struct _mem_pool_t {
uint32_t block_size : 8;
uint32_t bits_size : 8;
uint32_t block_nr : 16;
uint32_t min_block_size : 16;
uint32_t used : 16;
uint32_t* bits;
uint8_t* start;
} mem_pool_t;
static inline bool_t mem_pool_match_size(mem_pool_t* pool, uint32_t size) {
return size >= pool->min_block_size && size <= pool->block_size;
}
static inline uint32_t mem_pool_get_bits_size(uint32_t block_nr) {
return (block_nr / 32 + 2) & 0xfffffffe;
}
static inline uint32_t mem_pool_get_min_size(uint32_t block_size, uint32_t block_nr) {
uint32_t bits_size = mem_pool_get_bits_size(block_nr);
uint32_t head_size = sizeof(mem_pool_t);
return head_size + bits_size * sizeof(uint32_t) + block_nr * block_size;
}
static inline mem_pool_t* mem_pool_init(uint8_t* addr, uint32_t size, uint32_t block_size,
uint32_t block_nr) {
mem_pool_t* pool = (mem_pool_t*)addr;
uint32_t bits_size = mem_pool_get_bits_size(block_nr);
#ifndef NDEBUG
uint32_t min_size = mem_pool_get_min_size(block_size, block_nr);
assert(size >= min_size);
#endif /*NDEBUG*/
memset(addr, 0x00, size);
pool->block_nr = block_nr;
pool->block_size = block_size;
pool->bits_size = bits_size;
pool->bits = (uint32_t*)(addr + sizeof(*pool));
pool->start = (uint8_t*)(pool->bits + pool->bits_size);
return pool;
}
static inline int32_t mem_pool_get_free_index(mem_pool_t* pool) {
uint32_t i = 0;
uint32_t index = 0;
uint32_t* bits = pool->bits;
for (i = 0; i < pool->bits_size; i++) {
if (index >= pool->block_nr) {
break;
}
if (bits[i] != 0xffffffff) {
uint32_t k = 0;
uint32_t v = bits[i];
for (k = 0; k < 32; k++) {
if (TK_TEST_BIT(v, k) == 0) {
TK_SET_BIT(v, k);
assert(TK_TEST_BIT(v, k) != 0);
bits[i] = v;
return i * 32 + k;
}
index++;
if (index >= pool->block_nr) {
break;
}
}
} else {
index += 32;
}
}
return -1;
}
static inline void* mem_pool_get(mem_pool_t* pool) {
int32_t index = mem_pool_get_free_index(pool);
if (index >= 0) {
pool->used++;
return pool->start + index * pool->block_size;
}
return NULL;
}
static inline ret_t mem_pool_put_index(mem_pool_t* pool, uint32_t index) {
uint32_t i = index / 32;
uint32_t k = index % 32;
uint32_t v = pool->bits[i];
return_value_if_fail(TK_TEST_BIT(v, k) != 0, RET_FAIL);
TK_CLEAR_BIT(v, k);
pool->bits[i] = v;
assert(TK_TEST_BIT(v, k) == 0);
return RET_OK;
}
static inline int32_t mem_pool_get_index(mem_pool_t* pool, void* ptr) {
uint8_t* addr = (uint8_t*)ptr;
if (pool->start <= addr && addr < (pool->start + pool->block_size * pool->block_nr)) {
int64_t offset = addr - pool->start;
int64_t index = offset / (pool->block_size);
assert(offset % pool->block_size == 0);
return (int32_t)index;
}
return -1;
}
static inline ret_t mem_pool_put(mem_pool_t* pool, void* ptr) {
uint8_t* addr = (uint8_t*)ptr;
int32_t index = mem_pool_get_index(pool, addr);
if (index >= 0) {
if (mem_pool_put_index(pool, index) == RET_OK) {
pool->used--;
return RET_OK;
}
}
return RET_NOT_FOUND;
}
END_C_DECLS
#endif /*TK_MEM_POOL_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/emitter.c
|
/**
* File: emitter.c
* Author: AWTK Develop Team
* Brief: emitter dispatcher
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-14 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/emitter.h"
#include "tkc/time_now.h"
emitter_t* emitter_create() {
emitter_t* emitter = (emitter_t*)TKMEM_ZALLOC(emitter_t);
return emitter_init(emitter);
}
static uint32_t emitter_next_id(emitter_t* emitter) {
uint32_t id = emitter->next_id++;
if (id == TK_INVALID_ID) {
id = emitter->next_id++;
}
return id;
}
emitter_t* emitter_init(emitter_t* emitter) {
return_value_if_fail(emitter, NULL);
memset(emitter, 0x00, sizeof(emitter_t));
emitter->disable = FALSE;
emitter->next_id = TK_INVALID_ID + 1;
return emitter;
}
#ifdef AWTK_WEB_JS
#include <emscripten.h>
#endif /*AWTK_WEB_JS*/
static ret_t emitter_item_destroy(emitter_item_t* iter) {
if (iter->on_destroy) {
iter->on_destroy(iter);
}
#ifdef AWTK_WEB_JS
EM_ASM_INT({ return TBrowser.releaseFunction($0); }, iter->handler);
#endif /*AWTK_WEB_JS*/
memset(iter, 0x00, sizeof(emitter_item_t));
TKMEM_FREE(iter);
return RET_OK;
}
static ret_t emitter_remove(emitter_t* emitter, emitter_item_t* prev, emitter_item_t* iter) {
return_value_if_fail(emitter != NULL && iter != NULL, RET_BAD_PARAMS);
if (iter->working) {
iter->pending_remove = TRUE;
return RET_OK;
}
if (iter == emitter->items) {
emitter->items = iter->next;
} else {
prev->next = iter->next;
}
emitter_item_destroy(iter);
return RET_OK;
}
ret_t emitter_remove_item(emitter_t* emitter, emitter_item_t* item) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
emitter_item_t* prev = emitter->items;
while (iter != NULL) {
emitter_item_t* next = iter->next;
if (iter == item) {
return emitter_remove(emitter, prev, iter);
}
prev = iter;
iter = next;
}
}
return RET_NOT_FOUND;
}
ret_t emitter_dispatch(emitter_t* emitter, event_t* e) {
ret_t ret = RET_OK;
return_value_if_fail(emitter != NULL && e != NULL, RET_BAD_PARAMS);
if (!(e->time)) {
e->time = time_now_ms();
}
if (e->target == NULL) {
e->target = emitter;
}
if (emitter->disable == 0 && emitter->items) {
emitter_item_t* iter = emitter->items;
while (iter != NULL) {
if (iter->type == e->type) {
bool_t is_working = iter->working;
iter->working = TRUE;
ret = iter->handler(iter->ctx, e);
if (!is_working) {
iter->working = FALSE;
}
if (ret == RET_STOP) {
if (iter->pending_remove) {
emitter_remove_item(emitter, iter);
}
return ret;
} else if (ret == RET_REMOVE || iter->pending_remove) {
emitter_item_t* next = iter->next;
emitter_remove_item(emitter, iter);
iter = next;
continue;
}
}
iter = iter->next;
}
}
return RET_OK;
}
uint32_t emitter_on_with_tag(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx,
uint32_t tag) {
emitter_item_t* iter = NULL;
return_value_if_fail(emitter != NULL && handler != NULL, TK_INVALID_ID);
iter = TKMEM_ZALLOC(emitter_item_t);
return_value_if_fail(iter != NULL, TK_INVALID_ID);
iter->tag = tag;
iter->ctx = ctx;
iter->type = etype;
iter->handler = handler;
iter->id = emitter_next_id(emitter);
iter->next = emitter->items;
emitter->items = iter;
return iter->id;
}
bool_t emitter_exist(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx) {
return_value_if_fail(emitter != NULL, FALSE);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
while (iter != NULL) {
if (iter->handler == handler && iter->type == etype && iter->ctx == ctx) {
return TRUE;
}
iter = iter->next;
}
}
return FALSE;
}
uint32_t emitter_on(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx) {
return emitter_on_with_tag(emitter, etype, handler, ctx, 0);
}
emitter_item_t* emitter_find(emitter_t* emitter, uint32_t id) {
return_value_if_fail(emitter != NULL, NULL);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
while (iter != NULL) {
if (iter->id == id) {
return iter;
}
iter = iter->next;
}
}
return NULL;
}
uint32_t emitter_size(emitter_t* emitter) {
uint32_t size = 0;
return_value_if_fail(emitter != NULL, size);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
while (iter != NULL) {
size++;
iter = iter->next;
}
}
return size;
}
static ret_t emitter_off_ex(emitter_t* emitter, tk_compare_t cmp, void* ctx) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
emitter_item_t* prev = emitter->items;
while (iter != NULL) {
if (!iter->pending_remove && cmp(iter, ctx) == 0) {
return emitter_remove(emitter, prev, iter);
}
prev = iter;
iter = iter->next;
}
}
return RET_FAIL;
}
static int emitter_item_compare_by_tag(const void* a, const void* b) {
const emitter_item_t* item = (const emitter_item_t*)a;
uint32_t tag = *(const uint32_t*)b;
return item->tag - tag;
}
static int emitter_item_compare_by_ctx(const void* a, const void* b) {
const emitter_item_t* item = (const emitter_item_t*)a;
return item->ctx == b ? 0 : 1;
}
static int emitter_item_compare_by_id(const void* a, const void* b) {
const emitter_item_t* item = (const emitter_item_t*)a;
uint32_t id = *(const uint32_t*)b;
return item->id - id;
}
static int emitter_item_compare_by_func(const void* a, const void* b) {
const emitter_item_t* item = (const emitter_item_t*)a;
const emitter_item_t* p = (const emitter_item_t*)b;
if (item->type == p->type && item->ctx == p->ctx && item->handler == p->handler) {
return 0;
}
return -1;
}
ret_t emitter_off(emitter_t* emitter, uint32_t id) {
return emitter_off_ex(emitter, emitter_item_compare_by_id, &id);
}
ret_t emitter_off_by_func(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx) {
ret_t ret;
emitter_item_t item;
memset(&item, 0x00, sizeof(item));
item.ctx = ctx;
item.type = etype;
item.handler = handler;
ret = emitter_off_ex(emitter, emitter_item_compare_by_func, &item);
if (ret == RET_OK) {
while (TRUE) {
if (emitter_off_ex(emitter, emitter_item_compare_by_func, &item) != RET_OK) {
break;
}
}
}
return ret;
}
ret_t emitter_off_by_tag(emitter_t* emitter, uint32_t tag) {
ret_t ret = emitter_off_ex(emitter, emitter_item_compare_by_tag, &tag);
if (ret == RET_OK) {
while (TRUE) {
if (emitter_off_ex(emitter, emitter_item_compare_by_tag, &tag) != RET_OK) {
break;
}
}
}
return ret;
}
ret_t emitter_off_by_ctx(emitter_t* emitter, void* ctx) {
ret_t ret = emitter_off_ex(emitter, emitter_item_compare_by_ctx, ctx);
if (ret == RET_OK) {
while (TRUE) {
if (emitter_off_ex(emitter, emitter_item_compare_by_ctx, ctx) != RET_OK) {
break;
}
}
}
return ret;
}
ret_t emitter_enable(emitter_t* emitter) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
emitter->disable--;
return RET_OK;
}
ret_t emitter_disable(emitter_t* emitter) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
emitter->disable++;
return RET_OK;
}
ret_t emitter_deinit(emitter_t* emitter) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
if (emitter->items) {
emitter_item_t* iter = emitter->items;
emitter_item_t* next = emitter->items;
while (iter != NULL) {
next = iter->next;
emitter_item_destroy(iter);
iter = next;
}
emitter->items = NULL;
}
return RET_OK;
}
ret_t emitter_destroy(emitter_t* emitter) {
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
emitter_deinit(emitter);
TKMEM_FREE(emitter);
return RET_OK;
}
ret_t emitter_set_on_destroy(emitter_t* emitter, uint32_t id, tk_destroy_t on_destroy,
void* on_destroy_ctx) {
emitter_item_t* item = emitter_find(emitter, id);
return_value_if_fail(item != NULL, RET_BAD_PARAMS);
item->on_destroy = on_destroy;
item->on_destroy_ctx = on_destroy_ctx;
return RET_OK;
}
emitter_t* emitter_cast(emitter_t* emitter) {
return_value_if_fail(emitter != NULL, NULL);
return emitter;
}
emitter_item_t* emitter_get_item(emitter_t* emitter, uint32_t index) {
uint32_t i = 0;
emitter_item_t* iter = NULL;
return_value_if_fail(emitter != NULL && index < emitter_size(emitter), NULL);
iter = emitter->items;
for (i = 0; i < index && iter != NULL; i++) {
iter = iter->next;
}
return iter;
}
ret_t emitter_dispatch_simple_event(emitter_t* emitter, uint32_t type) {
event_t e = event_init(type, emitter);
return_value_if_fail(emitter != NULL, RET_BAD_PARAMS);
return emitter_dispatch(emitter, &e);
}
ret_t emitter_forward(void* ctx, event_t* e) {
return emitter_dispatch(EMITTER(ctx), e);
}
ret_t emitter_forward_retarget(void* ctx, event_t* e) {
return_value_if_fail(e != NULL, RET_BAD_PARAMS);
e->target = ctx;
return emitter_dispatch(EMITTER(ctx), e);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/ostream.h
|
/**
* File: tk_ostream.h
* Author: AWTK Develop Team
* Brief: output stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OSTREAM_H
#define TK_OSTREAM_H
#include "tkc/object.h"
#include "tkc/stream_const.h"
BEGIN_C_DECLS
struct _tk_ostream_t;
typedef struct _tk_ostream_t tk_ostream_t;
typedef int32_t (*tk_ostream_write_t)(tk_ostream_t* stream, const uint8_t* buff, uint32_t max_size);
typedef ret_t (*tk_ostream_flush_t)(tk_ostream_t* stream);
typedef ret_t (*tk_ostream_seek_t)(tk_ostream_t* stream, uint32_t offset);
typedef int32_t (*tk_ostream_tell_t)(tk_ostream_t* stream);
/**
* @class tk_ostream_t
* @parent tk_object_t
*
* 输出流的接口。
*
*/
struct _tk_ostream_t {
tk_object_t object;
tk_ostream_flush_t flush;
tk_ostream_write_t write;
tk_ostream_seek_t seek;
tk_ostream_tell_t tell;
};
/**
* @method tk_ostream_write
*
* 写入数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {const void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
*
* @return {int32_t} 返回负数表示写入失败，否则返回实际写入数据的长度。
*
*/
int32_t tk_ostream_write(tk_ostream_t* stream, const void* buff, uint32_t max_size);
/**
* @method tk_ostream_seek
*
* 设置偏移量。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint32_t} offset 偏移量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_seek(tk_ostream_t* stream, uint32_t offset);
/**
* @method tk_ostream_tell
*
* 获取当前读取位置。
*
* @param {tk_ostream_t*} stream ostream对象。
*
* @return {int32_t} 返回负数表示失败，否则返回当前读取位置。
*
*/
int32_t tk_ostream_tell(tk_ostream_t* stream);
/**
* @method tk_ostream_write_len
*
* 写入指定长度的数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {const void*} buff 数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
* @param {uint32_t} timeout_ms timeout.
*
* @return {int32_t} 返回负数表示写入失败，否则返回实际写入数据的长度。
*
*/
int32_t tk_ostream_write_len(tk_ostream_t* stream, const void* buff, uint32_t max_size,
uint32_t timeout_ms);
/**
* @method tk_ostream_write_byte
*
* 写入一个字节的数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint8_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_byte(tk_ostream_t* stream, uint8_t value);
/**
* @method tk_ostream_write_uint8
*
* 写入uint8数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint8_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_uint8(tk_ostream_t* stream, uint8_t value);
/**
* @method tk_ostream_write_uint16
*
* 写入uint16数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint16_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_uint16(tk_ostream_t* stream, uint16_t value);
/**
* @method tk_ostream_write_uint32
*
* 写入uint32数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint32_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_uint32(tk_ostream_t* stream, uint32_t value);
/**
* @method tk_ostream_write_uint64
*
* 写入uint64数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {uint64_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_uint64(tk_ostream_t* stream, uint64_t value);
/**
* @method tk_ostream_write_int8
*
* 写入int8数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {int8_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_int8(tk_ostream_t* stream, int8_t value);
/**
* @method tk_ostream_write_int16
*
* 写入int16数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {int16_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_int16(tk_ostream_t* stream, int16_t value);
/**
* @method tk_ostream_write_int32
*
* 写入int32数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {int32_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_int32(tk_ostream_t* stream, int32_t value);
/**
* @method tk_ostream_write_int64
*
* 写入int64数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {int64_t} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_int64(tk_ostream_t* stream, int64_t value);
/**
* @method tk_ostream_write_float
*
* 写入float数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {float} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_float(tk_ostream_t* stream, float value);
/**
* @method tk_ostream_write_double
*
* 写入double数据。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {double} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_write_double(tk_ostream_t* stream, double value);
/**
* @method tk_ostream_flush
*
* 刷新数据。
*
* @param {tk_ostream_t*} stream ostream对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_ostream_flush(tk_ostream_t* stream);
/**
* @method tk_ostream_write_str
*
* 写入字符串。
*
* @param {tk_ostream_t*} stream ostream对象。
* @param {const char*} str 字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_ostream_write_str(tk_ostream_t* stream, const char* str);
/**
* @method tk_ostream_printf
*
* 写入格式化字符串。
* > 长度不超过1024。
* @param {tk_ostream_t*} stream ostream对象。
* @param {const char*} format 格式化字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_ostream_printf(tk_ostream_t* stream, const char* format, ...);
#define TK_OSTREAM(obj) ((tk_ostream_t*)(obj))
#define TK_OSTREAM_SEEKABLE(obj) (TK_OSTREAM(obj)->seek != NULL)
#define TK_OSTREAM_TELLABLE(obj) (TK_OSTREAM(obj)->tell != NULL)
/**
* @method tk_ostream_unref
*
* 引用计数减1。引用计数为0时，销毁对象。
* @param {tk_ostream_t*} stream ostream对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_ostream_unref(tk_ostream_t* stream);
END_C_DECLS
#endif /*TK_OSTREAM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/types_def.h
|
/**
* File: types_def.h
* Author: AWTK Develop Team
* Brief: basic types definitions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TYPES_DEF_H
#define TYPES_DEF_H
#ifdef __cplusplus
#define BEGIN_C_DECLS extern "C" {
#define END_C_DECLS }
#else
#define BEGIN_C_DECLS
#define END_C_DECLS
#endif
#include <stdarg.h>
#include <ctype.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <inttypes.h>
#if defined(HAS_AWTK_CONFIG)
#include "awtk_config.h"
#endif /*HAS_AWTK_CONFIG*/
#if defined(WIN32) || defined(LINUX) || defined(MACOS) || defined(ANDROID) || defined(IOS)
#define WITH_SOCKET 1
#endif /*WIN32 || MACOS || LINUX || IOS || ANDROID*/
#ifndef TK_IS_PC
#if defined(WITH_SDL) && !defined(ANDROID) && !defined(IOS)
#define TK_IS_PC 1
#endif
#endif /*TK_IS_PC*/
#ifndef WITH_WASM
#include <math.h>
#include <time.h>
#include <wchar.h>
#include <assert.h>
#include <wctype.h>
#ifdef WITH_SOCKET
#ifdef WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <winsock2.h>
typedef int socklen_t;
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#endif /*WIN32*/
#endif /*WITH_SOCKET*/
#else
#include "tkc/wasm_helper.h"
#endif /*WITH_WASM*/
#if defined(__MINGW32__) || defined(__MINGW64__)
#ifndef MINGW
#define MINGW 1
#endif
#endif
#if defined(HAS_STDIO) || defined(AWTK_WEB)
#include <stdio.h>
#else
#define STBI_NO_STDIO
#endif /*HAS_STDIO*/
#ifndef TK_WEAK
#if defined(__CC_ARM) || \
(defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) /* ARM Compiler */
#define TK_WEAK __attribute__((weak))
#elif defined(__IAR_SYSTEMS_ICC__) /* for IAR Compiler */
#define TK_WEAK __weak
#elif defined(__GNUC__) && !defined(__MINGW32__) && !defined(__MINGW64__) /* GNU GCC Compiler */
#define TK_WEAK __attribute__((weak))
#elif defined(__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */
#define TK_WEAK __attribute__((weak))
#elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__) /* Windows */
#define TK_WEAK
#elif defined(__TI_COMPILER_VERSION__)
#define TK_WEAK
#else
#define TK_WEAK
#endif
#endif
#ifndef TRUE
#define TRUE 1
#endif /*TRUE*/
#ifndef FALSE
#define FALSE 0
#endif /*FALSE*/
#if defined(__GNUC__) && !defined(__cplusplus)
typedef _Bool bool_t;
#else
typedef uint8_t bool_t;
#endif
typedef int32_t xy_t;
typedef int32_t wh_t;
typedef uint16_t font_size_t;
/*
* 如果使用了 mingw 或者 32 位 pc 的 linux 出现 “conflicting declaration 'typedef float float_t'” 的错误提示的话，
* 因为 awtk 的 float_t 类型为 float，所以请定义 __FLT_EVAL_METHOD__ 宏并且宏为 0 （#define __FLT_EVAL_METHOD__ 0 ）
*/
#if defined(WITH_DOUBLE_FLOAT)
typedef long double float_t;
#else
typedef float float_t;
#endif /*WITH_DOUBLE_FLOAT*/
#if !defined(ANDROID) && !defined(IOS) && !defined(LINUX) && !defined(MACOS) && !defined(WIN32)
#ifndef time_t
#define time_t uint64_t
#endif /*time_t*/
#endif
struct _value_t;
typedef struct _value_t value_t;
struct _tk_object_t;
typedef struct _tk_object_t tk_object_t;
#ifndef USE_TK_PREFIX
#define object_t tk_object_t
#endif /*USE_TK_PREFIX*/
/**
* @enum ret_t
* @prefix RET_
* @annotation ["scriptable"]
* 函数返回值常量定义。
*/
typedef enum _ret_t {
/**
* @const RET_OK
* 成功。
*/
RET_OK = 0,
/**
* @const RET_OOM
* Out of memory。
*/
RET_OOM,
/**
* @const RET_FAIL
* 失败。
*/
RET_FAIL,
/**
* @const RET_NOT_IMPL
* 没有实现/不支持。
*/
RET_NOT_IMPL,
/**
* @const RET_QUIT
* 退出。通常用于主循环。
*/
RET_QUIT,
/**
* @const RET_FOUND
* 找到。
*/
RET_FOUND,
/**
* @const RET_BUSY
* 对象忙。
*/
RET_BUSY,
/**
* @const RET_REMOVE
* 移出。通常用于定时器。
*/
RET_REMOVE,
/**
* @const RET_REPEAT
* 重复。通常用于定时器。
*/
RET_REPEAT,
/**
* @const RET_NOT_FOUND
* 没找到。
*/
RET_NOT_FOUND,
/**
* @const RET_DONE
* 操作完成。
*/
RET_DONE,
/**
* @const RET_STOP
* 停止后续操作。
*/
RET_STOP,
/**
* @const RET_SKIP
* 跳过当前项。
*/
RET_SKIP,
/**
* @const RET_CONTINUE
* 继续后续操作。
*/
RET_CONTINUE,
/**
* @const RET_OBJECT_CHANGED
* 对象属性变化。
*/
RET_OBJECT_CHANGED,
/**
* @const RET_ITEMS_CHANGED
* 集合数目变化。
*/
RET_ITEMS_CHANGED,
/**
* @const RET_BAD_PARAMS
* 无效参数。
*/
RET_BAD_PARAMS,
/**
* @const RET_TIMEOUT
* 超时。
*/
RET_TIMEOUT,
/**
* @const RET_CRC
* CRC错误。
*/
RET_CRC,
/**
* @const RET_IO
* IO错误。
*/
RET_IO,
/**
* @const RET_EOS
* End of Stream
*/
RET_EOS,
/**
* @const RET_NOT_MODIFIED
* 没有改变。
*/
RET_NOT_MODIFIED,
/**
* @const RET_NO_PERMISSION
* 没有权限。
*/
RET_NO_PERMISSION,
/**
* @const RET_INVALID_ADDR
* 无效地址。
*/
RET_INVALID_ADDR,
/**
* @const RET_EXCEED_RANGE
* 超出范围。
*/
RET_EXCEED_RANGE,
/**
* @const RET_MAX_NR
* 最大值。
*/
RET_MAX_NR
} ret_t;
#include "tkc/log.h"
#if defined(WIN32) || defined(__ARMCC_VERSION)
#define random rand
#define srandom srand
#endif /*WIN32||__ARMCC_VERSION*/
#if !defined(WIN32) && !defined(MAX_PATH)
#define MAX_PATH 255
#endif /*MAX_PATH*/
#if defined(WIN32)
#define TK_PATH_SEP '\\'
#else
#define TK_PATH_SEP '/'
#endif /*TK_PATH_SEP*/
#if defined(WIN32) && !defined(MINGW)
#ifndef snprintf
#define snprintf _snprintf
#endif /*snprintf*/
#define strcasecmp stricmp
#define strncasecmp strnicmp
#define wcscasecmp wcsicmp
#endif /*TK_PATH_SEP*/
#define log_if_fail(p) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
}
#if defined(NDEBUG) || defined(SYLIXOS)
#ifdef WITH_INFERCHECK
#define __INFER_ENSURE__(p) (void)(!!(p) || (exit(0), 0))
#define ENSURE(p) __INFER_ENSURE__(p)
#else
#define ENSURE(p) (void)(p)
#endif
#define goto_error_if_fail(p) \
if (!(p)) { \
goto error; \
}
#define goto_error_if_fail_ex(p, sentence) \
if (!(p)) { \
sentence; \
goto error; \
}
#define return_if_fail(p) \
if (!(p)) { \
return; \
}
#define break_if_fail(p) \
if (!(p)) { \
break; \
}
#define return_value_if_fail(p, value) \
if (!(p)) { \
return (value); \
}
#else
#define ENSURE(p) assert(p)
#define goto_error_if_fail(p) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
goto error; \
}
#define goto_error_if_fail_ex(p, sentence) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
sentence; \
goto error; \
}
#define break_if_fail(p) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
break; \
}
#define return_if_fail(p) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
return; \
}
#define return_value_if_fail(p, value) \
if (!(p)) { \
log_warn("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
return (value); \
}
#endif
#define return_value_if_equal(p, value) \
if ((p) == value) { \
return (value); \
}
#define tk_min(a, b) ((a) < (b) ? (a) : (b))
#define tk_abs(a) ((a) < (0) ? (-(a)) : (a))
#define tk_max(a, b) ((a) > (b) ? (a) : (b))
#define tk_roundi(a) (int32_t)(((a) >= 0) ? ((a) + 0.5f) : ((a)-0.5f))
#define tk_clamp(a, mn, mx) ((a) < (mn) ? (mn) : ((a) > (mx) ? (mx) : (a)))
#define tk_clampi(a, mn, mx) (int32_t)((a) < (mn) ? (mn) : ((a) > (mx) ? (mx) : (a)))
#define tk_swap(a, b, type) \
{ \
type temp = a; \
a = b; \
b = temp; \
}
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#endif /*ARRAY_SIZE*/
typedef void* (*tk_create_t)(void);
typedef ret_t (*tk_destroy_t)(void* data);
typedef ret_t (*tk_on_done_t)(void* data);
typedef ret_t (*tk_on_result_t)(void* ctx, const void* data);
typedef bool_t (*tk_is_valid_t)(void* data);
/*TRUE 保留，FALSE 忽略*/
typedef bool_t (*tk_filter_t)(void* ctx, const void* data);
typedef int (*tk_compare_t)(const void* a, const void* b);
typedef ret_t (*tk_visit_t)(void* ctx, const void* data);
typedef uint32_t (*tk_hash_t)(const void* data);
typedef ret_t (*tk_callback_t)(void* ctx);
/*TK_NAME_LEN+1 must aligned to 4*/
enum { TK_NAME_LEN = 31, TK_FUNC_NAME_LEN = 63 };
#ifdef WITH_CPPCHECK
int __cppcheck__strcmp(const char* s1, const char* s2);
int __cppcheck__strcasecmp(const char* s1, const char* s2);
int __cppcheck__strncmp(const char* s1, const char* s2, size_t n);
#define tk_str_eq(s1, s2) (__cppcheck__strcmp((s1), (s2)) == 0)
#define tk_str_ieq(s1, s2) (__cppcheck__strcasecmp((s1), (s2)) == 0)
#define tk_str_eq_with_len(s1, s2, len) (__cppcheck__strncmp((s1), (s2), len) == 0)
#else
#define tk_str_eq(s1, s2) \
(((s1) == NULL && (s2) == NULL) || \
(((s1) != NULL) && ((s2) != NULL) && *((const char*)s1) == *((const char*)s2) && \
strcmp((s1), (s2)) == 0))
#define tk_str_eq_with_len(s1, s2, len) \
(((s1) != NULL) && ((s2) != NULL) && *((const char*)s1) == *((const char*)s2) && \
strncmp((s1), (s2), len) == 0)
#define tk_str_ieq(s1, s2) \
(((s1) == NULL && (s2) == NULL) || \
(((s1) != NULL) && ((s2) != NULL) && strcasecmp((s1), (s2)) == 0))
#define tk_wstr_eq(s1, s2) \
(((s1) == NULL && (s2) == NULL) || \
(((s1) != NULL) && ((s2) != NULL) && *((const wchar_t*)s1) == *((const wchar_t*)s2) && \
wcscmp((s1), (s2)) == 0))
#endif /*WITH_CPPCHECK*/
#define tk_fequal(f1, f2) (fabs((f1) - (f2)) < 0.0001)
#define tk_lfequal(f1, f2) (fabs((f1) - (f2)) < 0.0000001)
#ifndef M_PI
#define M_PI 3.1415926f
#endif /*M_PI*/
#ifndef M_E
#define M_E 2.71828f
#endif /*M_E*/
#ifndef M_SQRT2
#define M_SQRT2 1.4142135f
#endif /*M_SQRT2*/
#define TK_INVALID_ID 0u
#define TK_NUM_MAX_LEN 31u
#define TK_UINT32_MAX 0xffffffffu
#define TK_LOCALE_MAGIC "$locale$"
#define TK_OBJECT_PROP_NAME_MAX_LEN 64u
#define TK_D2R(d) (((d)*M_PI) / 180)
#define TK_R2D(r) (((r)*180) / M_PI)
#ifdef _MSC_VER
#define TK_CONST_DATA_ALIGN(v) __declspec(align(8)) v
#else
#define TK_CONST_DATA_ALIGN(v) v __attribute__((aligned(8)))
#endif /*_MSC_VER*/
typedef uint64_t (*tk_get_time_t)(void);
typedef uint64_t (*tk_get_time_ms_t)(void);
typedef void (*tk_sleep_ms_t)(uint32_t ms);
#if defined(WIN32) && !defined(NDEBUG) && defined(_CONSOLE)
#define TK_ENABLE_CONSOLE() \
{ \
AllocConsole(); \
FILE* fp = NULL; \
freopen_s(&fp, "CONOUT$", "w+t", stdout); \
system("chcp 65001"); \
}
#else
#define TK_ENABLE_CONSOLE()
#endif /*WIN32 && !NDEBUG*/
struct _event_source_t;
typedef struct _event_source_t event_source_t;
struct _event_source_manager_t;
typedef struct _event_source_manager_t event_source_manager_t;
#ifndef EAGAIN
#define EAGAIN 11
#endif /*EAGAIN*/
#define TK_SET_NULL(p) (p) = NULL
#define TK_ROUND_TO4(size) ((((size) + 3) >> 2) << 2)
#define TK_ROUND_TO8(size) ((((size) + 7) >> 3) << 3)
#define TK_ROUND_TO_MACH(size) ((sizeof(void*) == 4) ? TK_ROUND_TO4(size) : TK_ROUND_TO8(size))
#define TK_ROUND_TO(size, round_size) ((((size) + (round_size)-1) / (round_size)) * (round_size))
#define TK_SET_BIT(v, n) ((v) |= 1UL << (n))
#define TK_CLEAR_BIT(v, n) ((v) &= ~(1UL << (n)))
#define TK_TOGGLE_BIT(v, n) ((v) ^= (1UL << (n)))
#define TK_TEST_BIT(v, n) (((v) >> (n)) & 1U)
#ifndef TK_DEFAULT_WAIT_TIME
#define TK_DEFAULT_WAIT_TIME 16
#endif /*TK_DEFAULT_WAIT_TIME*/
/*from cairo/cairo/cairoint.h*/
#if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE)
#define TK_ISFINITE(x) isfinite(x)
#else
#define TK_ISFINITE(x) ((x) * (x) >= 0.) /* check for NaNs */
#endif
#define tk_isspace(c) ((0 <= (int)(c)) && ((int)(c) < 128) && isspace(c))
#define tk_isdigit(c) ((int)(c) >= '0' && (int)(c) <= '9')
#define tk_isxdigit(c) ((0 <= (int)(c)) && ((int)(c) < 128) && isxdigit(c))
#define tk_isprint(c) ((0 <= (int)(c)) && ((int)(c) < 128) && isprint(c))
#define tk_isalpha(c) ((0 <= (int)(c)) && ((int)(c) < 128) && isalpha(c))
#define tk_islower(c) ((0 <= (int)(c)) && ((int)(c) < 128) && islower(c))
#define tk_isupper(c) ((0 <= (int)(c)) && ((int)(c) < 128) && isupper(c))
#define STR_SCHEMA_TCP "tcp://"
#define STR_SCHEMA_UDP "udp://"
#define STR_SCHEMA_SERIAL "serial://"
#define STR_SCHEMA_FILE "file://"
#define STR_SCHEMA_FTP "ftp://"
#define STR_SCHEMA_HTTP "http://"
#define STR_SCHEMA_HTTPS "https://"
#define STR_SCHEMA_SERIAL "serial://"
#define STR_SCHEMA_MEM "mem://"
#define TK_STR_IS_EMPTY(s) (s == NULL || *s == '\0')
#define TK_STR_IS_NOT_EMPTY(s) ((s != NULL) && *s)
#ifdef WIN32
#define popen _popen
#define pclose _pclose
#endif /*WIN32*/
#define TK_VALUE_UNDEFINED "undefined"
typedef struct _key_type_value_t {
char* name;
uint32_t type;
uint32_t value;
} key_type_value_t;
#endif /*TYPES_DEF_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_file.h
|
/**
* File: data_writer_file.h
* Author: AWTK Develop Team
* Brief: data_writer file
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_WRITER_FILE_H
#define TK_DATA_WRITER_FILE_H
#include "tkc/data_writer.h"
BEGIN_C_DECLS
/**
* @class data_writer_file_t
* @parent data_writer_t
* @annotation ["fake"]
* 基于文件实现的 data_writer。通过 data_writer_factory 创建 writer 时，URL的格式如下：
*
* ```
* file://filename
* ```
*/
/**
* @method data_writer_file_create
* 创建基于文件的data writer。
*
* > 不要直接调用，而是注册到 data\_writer\_factory后，通过data\_writer\_factory调用
* @annotation ["constructor"]
*
* @param {const char*} filename 文件名。
*
* @return {data_writer_t*} 返回data writer对象。
*/
data_writer_t* data_writer_file_create(const char* filename);
END_C_DECLS
#endif /*TK_DATA_WRITER_FILE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/named_value_hash.c
|
/**
* File: named_value_hash.c
* Author: AWTK Develop Team
* Brief: 带有散列值的named value
*
* Copyright (c) 2024 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2024-08-21 Shen ZhaoKun <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/named_value_hash.h"
static uint64_t bkdr_hash(const char* str) {
const uint64_t base = 131;
const char* iter = NULL;
uint64_t ret = 0;
for (ret = 0, iter = str; (*iter) != '\0'; iter++) {
ret = ret * base + (*iter);
}
return ret;
}
uint64_t named_value_hash_get_hash_from_str(const char* str) {
return bkdr_hash(str);
}
ret_t named_value_hash_set_name(named_value_hash_t* nvh, const char* name) {
return_value_if_fail(nvh != NULL, RET_BAD_PARAMS);
named_value_set_name(&nvh->base, name);
nvh->hash = named_value_hash_get_hash_from_str(name);
return RET_OK;
}
ret_t named_value_hash_deinit(named_value_hash_t* nvh) {
return_value_if_fail(nvh != NULL, RET_BAD_PARAMS);
named_value_deinit(&nvh->base);
memset(nvh, 0, sizeof(named_value_hash_t));
return RET_OK;
}
named_value_hash_t* named_value_hash_init(named_value_hash_t* nvh, const char* name,
const value_t* value) {
ret_t ret = RET_OK;
return_value_if_fail(nvh != NULL, NULL);
memset(nvh, 0x00, sizeof(named_value_hash_t));
if (name != NULL) {
ret = named_value_hash_set_name(nvh, name);
}
if (RET_OK == ret) {
if (value != NULL) {
named_value_set_value((named_value_t*)nvh, value);
}
}
return (RET_OK == ret) ? nvh : NULL;
}
ret_t named_value_hash_destroy(named_value_hash_t* nvh) {
return_value_if_fail(nvh != NULL, RET_BAD_PARAMS);
named_value_hash_deinit(nvh);
TKMEM_FREE(nvh);
return RET_OK;
}
named_value_hash_t* named_value_hash_create_ex(const char* name, const value_t* value) {
named_value_hash_t* ret = TKMEM_ZALLOC(named_value_hash_t);
return_value_if_fail(ret != NULL, NULL);
goto_error_if_fail(ret == named_value_hash_init(ret, name, value));
return ret;
error:
named_value_hash_destroy(ret);
return NULL;
}
named_value_hash_t* named_value_hash_create(void) {
return named_value_hash_create_ex(NULL, NULL);
}
static int32_t named_value_hash_hash_compare(uint64_t hash1, uint64_t hash2) {
if (hash1 > hash2) {
// uint64_t d = hash1 - hash2;
// return tk_min(d, INT32_MAX);
return 1;
} else if (hash1 < hash2) {
// uint64_t d = hash2 - hash1;
// int64_t t = -tk_min(d, -(int64_t)INT32_MIN);
// return tk_max(INT32_MIN, t);
return -1;
} else {
return 0;
}
}
int32_t named_value_hash_compare(const named_value_hash_t* nvh, const named_value_hash_t* other) {
return_value_if_fail(nvh != NULL && other != NULL, -1);
return named_value_hash_hash_compare(nvh->hash, other->hash);
}
int32_t named_value_hash_compare_by_hash(const named_value_hash_t* nvh, uint64_t hash) {
return_value_if_fail(nvh != NULL, -1);
return named_value_hash_hash_compare(nvh->hash, hash);
}
named_value_hash_t* named_value_hash_clone(named_value_hash_t* nvh) {
named_value_hash_t* ret = named_value_hash_create();
return_value_if_fail(ret != NULL, NULL);
ret->hash = nvh->hash;
named_value_set_name(&ret->base, nvh->base.name);
named_value_set_value(&ret->base, &nvh->base.value);
return ret;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_wbuffer.c
|
/**
* File: data_writer.c
* Author: AWTK Develop Team
* Brief: data_writer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License wbuffer for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-23 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/data_writer_wbuffer.h"
typedef struct _data_writer_wbuffer_t {
data_writer_t data_writer;
wbuffer_t* wbuffer;
} data_writer_wbuffer_t;
static int32_t data_writer_wbuffer_write(data_writer_t* writer, uint64_t offset, const void* data,
uint32_t size) {
data_writer_wbuffer_t* wbuffer = (data_writer_wbuffer_t*)writer;
return_value_if_fail(wbuffer_extend_capacity(wbuffer->wbuffer, offset + size) == RET_OK, 0);
wbuffer->wbuffer->cursor = offset;
return wbuffer_write_binary(wbuffer->wbuffer, data, size) == RET_OK ? size : 0;
}
static ret_t data_writer_wbuffer_destroy(data_writer_t* writer) {
TKMEM_FREE(writer);
return RET_OK;
}
static const data_writer_vtable_t s_data_writer_wbuffer_vtable = {
.write = data_writer_wbuffer_write,
.destroy = data_writer_wbuffer_destroy,
};
data_writer_t* data_writer_wbuffer_create(const char* wbuffername) {
int32_t nr = 0;
data_writer_wbuffer_t* wbuffer = NULL;
return_value_if_fail(wbuffername != NULL, NULL);
wbuffer = TKMEM_ZALLOC(data_writer_wbuffer_t);
return_value_if_fail(wbuffer != NULL, NULL);
nr = tk_sscanf(wbuffername, "%p", &wbuffer->wbuffer);
wbuffer->data_writer.vt = &s_data_writer_wbuffer_vtable;
if (wbuffer->wbuffer == NULL && nr == 1) {
TKMEM_FREE(wbuffer);
}
return (data_writer_t*)wbuffer;
}
const char* data_writer_wbuffer_build_url(wbuffer_t* buffer, char url[MAX_PATH + 1]) {
return_value_if_fail(buffer != NULL, NULL);
tk_snprintf(url, MAX_PATH, "wbuffer://%p", buffer);
return url;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_wbuffer.h
|
/**
* File: object_wbuffer.h
* Author: AWTK Develop Team
* Brief: wrap wbuffer to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_WBUFFER_H
#define TK_OBJECT_WBUFFER_H
#include "tkc/object.h"
#include "tkc/buffer.h"
BEGIN_C_DECLS
/**
* @class object_wbuffer_t
* @parent tk_object_t
*
* 将wbuffer包装成object。
*
*/
typedef struct _object_wbuffer_t {
tk_object_t object;
/**
* @property {wbuffer_t*} wbuffer
* @annotation ["readable"]
* wbuffer对象。
*
*/
wbuffer_t* wbuffer;
/*private*/
wbuffer_t awbuffer;
} object_wbuffer_t;
/**
* @method object_wbuffer_create
*
* 创建wbuffer对象。
*
* @annotation ["constructor"]
* @param {uint8_t*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_wbuffer_create(uint8_t* data, uint32_t capacity);
/**
* @method object_wbuffer_create_extendable
*
* 创建可扩展的wbuffer对象。
*
* @annotation ["constructor"]
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_wbuffer_create_extendable(void);
/**
* @method object_wbuffer_cast
* 转换为object_wbuffer对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_wbuffer对象。
*
* @return {object_wbuffer_t*} object_wbuffer对象。
*/
object_wbuffer_t* object_wbuffer_cast(tk_object_t* obj);
#define OBJECT_WBUFFER(obj) object_wbuffer_cast(obj)
#define OBJECT_WBUFFER_TYPE "object_wbuffer"
END_C_DECLS
#endif /*TK_OBJECT_WBUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/wasm_helper.h
|
#ifndef WASM_HELPER_H
#define WASM_HELPER_H
#include <math.h>
#include <stdio.h>
BEGIN_C_DECLS
#define WITH_SOCKET 1
#ifndef PRIu64
#if UINTPTR_MAX == 0xffffffff
#define __PRI64_PREFIX "ll"
#else
#define __PRI64_PREFIX "l"
#endif
#define PRIu64 __PRI64_PREFIX "u"
#define PRId64 __PRI64_PREFIX "d"
#endif /*PRIu64*/
#ifdef WITH_EASTL
#include <wchar.h>
#else
#ifndef WITH_WCSXXX
#define WITH_WCSXXX 1
#endif /*WITH_WCSXXX*/
#endif /*WITH_EASTL*/
#define WITHOUT_FSCRIPT
int awplc_log(const char* format, ...);
#define log_impl awplc_log
#define assert(__pp) wasm_assert(__pp, #__pp)
#define ret_t_init(r) *r = RET_OK;
double sin(double x);
double cos(double x);
double tan(double x);
double asin(double x);
double acos(double x);
double atan(double x);
double atan2(double y, double x);
double sqrt(double x);
double log10(double x);
double log(double x);
double exp(double x);
#if defined(WIN32) && defined(_MSC_VER)
_Check_return_ _ACRTIMP double __cdecl round(_In_ double _X);
_Check_return_ _ACRTIMP double __cdecl floor(_In_ double _X);
_Check_return_ _ACRTIMP double __cdecl ceil(_In_ double _X);
#else
double round(double x);
double floor(double x);
double ceil(double x);
#endif /*WIN32*/
#ifndef __cplusplus
typedef int wchar_t;
typedef int wint_t;
#endif /*_cplusplus*/
int iswupper(wchar_t ch);
int iswlower(wchar_t ch);
int iswdigit(wchar_t ch);
int iswxdigit(wchar_t ch);
int iswalpha(wchar_t ch);
int iswalnum(wchar_t ch);
int iswspace(wchar_t ch);
int islower(int c);
#ifdef WITH_WCSXXX
size_t wcslen(const wchar_t* s);
int wcscmp(const wchar_t* s1, const wchar_t* s2);
int wcscasecmp(const wchar_t* s1, const wchar_t* s2);
int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n);
wchar_t* wcsdup(const wchar_t* s);
wchar_t* wcschr(const wchar_t* s, wchar_t c);
wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2);
wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);
const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
#endif /*WITH_WCSXXX*/
#if defined(__GNUC__) && !defined(__cplusplus)
typedef _Bool bool_t;
#else
typedef uint8_t bool_t;
#endif
double atof(const char* str);
char* strrchr(const char* s, int c);
int wasm_assert(bool_t p, const char* text);
int strcasecmp(const char* s1, const char* s2);
long strtol(const char* str, char** endptr, int base);
long long strtoll(const char* str, char** endptr, int base);
unsigned long strtoul(const char* str, char** endptr, int base);
unsigned long long strtoull(const char* str, char** endptr, int base);
long random(void);
void srand(unsigned seed);
void qsort(void*, size_t, size_t, int (*)(const void*, const void*));
#define towlower(c) tolower(c)
#define towupper(c) toupper(c)
#define HAS_NO_VSSCANF 1
void perror(const char* s);
struct in_addr {
unsigned long s_addr;
};
struct sockaddr {
unsigned short sa_family;
char sa_data[14];
};
struct sockaddr_in {
short sin_family;
unsigned short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
END_C_DECLS
#endif /*WASM_HELPER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/log.h
|
/**
* File: log.h
* Author: AWTK Develop Team
* Brief: log functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-11-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LOG_H
#define TK_LOG_H
BEGIN_C_DECLS
/**
* @enum tk_log_level_t
* @prefix LOG_LEVEL_
* LOG的级别。
*/
typedef enum _tk_log_level_t {
/**
* @const LOG_LEVEL_DEBUG
* DEBUG
*/
LOG_LEVEL_DEBUG = 0,
/**
* @const LOG_LEVEL_INFO
* INFO
*/
LOG_LEVEL_INFO,
/**
* @const LOG_LEVEL_WARN
* WARN
*/
LOG_LEVEL_WARN,
/**
* @const LOG_LEVEL_ERROR
* ERROR
*/
LOG_LEVEL_ERROR
} tk_log_level_t;
/**
* @class log_t
* @annotation ["fake"]
* log。
*
*/
/**
* @method log_get_log_level
*
* 获取log的级别。
*
* @return {tk_log_level_t} 返回log的级别。
*/
tk_log_level_t log_get_log_level(void);
/**
* @method log_set_log_level
*
* 设置log的级别。
*
* @param {tk_log_level_t} log_level log的级别。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t log_set_log_level(tk_log_level_t log_level);
int32_t log_dummy(const char* fmt, ...);
/**
* @method log_debug
* @export none
*
* 输出调试信息。
* > 变参函数。
*
* ```
* log_debug("debug message\n");
* ```
* @param {const char*} format 格式或信息。
* @return {void} 无返回值。
*/
/**
* @method log_info
* @export none
*
* 输出参考信息。
* > 变参函数。
*
* ```
* log_info("info message\n");
* ```
* @param {const char*} format 格式或信息。
*
* @return {void} 无返回值。
*/
/**
* @method log_warn
* @export none
*
* 输出警告信息。
* > 变参函数。
*
* ```
* log_warn("warn message\n");
* ```
* @param {const char*} format 格式或信息。
*
* @return {void} 无返回值。
*/
/**
* @method log_error
* @export none
*
* 输出错误信息。
* > 变参函数。
*
* ```
* log_error("error message\n");
* ```
* @param {const char*} format 格式或信息。
*
* @return {void} 无返回值。
*/
/**
* @method log_notify
*
* 用于拦截日志，发送给客户端。
* > 变参函数。
*
* @param {tk_log_level_t} level 级别。
* @param {const char*} format 格式或信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t log_notify(tk_log_level_t level, const char* format, ...);
typedef ret_t (*tk_log_hook_t)(void* ctx, tk_log_level_t level, const char* format, va_list ap);
/**
* @method log_set_hook
*
* 设置钩子函数。
*
* @param {tk_log_hook_t} log 回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t log_set_hook(tk_log_hook_t log, void* ctx);
#ifdef ANDROID
#include "android/log.h"
#define log_debug(...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, __VA_ARGS__); \
__android_log_print(ANDROID_LOG_DEBUG, "AWTK", __VA_ARGS__); \
}
#define log_info(...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, __VA_ARGS__); \
__android_log_print(ANDROID_LOG_INFO, "AWTK", __VA_ARGS__); \
}
#define log_warn(...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, __VA_ARGS__); \
__android_log_print(ANDROID_LOG_WARN, "AWTK", __VA_ARGS__); \
}
#define log_error(...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, __VA_ARGS__); \
__android_log_print(ANDROID_LOG_ERROR, "AWTK", __VA_ARGS__); \
}
#elif defined(IOS)
void awtk_ios_log(const char* message, ...);
#define log_debug(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, format, ##args); \
awtk_ios_log(format, ##args); \
}
#define log_info(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, format, ##args); \
awtk_ios_log(format, ##args); \
}
#define log_warn(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, format, ##args); \
awtk_ios_log(format, ##args); \
}
#define log_error(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, format, ##args); \
awtk_ios_log(format, ##args); \
}
#elif defined(WIN32)
#include <windows.h>
#if defined(__GNUC__)
/*MINGW*/
#define log_debug(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, format, ##args); \
printf(format, ##args); \
}
#define log_info(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, format, ##args); \
printf(format, ##args); \
}
#define log_warn(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, format, ##args); \
printf(format, ##args); \
}
#define log_error(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, format, ##args); \
printf(format, ##args); \
}
#else
/*MSVC*/
#define log_debug(format, ...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, format, __VA_ARGS__); \
printf(format, __VA_ARGS__); \
fflush(stdout); \
}
#define log_info(format, ...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, format, __VA_ARGS__); \
printf(format, __VA_ARGS__); \
fflush(stdout); \
}
#define log_warn(format, ...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, format, __VA_ARGS__); \
printf(format, __VA_ARGS__); \
fflush(stdout); \
}
#define log_error(format, ...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, format, __VA_ARGS__); \
printf(format, __VA_ARGS__); \
fflush(stdout); \
}
#endif
#elif defined(HAS_STDIO) || defined(AWTK_WEB)
#include <stdio.h>
#define log_debug(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, format, ##args); \
printf(format, ##args); \
fflush(stdout); \
}
#define log_info(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, format, ##args); \
printf(format, ##args); \
fflush(stdout); \
}
#define log_warn(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, format, ##args); \
printf(format, ##args); \
fflush(stdout); \
}
#define log_error(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, format, ##args); \
printf(format, ##args); \
fflush(stdout); \
}
#elif defined(log_impl)
#define log_debug(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_DEBUG) { \
log_notify(LOG_LEVEL_DEBUG, format, ##args); \
log_impl(format, ##args); \
}
#define log_info(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_INFO) { \
log_notify(LOG_LEVEL_INFO, format, ##args); \
log_impl(format, ##args); \
}
#define log_warn(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_WARN) { \
log_notify(LOG_LEVEL_WARN, format, ##args); \
log_impl(format, ##args); \
}
#define log_error(format, args...) \
if (log_get_log_level() <= LOG_LEVEL_ERROR) { \
log_notify(LOG_LEVEL_ERROR, format, ##args); \
log_impl(format, ##args); \
}
#else
#ifdef WITH_LOG_NOTIFY
#define log_debug(format, args...) log_notify(LOG_LEVEL_DEBUG, format, ##args)
#define log_info(format, args...) log_notify(LOG_LEVEL_INFO, format, ##args)
#define log_warn(format, args...) log_notify(LOG_LEVEL_WARN, format, ##args)
#define log_error(format, args...) log_notify(LOG_LEVEL_ERROR, format, ##args)
#else
#define log_debug(format, args...)
#define log_info(format, args...)
#define log_warn(format, args...)
#define log_error(format, args...)
#endif /*WITH_LOG_NOTIFY*/
#endif
END_C_DECLS
#endif /*TK_LOG_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_debug.h
|
/**
* File: mem_allocator_debug.h
* Author: AWTK Develop Team
* Brief: mem_allocator_debug
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_DEBUG_H
#define TK_MEM_ALLOCATOR_DEBUG_H
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
/**
* @class mem_allocator_debug_t
* @parent mem_allocator_t
*
* 对现有的allocator进行包装，记录分配的内存，用于帮助分析内存的使用和泄露。
*
*/
typedef struct _mem_allocator_debug_t {
mem_allocator_t allocator;
mem_allocator_t* impl;
} mem_allocator_debug_t;
#define MEM_ALLOCATOR_DEBUG(allocator) ((mem_allocator_debug_t*)(allocator))
typedef struct _mem_entry_t {
void* addr;
const char* func;
uint32_t line;
uint32_t size;
} mem_entry_t;
static mem_entry_t s_mem_log[10 * 1024];
#define MEM_ALLOCATOR_STD(allocator) ((mem_allocator_std_t*)(allocator))
static inline ret_t mem_entry_add(void* addr, uint32_t size, const char* func, uint32_t line) {
uint32_t i = 0;
uint32_t n = ARRAY_SIZE(s_mem_log);
for (i = 0; i < n; i++) {
mem_entry_t* iter = s_mem_log + i;
if (iter->addr == NULL) {
iter->addr = addr;
iter->size = size;
iter->func = func;
iter->line = line;
return RET_OK;
}
}
return RET_FAIL;
}
static inline ret_t mem_entry_remove(void* addr) {
uint32_t i = 0;
uint32_t n = ARRAY_SIZE(s_mem_log);
for (i = 0; i < n; i++) {
mem_entry_t* iter = s_mem_log + i;
if (iter->addr == addr) {
iter->addr = NULL;
iter->func = NULL;
iter->size = 0;
iter->line = 0;
return RET_OK;
}
}
return RET_FAIL;
}
static inline void mem_entry_dump(void) {
uint32_t i = 0;
uint32_t leq8 = 0;
uint32_t leq16 = 0;
uint32_t leq32 = 0;
uint32_t leq48 = 0;
uint32_t leq64 = 0;
uint32_t geq1024 = 0;
uint32_t geq10240 = 0;
uint32_t geq102400 = 0;
uint32_t used_block = 0;
uint32_t used_size = 0;
uint32_t n = ARRAY_SIZE(s_mem_log);
for (i = 0; i < n; i++) {
mem_entry_t* iter = s_mem_log + i;
if (iter->addr != NULL) {
used_block++;
used_size += iter->size;
if (iter->size <= 8) {
leq8++;
} else if (iter->size <= 16) {
leq16++;
} else if (iter->size <= 32) {
leq32++;
} else if (iter->size <= 48) {
leq48++;
} else if (iter->size <= 64) {
leq64++;
} else if (iter->size >= 1024) {
geq1024++;
} else if (iter->size >= 10240) {
geq10240++;
} else if (iter->size >= 102400) {
geq102400++;
}
log_debug("[%d] %p %u %s:%u\n", i, iter->addr, iter->size, iter->func, iter->line);
}
}
log_info(
"mem_info: used_block=%u used_size=%u <=8=%u <=16=%u <=32=%u <=48=%u <=64=%u >=1024=%u "
">=10240=%u >=102400=%u\n",
used_block, used_size, leq8, leq16, leq32, leq48, leq64, geq1024, geq10240, geq102400);
return;
}
static inline void* mem_allocator_debug_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
void* addr = NULL;
mem_allocator_t* impl = MEM_ALLOCATOR_DEBUG(allocator)->impl;
addr = mem_allocator_alloc(impl, size, func, line);
if (addr != NULL) {
mem_entry_add(addr, size, func, line);
}
return addr;
}
static inline void* mem_allocator_debug_realloc(mem_allocator_t* allocator, void* ptr,
uint32_t size, const char* func, uint32_t line) {
void* addr = NULL;
mem_allocator_t* impl = MEM_ALLOCATOR_DEBUG(allocator)->impl;
addr = mem_allocator_realloc(impl, ptr, size, func, line);
if (addr != NULL) {
if (ptr != NULL) {
mem_entry_remove(ptr);
}
mem_entry_add(addr, size, func, line);
}
return addr;
}
static inline void mem_allocator_debug_free(mem_allocator_t* allocator, void* ptr) {
mem_allocator_t* impl = MEM_ALLOCATOR_DEBUG(allocator)->impl;
if (ptr != NULL) {
mem_entry_remove(ptr);
mem_allocator_free(impl, ptr);
}
}
static inline ret_t mem_allocator_debug_dump(mem_allocator_t* allocator) {
mem_allocator_t* impl = MEM_ALLOCATOR_DEBUG(allocator)->impl;
mem_entry_dump();
mem_allocator_dump(impl);
return RET_OK;
}
static inline ret_t mem_allocator_debug_destroy(mem_allocator_t* allocator) {
mem_allocator_t* impl = MEM_ALLOCATOR_DEBUG(allocator)->impl;
mem_allocator_destroy(impl);
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_debug_vtable = {
.alloc = mem_allocator_debug_alloc,
.realloc = mem_allocator_debug_realloc,
.free = mem_allocator_debug_free,
.dump = mem_allocator_debug_dump,
.destroy = mem_allocator_debug_destroy};
static inline mem_allocator_t* mem_allocator_debug_init(mem_allocator_debug_t* debug,
mem_allocator_t* impl) {
mem_allocator_t* allocator = MEM_ALLOCATOR(debug);
return_value_if_fail(impl != NULL && debug != NULL, NULL);
memset(debug, 0x00, sizeof(*debug));
debug->impl = impl;
allocator->vt = &s_mem_allocator_debug_vtable;
return allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_DEBUG_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_darray_thread.c
|
/**
* File: action_darray_thread.c
* Author: AWTK Develop Team
* Brief: action_darray_thread
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-3-25 vih created
*
*/
#include "tkc/mem.h"
#include "tkc/waitable_action_darray.h"
#include "tkc/action_darray_thread.h"
static void* action_darray_thread_entry(void* args) {
done_event_t done;
action_darray_thread_t* thread = (action_darray_thread_t*)args;
thread->quit = FALSE;
thread->quited = FALSE;
log_debug("action thread start\n");
while (!(thread->quit)) {
qaction_t* action = NULL;
while (waitable_action_darray_recv(thread->darray, &action, thread->idle_interval) == RET_OK) {
ret_t ret = qaction_exec(action);
if (ret == RET_QUIT) {
thread->quit = TRUE;
}
if (qaction_notify(action, done_event_init(&done, ret)) == RET_NOT_IMPL) {
qaction_destroy(action);
}
if (thread->quit) {
break;
}
thread->executed_actions_nr++;
}
if (thread->on_idle != NULL) {
if (thread->on_idle(thread->on_idle_ctx, thread) == RET_QUIT) {
thread->quit = TRUE;
break;
}
}
}
thread->quited = TRUE;
if (thread->on_quit != NULL) {
thread->on_quit(thread->on_quit_ctx, thread);
}
log_debug("action thread done\n");
return NULL;
}
static action_darray_thread_t* action_darray_thread_create_internal(void) {
action_darray_thread_t* thread = NULL;
thread = TKMEM_ZALLOC(action_darray_thread_t);
return_value_if_fail(thread != NULL, NULL);
thread->thread = tk_thread_create(action_darray_thread_entry, thread);
goto_error_if_fail(thread->thread != NULL);
thread->idle_interval = 1000;
return thread;
error:
TKMEM_FREE(thread);
return NULL;
}
action_darray_thread_t* action_darray_thread_create(void) {
return action_darray_thread_create_ex(NULL, 0, TK_THREAD_PRIORITY_NORMAL);
}
action_darray_thread_t* action_darray_thread_create_ex(const char* name, uint32_t stack_size,
tk_thread_priority_t priority) {
action_darray_thread_t* thread = NULL;
waitable_action_darray_t* darray = waitable_action_darray_create(10);
return_value_if_fail(darray != NULL, NULL);
thread = action_darray_thread_create_internal();
if (thread != NULL) {
thread->darray = darray;
if (name != NULL) {
tk_thread_set_name(thread->thread, name);
}
if (priority != TK_THREAD_PRIORITY_NORMAL) {
tk_thread_set_priority(thread->thread, priority);
}
if (stack_size != 0) {
tk_thread_set_stack_size(thread->thread, stack_size);
}
tk_thread_start(thread->thread);
} else {
waitable_action_darray_destroy(darray);
}
return thread;
}
action_darray_thread_t* action_darray_thread_create_with_darray(waitable_action_darray_t* darray) {
return action_darray_thread_create_with_darray_ex(darray, NULL, 0, TK_THREAD_PRIORITY_NORMAL);
}
action_darray_thread_t* action_darray_thread_create_with_darray_ex(waitable_action_darray_t* darray,
const char* name,
uint32_t stack_size,
tk_thread_priority_t priority) {
action_darray_thread_t* thread = NULL;
return_value_if_fail(darray != NULL, NULL);
thread = action_darray_thread_create_internal();
return_value_if_fail(thread != NULL, NULL);
if (thread != NULL) {
thread->darray = darray;
thread->is_shared_darray = TRUE;
if (name != NULL) {
tk_thread_set_name(thread->thread, name);
}
if (priority != TK_THREAD_PRIORITY_NORMAL) {
tk_thread_set_priority(thread->thread, priority);
}
if (stack_size != 0) {
tk_thread_set_stack_size(thread->thread, stack_size);
}
tk_thread_start(thread->thread);
}
return thread;
}
ret_t action_darray_thread_set_strategy(action_darray_thread_t* thread,
action_darray_thread_strategy_t strategy) {
thread->strategy = strategy;
return RET_OK;
}
ret_t action_darray_thread_exec(action_darray_thread_t* thread, qaction_t* action) {
return_value_if_fail(thread != NULL && thread->darray != NULL, RET_BAD_PARAMS);
return_value_if_fail(action != NULL && action->exec != NULL, RET_BAD_PARAMS);
if (thread->strategy == ACTION_DARRAY_THREAD_STRATEGY_FLUSH) {
waitable_action_darray_remove(thread->darray, action->exec);
return waitable_action_darray_send(thread->darray, action, 3000);
} else if (thread->strategy == ACTION_DARRAY_THREAD_STRATEGY_REPLACE) {
if (waitable_action_darray_replace(thread->darray, action) != RET_OK) {
return waitable_action_darray_send(thread->darray, action, 3000);
}
return RET_OK;
} else {
return waitable_action_darray_send(thread->darray, action, 3000);
}
}
ret_t action_darray_thread_set_idle_interval(action_darray_thread_t* thread, uint32_t interval) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
thread->idle_interval = interval;
return RET_OK;
}
static ret_t qaction_quit_exec(qaction_t* action) {
return_value_if_fail(action != NULL, RET_BAD_PARAMS);
return RET_QUIT;
}
static ret_t action_darray_thread_quit(action_darray_thread_t* thread) {
qaction_t* a = qaction_create(qaction_quit_exec, NULL, 0);
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
if (thread->quited || !thread->darray) {
return RET_OK;
}
thread->quit = TRUE;
return waitable_action_darray_send(thread->darray, a, 3000);
}
ret_t action_darray_thread_destroy(action_darray_thread_t* thread) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
action_darray_thread_quit(thread);
tk_thread_join(thread->thread);
tk_thread_destroy(thread->thread);
if (!thread->is_shared_darray) {
waitable_action_darray_destroy(thread->darray);
}
TKMEM_FREE(thread);
return RET_OK;
}
ret_t action_darray_thread_set_on_idle(action_darray_thread_t* thread,
action_darray_thread_on_idle_t on_idle, void* ctx) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
thread->on_idle = on_idle;
thread->on_idle_ctx = ctx;
return RET_OK;
}
ret_t action_darray_thread_set_on_quit(action_darray_thread_t* thread,
action_darray_thread_on_quit_t on_quit, void* ctx) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
thread->on_quit = on_quit;
thread->on_quit_ctx = ctx;
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/utf8.h
|
/**
* File: utf8.h
* Author: AWTK Develop Team
* Brief: utf8 encode decode
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-14 Li XianJing <[email protected]> created
*
*/
#ifndef TK_UTF8_H
#define TK_UTF8_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class utf8_t
* @annotation ["fake"]
* wchar_t和char类型转换接口。
*
* 示例：
*
* ```c
* const char* str = "hello";
* const wchar_t* wstr = L"hello";
* char res_str[128];
* wchar_t res_wstr[128];
* tk_utf8_to_utf16(str, res_wstr, ARRAY_SIZE(res_wstr));
* tk_utf8_from_utf16(wstr, res_str, ARRAY_SIZE(res_str));
* ```
*/
/**
* @method tk_utf8_from_utf16
*
* 把ucs字符串转成UTF8字符串。
*
* @param {const wchar_t*} in 输入字符串。
* @param {char*} out 输出字符串。
* @param {uint32_t} out_size 输出字符串的最大长度。
*
*
* @return {char*} 返回UTF8字符串。
*/
char* tk_utf8_from_utf16(const wchar_t* in, char* out, uint32_t out_size);
/**
* @method tk_utf8_from_utf16_ex
*
* 把ucs字符串转成UTF8字符串。
*
* @param {const wchar_t*} in 输入字符串。
* @param {uint32_t} in_size 输入字符串的长度。
* @param {char*} out 输出字符串。
* @param {uint32_t} out_size 输出字符串的最大长度。
*
*
* @return {char*} 返回UTF8字符串。
*/
char* tk_utf8_from_utf16_ex(const wchar_t* in, uint32_t in_size, char* out, uint32_t out_size);
/**
* @method tk_utf8_to_utf16
*
* 将char类型转换为wchar_t类型。
*
* @param {const char*} str str。
* @param {wchar_t*} out 返回结果缓冲区。
* @param {uint32_t} out_size 缓冲区大小。
*
* @return {wchar_t*} 值。
*/
wchar_t* tk_utf8_to_utf16(const char* str, wchar_t* out, uint32_t out_size);
/**
* @method tk_utf8_to_utf16_ex
*
* 将char类型转换为wchar_t类型。
*
* @param {const char*} str str。
* @param {uint32_t} size 缓冲区大小。
* @param {wchar_t*} out 返回结果缓冲区。
* @param {uint32_t} out_size 缓冲区大小。
*
* @return {wchar_t*} 值。
*/
wchar_t* tk_utf8_to_utf16_ex(const char* str, uint32_t size, wchar_t* out, uint32_t out_size);
/**
* @method tk_utf8_dup_utf16
*
* 把ucs字符串转成UTF8字符串。
* > 由调用者释放返回的指针。
*
* @param {const wchar_t*} in 输入字符串。
* @param {int32_t} size 字符串长度。
*
* @return {char*} 返回UTF8字符串。
*/
char* tk_utf8_dup_utf16(const wchar_t* in, int32_t size);
/**
* @method tk_utf8_get_bytes_of_leading
* 获取第一个字节为c的字符的字节数。
* @param {uint8_t} c 字符的第一个字节。
*
* @return {uint32_t} 返回字符的字节数。
*/
uint32_t tk_utf8_get_bytes_of_leading(uint8_t c);
/**
* @method tk_utf8_trim_invalid_char
*
* 如果字符串最后一个字符串是无效的，删掉该无效字符。
*
* > 对于用strncpy/snprintf等生成字符串时，如果目标字符串内存大小不够，
* > 可能最后一个字符被从中间截断，导致该字符是无效的，这可能会触发assert，
* > 本函数可以用来删除最后一个无效字符。
*
* @param {char*} str 输入字符串。
*
* @return {char*} 返回UTF8字符串。
*/
char* tk_utf8_trim_invalid_char(char* str);
END_C_DECLS
#endif /*TK_UTF8_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/matrix.c
|
/**
* File: matrix.c
* Author: AWTK Develop Team
* Brief: matrix
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; withm even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-03-23 Li XianJing <[email protected]> created. adapted
* from:https://github.com/toji/gl-matrix/tree/master/src/gl-matrix
*
*/
#include <math.h>
#include "tkc/matrix.h"
matrix_t* matrix_init(matrix_t* m) {
return_value_if_fail(m != NULL, NULL);
return matrix_identity(m);
}
matrix_t* matrix_identity(matrix_t* m) {
return_value_if_fail(m != NULL, NULL);
m->a0 = 1;
m->a1 = 0;
m->a2 = 0;
m->a3 = 1;
m->a4 = 0;
m->a5 = 0;
return m;
}
matrix_t* matrix_invert(matrix_t* m) {
float aa = m->a0, ab = m->a1, ac = m->a2, ad = m->a3;
float atx = m->a4, aty = m->a5;
float det = aa * ad - ab * ac;
if (!det) {
return NULL;
}
det = 1.0f / det;
m->a0 = ad * det;
m->a1 = -ab * det;
m->a2 = -ac * det;
m->a3 = aa * det;
m->a4 = (ac * aty - ad * atx) * det;
m->a5 = (ab * atx - aa * aty) * det;
return m;
}
matrix_t* matrix_set(matrix_t* m, float a0, float a1, float a2, float a3, float a4, float a5) {
m->a0 = a0;
m->a1 = a1;
m->a2 = a2;
m->a3 = a3;
m->a4 = a4;
m->a5 = a5;
return m;
}
matrix_t* matrix_multiply(matrix_t* m, matrix_t* b) {
float a0 = m->a0, a1 = m->a1, a2 = m->a2, a3 = m->a3, a4 = m->a4, a5 = m->a5;
float b0 = b->a0, b1 = b->a1, b2 = b->a2, b3 = b->a3, b4 = b->a4, b5 = b->a5;
m->a0 = a0 * b0 + a2 * b1;
m->a1 = a1 * b0 + a3 * b1;
m->a2 = a0 * b2 + a2 * b3;
m->a3 = a1 * b2 + a3 * b3;
m->a4 = a0 * b4 + a2 * b5 + a4;
m->a5 = a1 * b4 + a3 * b5 + a5;
return m;
}
matrix_t* matrix_translate(matrix_t* m, xy_t x, xy_t y) {
float a0 = m->a0, a1 = m->a1, a2 = m->a2, a3 = m->a3, a4 = m->a4, a5 = m->a5;
m->a0 = a0;
m->a1 = a1;
m->a2 = a2;
m->a3 = a3;
m->a4 = a0 * x + a2 * y + a4;
m->a5 = a1 * x + a3 * y + a5;
return m;
}
matrix_t* matrix_scale(matrix_t* m, float sx, float sy) {
float a0 = m->a0, a1 = m->a1, a2 = m->a2, a3 = m->a3, a4 = m->a4, a5 = m->a5;
m->a0 = a0 * sx;
m->a1 = a1 * sx;
m->a2 = a2 * sy;
m->a3 = a3 * sy;
m->a4 = a4;
m->a5 = a5;
return m;
}
matrix_t* matrix_rotate(matrix_t* m, float rad) {
float a0 = m->a0, a1 = m->a1, a2 = m->a2, a3 = m->a3, a4 = m->a4, a5 = m->a5, s = sin(rad),
c = cos(rad);
m->a0 = a0 * c + a2 * s;
m->a1 = a1 * c + a3 * s;
m->a2 = a0 * -s + a2 * c;
m->a3 = a1 * -s + a3 * c;
m->a4 = a4;
m->a5 = a5;
return m;
}
matrix_t* matrix_transform_point(matrix_t* m, xy_t x, xy_t y, xy_t* ox, xy_t* oy) {
float x1 = m->a0 * x + m->a2 * y + m->a4;
float y1 = m->a1 * x + m->a3 * y + m->a5;
*ox = x1 > 0 ? x1 + 0.5f : x1 - 0.5f;
*oy = y1 > 0 ? y1 + 0.5f : y1 - 0.5f;
return m;
}
matrix_t* matrix_transform_pointf(matrix_t* m, float x, float y, float* ox, float* oy) {
float x1 = m->a0 * x + m->a2 * y + m->a4;
float y1 = m->a1 * x + m->a3 * y + m->a5;
*ox = x1;
*oy = y1;
return m;
}
static double matrix_compute_determinant(matrix_t* m) {
double a = m->a0;
double b = m->a1;
double c = m->a2;
double d = m->a3;
return a * d - b * c;
}
bool_t matrix_is_invertible(matrix_t* m) {
double det = matrix_compute_determinant(m);
return TK_ISFINITE(det) && det != 0.;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/zip_file.c
|
/**
* File: zip_file.c
* Author: AWTK Develop Team
* Brief: zip file
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-19 Li XianJing <[email protected]> created
*
*/
#include "miniz/miniz.h"
#include "miniz/miniz_zip.h"
#include "tkc/fs.h"
#include "tkc/path.h"
#include "tkc/buffer.h"
ret_t zip_file_extract(const char* zipfile, const char* dst_dir, const char* password) {
mz_zip_archive zip;
mz_uint i = 0;
mz_uint nr = 0;
ret_t ret = RET_OK;
char filename[MAX_PATH + 1];
char full_path[MAX_PATH + 1];
memset(&zip, 0x00, sizeof(zip));
return_value_if_fail(zipfile != NULL && dst_dir != NULL, RET_BAD_PARAMS);
return_value_if_fail(mz_zip_reader_init_file(&zip, zipfile, 0), RET_BAD_PARAMS);
nr = mz_zip_reader_get_num_files(&zip);
for (i = 0; i < nr; i++) {
int ret = mz_zip_reader_get_filename(&zip, i, filename, MAX_PATH);
if (ret > 0) {
filename[ret] = '\0';
} else {
ret = RET_FAIL;
break;
}
path_build(full_path, MAX_PATH, dst_dir, filename, NULL);
log_debug("%s => %s\n", filename, full_path);
if (mz_zip_reader_is_file_a_directory(&zip, i)) {
fs_create_dir_r(os_fs(), full_path);
} else {
if (!mz_zip_reader_extract_file_to_file(&zip, filename, full_path, 0)) {
ret = RET_FAIL;
break;
}
}
}
mz_zip_reader_end(&zip);
return ret;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/tokenizer.c
|
/**
* File: tokenizer.c
* Author: AWTK Develop Team
* Brief: tokenizer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is ditokenizeributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-17 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/utils.h"
#include "tkc/tokenizer.h"
tokenizer_t* tokenizer_init_ex(tokenizer_t* tokenizer, const char* str, uint32_t size,
const char* separtor, const char* single_char_token) {
uint32_t str_size = 0;
return_value_if_fail(tokenizer != NULL && str != NULL && separtor != NULL, NULL);
str_size = strlen(str);
tokenizer->str = str;
tokenizer->cursor = 0;
tokenizer->separtor = separtor;
tokenizer->size = tk_min(str_size, size);
tokenizer->single_char_token = single_char_token;
str_init(&(tokenizer->token), 20);
return tokenizer;
}
tokenizer_t* tokenizer_init(tokenizer_t* tokenizer, const char* str, uint32_t size,
const char* separtor) {
return tokenizer_init_ex(tokenizer, str, size, separtor, NULL);
}
static ret_t tokenizer_skip_separator(tokenizer_t* tokenizer) {
return_value_if_fail(tokenizer != NULL, RET_BAD_PARAMS);
while (tokenizer->cursor < tokenizer->size) {
char c = tokenizer->str[tokenizer->cursor];
if (strchr(tokenizer->separtor, c) != NULL) {
tokenizer->cursor++;
} else {
break;
}
}
return RET_OK;
}
static ret_t tokenizer_skip_non_separator(tokenizer_t* tokenizer) {
const char* separtor = NULL;
const char* single_char_token = NULL;
return_value_if_fail(tokenizer != NULL, RET_BAD_PARAMS);
separtor = tokenizer->separtor;
single_char_token = tokenizer->single_char_token != NULL ? tokenizer->single_char_token : "";
while (tokenizer->cursor < tokenizer->size) {
char c = tokenizer->str[tokenizer->cursor];
if (strchr(separtor, c) == NULL && strchr(single_char_token, c) == NULL) {
tokenizer->cursor++;
} else {
break;
}
}
return RET_OK;
}
bool_t tokenizer_has_more(tokenizer_t* tokenizer) {
return_value_if_fail(tokenizer != NULL, FALSE);
return tokenizer->cursor < tokenizer->size;
}
static ret_t tokenizer_skip_quoted_str(tokenizer_t* tokenizer) {
bool_t escaped = FALSE;
char c = tokenizer->str[tokenizer->cursor];
char quot_c = c;
return_value_if_fail(c == '\"' || c == '\'', RET_BAD_PARAMS);
tokenizer->cursor++;
while (tokenizer->str[tokenizer->cursor]) {
c = tokenizer->str[tokenizer->cursor++];
if (c == quot_c) {
if (!escaped) {
break;
}
}
if (c == '\\') {
escaped = !escaped;
} else {
escaped = FALSE;
}
}
return RET_OK;
}
static ret_t tokenizer_closing_bracket_until(tokenizer_t* tokenizer, char opening_bracket,
char closing_bracket) {
int32_t lparent = 1;
tokenizer->cursor++;
while (tokenizer->str[tokenizer->cursor]) {
char c = tokenizer->str[tokenizer->cursor];
if (c == '\"' || c == '\'') {
tokenizer_skip_quoted_str(tokenizer);
continue;
} else if (c == opening_bracket) {
lparent++;
} else if (c == closing_bracket) {
lparent--;
if (lparent <= 0) {
tokenizer->cursor++;
break;
}
}
tokenizer->cursor++;
}
return RET_OK;
}
const char* tokenizer_next_str_until(tokenizer_t* tokenizer, const char* str) {
return_value_if_fail(tokenizer_skip_separator(tokenizer) == RET_OK && str != NULL, NULL);
if (tokenizer_has_more(tokenizer)) {
uint32_t len = 0;
str_t* s = &(tokenizer->token);
uint32_t start = tokenizer->cursor;
char c = tokenizer->str[tokenizer->cursor];
if (c == '\"' || c == '\'') {
return tokenizer_next_str(tokenizer);
}
while (tokenizer->str[tokenizer->cursor]) {
c = tokenizer->str[tokenizer->cursor];
if (strchr(str, c) != NULL) {
break;
}
tokenizer->cursor++;
}
len = tokenizer->cursor - start;
str_set_with_len(s, tokenizer->str + start, len);
tokenizer_skip_separator(tokenizer);
return s->str;
}
return NULL;
}
const char* tokenizer_next_expr_until(tokenizer_t* tokenizer, const char* str) {
return_value_if_fail(tokenizer_skip_separator(tokenizer) == RET_OK && str != NULL, NULL);
if (tokenizer_has_more(tokenizer)) {
uint32_t len = 0;
str_t* s = &(tokenizer->token);
uint32_t start = tokenizer->cursor;
while (tokenizer->str[tokenizer->cursor]) {
char c = tokenizer->str[tokenizer->cursor];
if (c == '\"' || c == '\'') {
tokenizer_skip_quoted_str(tokenizer);
continue;
} else if (c == '(') {
tokenizer_closing_bracket_until(tokenizer, '(', ')');
continue;
} else if (c == '{') {
tokenizer_closing_bracket_until(tokenizer, '{', '}');
continue;
} else if (c == '[') {
tokenizer_closing_bracket_until(tokenizer, '[', ']');
continue;
}
if (strchr(str, c) != NULL) {
break;
}
tokenizer->cursor++;
}
len = tokenizer->cursor - start;
str_set_with_len(s, tokenizer->str + start, len);
tokenizer_skip_separator(tokenizer);
return s->str;
}
return NULL;
}
const char* tokenizer_next_until(tokenizer_t* tokenizer, const char* str) {
return_value_if_fail(tokenizer_skip_separator(tokenizer) == RET_OK && str != NULL, NULL);
if (tokenizer_has_more(tokenizer)) {
uint32_t len = 0;
str_t* s = &(tokenizer->token);
uint32_t start = tokenizer->cursor;
while (tokenizer->str[tokenizer->cursor]) {
char c = tokenizer->str[tokenizer->cursor];
if (strchr(str, c) != NULL) {
break;
}
tokenizer->cursor++;
}
len = tokenizer->cursor - start;
str_set_with_len(s, tokenizer->str + start, len);
tokenizer_skip_separator(tokenizer);
return s->str;
}
return NULL;
}
const char* tokenizer_next_str(tokenizer_t* tokenizer) {
const char* ret = NULL;
return_value_if_fail(tokenizer_skip_separator(tokenizer) == RET_OK, NULL);
if (tokenizer_has_more(tokenizer)) {
char start = tokenizer->str[tokenizer->cursor];
if (start == '"') {
tokenizer->cursor++;
ret = tokenizer_next_until(tokenizer, "\"");
tokenizer->cursor++;
} else if (start == '\'') {
tokenizer->cursor++;
ret = tokenizer_next_until(tokenizer, "'");
tokenizer->cursor++;
} else {
ret = tokenizer_next(tokenizer);
}
}
return ret;
}
const char* tokenizer_next(tokenizer_t* tokenizer) {
return_value_if_fail(tokenizer_skip_separator(tokenizer) == RET_OK, NULL);
if (tokenizer_has_more(tokenizer)) {
uint32_t len = 0;
str_t* s = &(tokenizer->token);
uint32_t start = tokenizer->cursor;
if (tokenizer->single_char_token != NULL) {
if (strchr(tokenizer->single_char_token, tokenizer->str[start]) != NULL) {
str_set_with_len(s, tokenizer->str + start, 1);
tokenizer->cursor++;
return s->str;
}
}
tokenizer_skip_non_separator(tokenizer);
len = tokenizer->cursor - start;
str_set_with_len(s, tokenizer->str + start, len);
tokenizer_skip_separator(tokenizer);
return s->str;
}
return NULL;
}
int tokenizer_next_int(tokenizer_t* tokenizer, int defval) {
return_value_if_fail(tokenizer != NULL, defval);
if (tokenizer_has_more(tokenizer)) {
return tk_atoi(tokenizer_next(tokenizer));
} else {
return defval;
}
}
int64_t tokenizer_next_int64(tokenizer_t* tokenizer, int64_t defval) {
return_value_if_fail(tokenizer != NULL, defval);
if (tokenizer_has_more(tokenizer)) {
return tk_atol(tokenizer_next(tokenizer));
} else {
return defval;
}
}
float tokenizer_next_float(tokenizer_t* tokenizer, float defval) {
return_value_if_fail(tokenizer != NULL, defval);
if (tokenizer_has_more(tokenizer)) {
return tk_atof(tokenizer_next(tokenizer));
} else {
return defval;
}
}
ret_t tokenizer_deinit(tokenizer_t* tokenizer) {
return_value_if_fail(tokenizer != NULL, RET_BAD_PARAMS);
str_reset(&(tokenizer->token));
memset(tokenizer, 0x00, sizeof(tokenizer_t));
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/matrix.h
|
/**
* File: matrix.h
* Author: AWTK Develop Team
* Brief: matrix struct and utils functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-03-23 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MATRIX_H
#define TK_MATRIX_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class matrix_t
* 2D矩阵对象。
*/
typedef struct _matrix_t {
float a0;
float a1;
float a2;
float a3;
float a4;
float a5;
} matrix_t;
/**
* @method matrix_init
* 初始化矩阵对象。
*
* @param {matrix_t*} m 矩阵对象。
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_init(matrix_t* m);
/**
* @method matrix_identity
* 重置矩阵对象为单位矩阵。
*
* @param {matrix_t*} m 矩阵对象。
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_identity(matrix_t* m);
/**
* @method matrix_invert
* 求矩阵的逆。
*
* @param {matrix_t*} m 矩阵对象。
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_invert(matrix_t* m);
/**
* @method matrix_set
* 设置矩阵的参数。
*
* @param {matrix_t*} m 矩阵对象。
* @param {float} a0 a0
* @param {float} a1 a1
* @param {float} a2 a2
* @param {float} a3 a3
* @param {float} a4 a4
* @param {float} a5 a5
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_set(matrix_t* m, float a0, float a1, float a2, float a3, float a4, float a5);
/**
* @method matrix_multiply
* 矩阵相乘。
*
* @param {matrix_t*} m 矩阵对象。
* @param {matrix_t*} b 矩阵对象。
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_multiply(matrix_t* m, matrix_t* b);
/**
* @method matrix_translate
* 平移。
*
* @param {matrix_t*} m 矩阵对象。
* @param {xy_t} x x
* @param {xy_t} y y
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_translate(matrix_t* m, xy_t x, xy_t y);
/**
* @method matrix_scale
* 缩放。
*
* @param {matrix_t*} m 矩阵对象。
* @param {float} sx sx
* @param {float} sy sy
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_scale(matrix_t* m, float sx, float sy);
/**
* @method matrix_rotate
* 旋转。
*
* @param {matrix_t*} m 矩阵对象。
* @param {float} rad 角度。
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_rotate(matrix_t* m, float rad);
/**
* @method matrix_transform_point
* 对点进行变换。
*
* @param {matrix_t*} m 矩阵对象。
* @param {xy_t} x x
* @param {xy_t} y y
* @param {xy_t*} out_x out_x
* @param {xy_t*} out_y out_y
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_transform_point(matrix_t* m, xy_t x, xy_t y, xy_t* out_x, xy_t* out_y);
/**
* @method matrix_transform_pointf
* 对点进行变换。
*
* @param {matrix_t*} m 矩阵对象。
* @param {float} x x
* @param {float} y y
* @param {float*} ox out_x
* @param {float*} oy out_y
*
* @return {matrix_t*} 矩阵对象。
*/
matrix_t* matrix_transform_pointf(matrix_t* m, float x, float y, float* ox, float* oy);
/**
* @method matrix_is_invertible
* 判断matrix是否可逆。
*
* @param {matrix_t*} m 矩阵对象。
*
* @return {bool_t} 返回TRUE表示可逆，否则表示不可逆。
*/
bool_t matrix_is_invertible(matrix_t* m);
END_C_DECLS
#endif /*TK_MATRIX_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/async.c
|
/**
* File: async.c
* Author: AWTK Develop Team
* Brief: async call
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ===============================================================
* 2019-05-11 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/event.h"
#include "tkc/async.h"
#include "tkc/action_thread_pool.h"
static action_thread_pool_t* s_async_thread_pool = NULL;
typedef struct _async_call_info_t {
void* ctx;
async_exec_t exec;
async_on_result_t on_result;
} async_call_info_t;
static ret_t async_call_info_init(async_call_info_t* info, async_exec_t exec,
async_on_result_t on_result, void* ctx) {
return_value_if_fail(info != NULL && exec != NULL, RET_BAD_PARAMS);
info->ctx = ctx;
info->exec = exec;
info->on_result = on_result;
return RET_OK;
}
static ret_t qaction_async_exec(qaction_t* action) {
async_call_info_t* info = (async_call_info_t*)action->args;
return info->exec(info->ctx);
}
static ret_t qaction_async_on_event(qaction_t* action, event_t* event) {
async_call_info_t* info = (async_call_info_t*)action->args;
if (event->type == EVT_DONE) {
done_event_t* e = (done_event_t*)event;
if (info->on_result != NULL) {
info->on_result(info->ctx, e->result);
}
qaction_destroy(action);
}
return RET_OK;
}
ret_t async_call(async_exec_t exec, async_on_result_t on_result, void* ctx) {
qaction_t* a = NULL;
async_call_info_t info;
return_value_if_fail(async_call_info_init(&info, exec, on_result, ctx) == RET_OK, RET_FAIL);
a = qaction_create(qaction_async_exec, &info, sizeof(info));
ENSURE(qaction_set_on_event(a, qaction_async_on_event) == RET_OK);
return action_thread_pool_exec(s_async_thread_pool, a);
}
ret_t async_call_init_ex(uint32_t max_threads, uint32_t min_threads) {
return async_call_init_ex2(max_threads, min_threads, 0);
}
ret_t async_call_init_ex2(uint32_t max_threads, uint32_t min_threads, uint32_t stack_size) {
return_value_if_fail(s_async_thread_pool == NULL, RET_BAD_PARAMS);
s_async_thread_pool =
action_thread_pool_create_ex(max_threads, min_threads, stack_size, TK_THREAD_PRIORITY_NORMAL);
return_value_if_fail(s_async_thread_pool != NULL, RET_BAD_PARAMS);
return RET_OK;
}
ret_t async_call_deinit(void) {
return_value_if_fail(s_async_thread_pool != NULL, RET_BAD_PARAMS);
action_thread_pool_destroy(s_async_thread_pool);
s_async_thread_pool = NULL;
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/general_factory.h
|
/**
* File: general_factory.h
* Author: AWTK Develop Team
* Brief: data writer factory
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2028-08-26 Li XianJing <[email protected]> created
*
*/
#ifndef TK_GENERAL_FACTORY_H
#define TK_GENERAL_FACTORY_H
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/darray.h"
BEGIN_C_DECLS
typedef struct _general_factory_const_item_t {
const char* name;
tk_create_t create;
} general_factory_const_item_t, general_factory_table_t;
#define FACTORY_TABLE_BEGIN(name) static const general_factory_const_item_t name[] = {
#define FACTORY_TABLE_ENTRY(name, create) {name, (tk_create_t)create},
#define FACTORY_TABLE_END() \
{ NULL, NULL } \
} \
;
typedef struct _general_factory_item_t {
const char* name;
tk_create_t create;
uint8_t const_name;
char data[1];
} general_factory_item_t;
static inline general_factory_item_t* general_factory_item_create(const char* name,
tk_create_t create,
bool_t is_const_name) {
general_factory_item_t* item = NULL;
uint32_t name_len = tk_strlen(name);
uint32_t len = sizeof(general_factory_item_t);
return_value_if_fail(create != NULL && name != NULL, NULL);
if (!is_const_name) {
len += name_len;
}
item = (general_factory_item_t*)TKMEM_ALLOC(len);
return_value_if_fail(item != NULL, NULL);
item->create = create;
item->const_name = is_const_name;
if (is_const_name) {
item->name = name;
} else {
tk_strncpy(item->data, name, name_len);
item->name = item->data;
}
return item;
}
static inline ret_t general_factory_item_destroy(general_factory_item_t* item) {
return_value_if_fail(item != NULL, RET_BAD_PARAMS);
TKMEM_FREE(item);
return RET_OK;
}
static inline int general_factory_item_compare_by_name(const void* a, const void* b) {
const general_factory_item_t* aa = (const general_factory_item_t*)a;
const char* name = (const char*)b;
return strcmp(aa->name, name);
}
static inline int general_factory_item_compare(const void* a, const void* b) {
const general_factory_item_t* aa = (const general_factory_item_t*)a;
const general_factory_item_t* bb = (const general_factory_item_t*)b;
return strcmp(aa->name, bb->name);
}
typedef struct _general_factory_t {
darray_t sorted;
darray_t creators;
} general_factory_t;
static inline general_factory_t* general_factory_init(general_factory_t* factory) {
memset(factory, 0x00, sizeof(general_factory_t));
darray_init(&(factory->sorted), 5, NULL, general_factory_item_compare);
darray_init(&(factory->creators), 5, (tk_destroy_t)general_factory_item_destroy,
general_factory_item_compare_by_name);
return factory;
}
static inline ret_t general_factory_unregister(general_factory_t* factory, const char* name) {
return_value_if_fail(factory != NULL && name != NULL, RET_BAD_PARAMS);
darray_remove_all(&(factory->sorted), general_factory_item_compare_by_name, (void*)name);
return darray_remove_all(&(factory->creators), general_factory_item_compare_by_name, (void*)name);
}
static inline ret_t general_factory_register_ex(general_factory_t* factory, const char* name,
tk_create_t create, bool_t is_const_name) {
general_factory_item_t* item = NULL;
return_value_if_fail(factory != NULL && name != NULL && create != NULL, RET_BAD_PARAMS);
item = general_factory_item_create(name, create, is_const_name);
return_value_if_fail(item != NULL, RET_OOM);
general_factory_unregister(factory, name);
if (darray_push(&(factory->creators), item) != RET_OK) {
general_factory_item_destroy(item);
return RET_OOM;
}
return darray_sorted_insert(&(factory->sorted), item, general_factory_item_compare, TRUE);
}
static inline ret_t general_factory_register_table(general_factory_t* factory,
const general_factory_const_item_t* table) {
const general_factory_const_item_t* iter = NULL;
return_value_if_fail(factory != NULL && table != NULL, RET_BAD_PARAMS);
iter = (const general_factory_const_item_t*)(table);
while (iter->name != NULL) {
ENSURE(darray_sorted_insert(&(factory->sorted), (void*)iter, general_factory_item_compare,
TRUE) == RET_OK);
iter++;
}
return RET_OK;
}
static inline ret_t general_factory_register(general_factory_t* factory, const char* name,
tk_create_t create) {
return general_factory_register_ex(factory, name, create, TRUE);
}
static inline tk_create_t general_factory_find(general_factory_t* factory, const char* name) {
const general_factory_item_t* item = NULL;
return_value_if_fail(factory != NULL && name != NULL, NULL);
item = (const general_factory_item_t*)darray_bsearch(
&(factory->sorted), general_factory_item_compare_by_name, (void*)name);
return item != NULL ? item->create : NULL;
}
static inline ret_t general_factory_deinit(general_factory_t* factory) {
return_value_if_fail(factory != NULL, RET_BAD_PARAMS);
darray_deinit(&(factory->sorted));
darray_deinit(&(factory->creators));
memset(factory, 0x00, sizeof(general_factory_t));
return RET_OK;
}
static inline general_factory_t* general_factory_create(void) {
general_factory_t* factroy = TKMEM_ZALLOC(general_factory_t);
return general_factory_init(factroy);
}
static inline ret_t general_factory_destroy(general_factory_t* factory) {
general_factory_deinit(factory);
TKMEM_FREE(factory);
return RET_OK;
}
END_C_DECLS
#endif /*TK_GENERAL_FACTORY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_manager.h
|
/**
* File: event_source_manager.h
* Author: AWTK Develop Team
* Brief: event manager manager
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-29 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_SOURCE_MANAGER_H
#define TK_EVENT_SOURCE_MANAGER_H
#include "tkc/darray.h"
#include "tkc/event_source.h"
BEGIN_C_DECLS
typedef ret_t (*event_source_manager_dispatch_t)(event_source_manager_t* manager);
typedef ret_t (*event_source_manager_destroy_t)(event_source_manager_t* manager);
/**
* @class event_source_manager_t
*
* 事件源管理器。
*
*/
struct _event_source_manager_t {
darray_t sources;
darray_t dispatching_sources;
event_source_manager_dispatch_t dispatch;
event_source_manager_destroy_t destroy;
uint32_t min_sleep_time;
};
/**
* @method event_source_manager_init
*
* 初始化。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_init(event_source_manager_t* manager);
/**
* @method event_source_manager_deinit
*
* ~初始化。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_deinit(event_source_manager_t* manager);
/**
* @method event_source_manager_get_wakeup_time
*
* 获取wakeup时间(微秒)
*
* @param {event_source_manager_t*} manager event_source_manager对象。
*
* @return {uint64_t} 返回wakeup时间(微秒)。
*
*/
uint64_t event_source_manager_get_wakeup_time(event_source_manager_t* manager);
/**
* @method event_source_manager_dispatch
*
* 分发事件。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_dispatch(event_source_manager_t* manager);
/**
* @method event_source_manager_add
*
* 增加事件源对象。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
* @param {event_source_t*} source event_source对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_add(event_source_manager_t* manager, event_source_t* source);
/**
* @method event_source_manager_remove
*
* 移除事件源对象。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
* @param {event_source_t*} source event_source对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_remove(event_source_manager_t* manager, event_source_t* source);
/**
* @method event_source_manager_remove_by_tag
*
* 移除所有tag相同的事件源对象。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
* @param {void*} tag tag。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_remove_by_tag(event_source_manager_t* manager, void* tag);
/**
* @method event_source_manager_set_min_sleep_time
*
* 设置默认最小睡眠时间(毫秒)。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
* @param {uint32_t} sleep_time 默认最小睡眠时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_set_min_sleep_time(event_source_manager_t* manager, uint32_t sleep_time);
/**
* @method event_source_manager_set_min_sleep_time_us
*
* 设置默认最小睡眠时间(微秒)。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
* @param {uint32_t} sleep_time 默认最小睡眠时间(微秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_set_min_sleep_time_us(event_source_manager_t* manager, uint32_t sleep_time);
/**
* @method event_source_manager_destroy
*
* 销毁事件源管理器。
*
* @param {event_source_manager_t*} manager event_source_manager对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t event_source_manager_destroy(event_source_manager_t* manager);
#define TK_EVENT_SOURCE_MANAGER(obj) ((event_source_manager_t*)(obj))
/*public for test*/
bool_t event_source_manager_exist(event_source_manager_t* manager, event_source_t* source);
END_C_DECLS
#endif /*TK_EVENT_SOURCE_MANAGER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_manager.c
|
/**
* File: event_source_manager.c
* Author: AWTK Develop Team
* Brief: event manager manager
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-29 Li XianJing <[email protected]> created
*
*/
#include "tkc/event_source_manager.h"
ret_t event_source_manager_init(event_source_manager_t* manager) {
return_value_if_fail(manager != NULL, RET_BAD_PARAMS);
darray_init(&(manager->sources), 5, (tk_destroy_t)(tk_object_unref), NULL);
darray_init(&(manager->dispatching_sources), 5, (tk_destroy_t)(tk_object_unref), NULL);
return RET_OK;
}
ret_t event_source_manager_deinit(event_source_manager_t* manager) {
return_value_if_fail(manager != NULL, RET_BAD_PARAMS);
darray_deinit(&(manager->sources));
darray_deinit(&(manager->dispatching_sources));
return RET_OK;
}
static ret_t event_source_manager_prepare(event_source_manager_t* manager) {
uint32_t i = 0;
uint32_t n = 0;
event_source_t** sources = NULL;
return_value_if_fail(manager != NULL && manager->dispatch != NULL, RET_BAD_PARAMS);
n = manager->sources.size;
sources = (event_source_t**)(manager->sources.elms);
for (i = 0; i < n; i++) {
event_source_t* iter = sources[i];
tk_object_ref(TK_OBJECT(iter));
darray_push(&(manager->dispatching_sources), iter);
}
return RET_OK;
}
ret_t event_source_manager_dispatch(event_source_manager_t* manager) {
ret_t ret = RET_FAIL;
return_value_if_fail(event_source_manager_prepare(manager) == RET_OK, RET_BAD_PARAMS);
ret = manager->dispatch(manager);
darray_clear(&(manager->dispatching_sources));
return ret;
}
ret_t event_source_manager_add(event_source_manager_t* manager, event_source_t* source) {
return_value_if_fail(manager != NULL && source != NULL, RET_BAD_PARAMS);
tk_object_ref(TK_OBJECT(source));
source->manager = manager;
return darray_push(&(manager->sources), source);
}
bool_t event_source_manager_exist(event_source_manager_t* manager, event_source_t* source) {
return_value_if_fail(manager != NULL && source != NULL, RET_BAD_PARAMS);
return darray_find(&(manager->sources), source) != NULL;
}
ret_t event_source_manager_remove(event_source_manager_t* manager, event_source_t* source) {
return_value_if_fail(manager != NULL && source != NULL, RET_BAD_PARAMS);
source->manager = NULL;
return darray_remove(&(manager->sources), source);
}
static int event_source_compare_by_tag(const void* a, const void* b) {
const event_source_t* source = (const event_source_t*)a;
return (source->tag == b) ? 0 : 1;
}
ret_t event_source_manager_remove_by_tag(event_source_manager_t* manager, void* tag) {
return darray_remove_all(&(manager->sources), event_source_compare_by_tag, tag);
}
ret_t event_source_manager_destroy(event_source_manager_t* manager) {
return_value_if_fail(manager != NULL && manager->destroy != NULL, RET_BAD_PARAMS);
event_source_manager_deinit(manager);
return manager->destroy(manager);
}
uint64_t event_source_manager_get_wakeup_time(event_source_manager_t* manager) {
uint32_t i = 0;
uint32_t t = 0;
uint32_t n = 0;
event_source_t* iter = NULL;
uint64_t wakeup_time = 0xffff;
event_source_t** sources = NULL;
return_value_if_fail(manager != NULL, 0);
n = manager->sources.size;
sources = (event_source_t**)(manager->sources.elms);
if (n > 0) {
for (i = 0; i < n; i++) {
iter = sources[i];
t = event_source_get_wakeup_time(iter);
if (t < wakeup_time) {
wakeup_time = t;
}
}
wakeup_time = wakeup_time * 1000;
} else {
wakeup_time = manager->min_sleep_time;
}
return tk_min(manager->min_sleep_time, wakeup_time);
}
ret_t event_source_manager_set_min_sleep_time_us(event_source_manager_t* manager,
uint32_t sleep_time) {
return_value_if_fail(manager != NULL, RET_BAD_PARAMS);
manager->min_sleep_time = sleep_time;
return RET_OK;
}
ret_t event_source_manager_set_min_sleep_time(event_source_manager_t* manager,
uint32_t sleep_time) {
return event_source_manager_set_min_sleep_time_us(manager, sleep_time * 1000);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/idle_manager.c
|
/**
* File: idle.c
* Author: AWTK Develop Team
* Brief: idle manager
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/time_now.h"
#include "tkc/idle_manager.h"
static idle_manager_t* s_idle_manager;
idle_manager_t* idle_manager(void) {
return s_idle_manager;
}
ret_t idle_manager_set(idle_manager_t* idle_manager) {
s_idle_manager = idle_manager;
return RET_OK;
}
idle_manager_t* idle_manager_create(void) {
idle_manager_t* idle_manager = TKMEM_ZALLOC(idle_manager_t);
return idle_manager_init(idle_manager);
}
idle_manager_t* idle_manager_init(idle_manager_t* idle_manager) {
return_value_if_fail(idle_manager != NULL, NULL);
idle_manager->next_idle_id = TK_INVALID_ID + 1;
slist_init(&(idle_manager->idles), (tk_destroy_t)tk_object_unref, idle_info_compare_by_id);
return idle_manager;
}
ret_t idle_manager_deinit(idle_manager_t* idle_manager) {
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
return slist_deinit(&(idle_manager->idles));
}
ret_t idle_manager_remove_all(idle_manager_t* idle_manager) {
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
return slist_remove_all(&(idle_manager->idles));
}
ret_t idle_manager_remove_all_by_ctx_and_type(idle_manager_t* idle_manager, uint16_t type,
void* ctx) {
idle_info_t idle;
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
return slist_remove_with_compare(&(idle_manager->idles),
idle_info_init_dummy_with_ctx_and_type(&idle, type, ctx),
idle_info_compare_by_ctx_and_type, -1);
}
ret_t idle_manager_remove_all_by_ctx(idle_manager_t* idle_manager, void* ctx) {
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
return slist_remove_with_compare(&(idle_manager->idles), ctx, idle_info_compare_by_ctx, -1);
}
ret_t idle_manager_destroy(idle_manager_t* idle_manager) {
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
idle_manager_deinit(idle_manager);
TKMEM_FREE(idle_manager);
return RET_OK;
}
uint32_t idle_manager_get_next_idle_id(idle_manager_t* idle_manager) {
uint32_t next_idle_id = 0;
return_value_if_fail(idle_manager != NULL, TK_INVALID_ID);
do {
next_idle_id = idle_manager->next_idle_id++;
if (next_idle_id == TK_INVALID_ID) {
next_idle_id = idle_manager->next_idle_id++;
}
} while (idle_manager_find(idle_manager, next_idle_id) != NULL);
return next_idle_id;
}
ret_t idle_manager_append(idle_manager_t* idle_manager, idle_info_t* idle) {
return_value_if_fail(idle_manager != NULL && idle != NULL, RET_BAD_PARAMS);
return slist_append(&(idle_manager->idles), idle);
}
uint32_t idle_manager_add(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx) {
return idle_manager_add_with_type(idle_manager, on_idle, ctx, IDLE_INFO_NORMAL);
}
uint32_t idle_manager_add_with_id(idle_manager_t* idle_manager, uint32_t id, idle_func_t on_idle,
void* ctx) {
return idle_manager_add_with_type_and_id(idle_manager, id, on_idle, ctx, IDLE_INFO_NORMAL, TRUE);
}
uint32_t idle_manager_add_with_type(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx,
uint16_t type) {
uint32_t id = TK_INVALID_ID;
return_value_if_fail(idle_manager != NULL, TK_INVALID_ID);
id = idle_manager_get_next_idle_id(idle_manager);
return idle_manager_add_with_type_and_id(idle_manager, id, on_idle, ctx, type, FALSE);
}
uint32_t idle_manager_add_with_type_and_id(idle_manager_t* idle_manager, uint32_t id,
idle_func_t on_idle, void* ctx, uint16_t type,
bool_t check_id) {
idle_info_t* idle = NULL;
return_value_if_fail(on_idle != NULL, TK_INVALID_ID);
return_value_if_fail(idle_manager != NULL, TK_INVALID_ID);
if (check_id) {
if (idle_manager_find(idle_manager, id) != NULL) {
return TK_INVALID_ID;
}
}
idle = idle_info_create(idle_manager, id, on_idle, ctx, type);
return_value_if_fail(idle != NULL, TK_INVALID_ID);
return idle->id;
}
ret_t idle_manager_remove(idle_manager_t* idle_manager, uint32_t idle_id) {
idle_info_t idle;
return_value_if_fail(idle_id != TK_INVALID_ID, RET_BAD_PARAMS);
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
return slist_remove(&(idle_manager->idles), idle_info_init_dummy(&idle, idle_id));
}
const idle_info_t* idle_manager_find(idle_manager_t* idle_manager, uint32_t idle_id) {
idle_info_t idle;
return_value_if_fail(idle_id != TK_INVALID_ID, NULL);
return_value_if_fail(idle_manager != NULL, NULL);
return slist_find(&(idle_manager->idles), idle_info_init_dummy(&idle, idle_id));
}
static ret_t idle_manager_dispatch_one(idle_manager_t* idle_manager, uint32_t dispatch_id) {
slist_node_t* iter = idle_manager->idles.first;
while (iter != NULL && !idle_info_is_available(IDLE_INFO(iter->data), dispatch_id)) {
iter = iter->next;
}
if (iter != NULL) {
idle_info_t* idle = (idle_info_t*)tk_object_ref((tk_object_t*)(iter->data));
return_value_if_fail(idle != NULL, RET_BAD_PARAMS);
if (idle_info_on_idle(idle, dispatch_id) != RET_REPEAT) {
idle_manager_remove(idle_manager, idle->id);
}
tk_object_unref((tk_object_t*)idle);
return RET_OK;
}
return RET_DONE;
}
ret_t idle_manager_dispatch(idle_manager_t* idle_manager) {
uint32_t dispatch_times = 0;
return_value_if_fail(idle_manager != NULL, RET_BAD_PARAMS);
idle_manager->dispatch_times++;
if (idle_manager->idles.first == NULL) {
return RET_OK;
}
dispatch_times = idle_manager->dispatch_times;
while (idle_manager_dispatch_one(idle_manager, dispatch_times) == RET_OK) {
if (idle_manager->dispatch_times != dispatch_times) {
log_debug("abort dispatch because sub main loop\n");
}
}
return RET_OK;
}
uint32_t idle_manager_count(idle_manager_t* idle_manager) {
return_value_if_fail(idle_manager != NULL, 0);
return slist_size(&(idle_manager->idles));
}
bool_t idle_manager_exist(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx) {
slist_node_t* iter = idle_manager->idles.first;
while (iter != NULL) {
idle_info_t* idle = (idle_info_t*)(iter->data);
if (idle->on_idle == on_idle && idle->ctx == ctx) {
return TRUE;
}
iter = iter->next;
}
return FALSE;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/state_machine.c
|
/**
* File: state_machine.c
* Author: AWTK Develop Team
* Brief: state_machine
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
*/
/**
* History:
* ================================================================
* 2020-12-29 code generated
* 2020-12-29 Wang LinFu <[email protected]> created
*
*/
#include "state_machine.h"
#include "tkc/mem.h"
static tk_sm_transition_t* tk_state_machine_get_transition(tk_state_machine_t* fsm,
tk_sm_event_t* const event,
bool_t* is_back) {
const tk_sm_state_t* state = fsm->current_state;
size_t i;
*is_back = FALSE;
for (i = 0; i < state->ntransitions; ++i) {
tk_sm_transition_t* t = &state->transitions[i];
/* A transition for the given event has been found: */
if (t->etype == event->type) {
if (!t->guard) return t;
/* If transition is guarded, ensure that the condition is held: */
else if (t->guard(t->condition, event))
return t;
}
}
for (i = 0; i < state->ntransitions_back; ++i) {
tk_sm_transition_t* t = &state->transitions_back[i];
/* A transition for the given event has been found: */
if (t->etype == event->type) {
if (!t->guard) {
*is_back = TRUE;
return t;
}
/* If transition is guarded, ensure that the condition is held: */
else if (t->guard(t->condition, event)) {
*is_back = TRUE;
return t;
}
}
}
if (state->base_state) {
state = state->base_state;
return_value_if_fail(state->transitions && state->ntransitions, NULL);
for (i = 0; i < state->ntransitions; ++i) {
tk_sm_transition_t* t = &state->transitions[i];
if (!t->next_state) {
t->next_state = state;
}
/* A transition for the given event has been found: */
if (t->etype == event->type) {
if (!t->guard) return t;
/* If transition is guarded, ensure that the condition is held: */
else if (t->guard(t->condition, event))
return t;
}
}
}
/* No transitions found for given event for given state: */
return NULL;
}
ret_t tk_state_machine_init(tk_state_machine_t* fsm, const tk_sm_state_t* initial_state) {
return_value_if_fail(fsm, RET_BAD_PARAMS);
return_value_if_fail(initial_state, RET_BAD_PARAMS);
/* 初始状态不允许有 transitions_back ，防止无限递归 */
return_value_if_fail(initial_state->ntransitions_back == 0, RET_BAD_PARAMS);
return_value_if_fail(initial_state->transitions_back == NULL, RET_BAD_PARAMS);
fsm->current_state = initial_state;
fsm->previous_state = NULL;
return RET_OK;
}
ret_t tk_state_machine_handle(tk_state_machine_t* fsm, tk_sm_event_t* event) {
return_value_if_fail(fsm && event, RET_BAD_PARAMS);
return_value_if_fail(fsm->current_state, RET_NOT_IMPL);
const tk_sm_state_t* next_state;
bool_t is_back;
tk_sm_transition_t* transition = tk_state_machine_get_transition(fsm, event, &is_back);
return_value_if_fail(transition, RET_NOT_FOUND);
if (transition->next_state) {
next_state = transition->next_state;
} else {
next_state = fsm->current_state;
}
if (next_state != fsm->current_state && fsm->current_state->exit_action) {
fsm->current_state->exit_action(fsm->current_state->data, event);
}
/* action 在 exit 之后，如果要在 exit 之前执行的操作，可以放在 guard 中 */
if (transition->action) {
transition->action(fsm->current_state->data, event, next_state->data);
}
if (!is_back) {
if (next_state != fsm->current_state && next_state->entry_action) {
next_state->entry_action(next_state->data, event);
}
fsm->previous_state = fsm->current_state;
fsm->current_state = next_state;
return RET_OK;
} else {
return_value_if_fail(next_state != fsm->current_state, RET_FAIL);
fsm->previous_state = fsm->current_state;
fsm->current_state = next_state;
return tk_state_machine_handle(fsm, event);
}
}
const tk_sm_state_t* tk_state_machine_current_get(tk_state_machine_t* fsm) {
return_value_if_fail(fsm, NULL);
return fsm->current_state;
}
const tk_sm_state_t* tk_state_machine_previous_get(tk_state_machine_t* fsm) {
return_value_if_fail(fsm, NULL);
return fsm->previous_state;
}
ret_t tk_state_machine_deinit(tk_state_machine_t* fsm, tk_sm_event_t* event) {
return_value_if_fail(fsm, RET_BAD_PARAMS);
if (fsm->current_state->exit_action) {
fsm->current_state->exit_action(fsm->current_state->data, event);
}
memset(fsm, 0, sizeof(*fsm));
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_factory.c
|
/**
* File: data_reader_factory.c
* Author: AWTK Develop Team
* Brief: data reader factory
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/data_reader_factory.h"
static data_reader_factory_t* data_reader_factory_init(data_reader_factory_t* factory);
static ret_t data_reader_factory_deinit(data_reader_factory_t* factory);
static data_reader_factory_t* s_data_reader_factory = NULL;
typedef struct _creator_item_t {
char protocol[TK_NAME_LEN + 1];
data_reader_create_t create;
} creator_item_t;
static int32_t creator_item_cmp(const creator_item_t* iter, const char* protocol) {
return strcmp(iter->protocol, protocol);
}
data_reader_factory_t* data_reader_factory(void) {
return s_data_reader_factory;
}
data_reader_factory_t* data_reader_factory_create(void) {
data_reader_factory_t* factory = TKMEM_ZALLOC(data_reader_factory_t);
return_value_if_fail(factory != NULL, NULL);
return data_reader_factory_init(factory);
}
static data_reader_factory_t* data_reader_factory_init(data_reader_factory_t* factory) {
return_value_if_fail(factory != NULL, NULL);
darray_init(&(factory->creators), 0, default_destroy, (tk_compare_t)creator_item_cmp);
return factory;
}
ret_t data_reader_factory_register(data_reader_factory_t* factory, const char* protocol,
data_reader_create_t create) {
creator_item_t* item = NULL;
return_value_if_fail(factory != NULL && protocol != NULL && create != NULL, RET_BAD_PARAMS);
item = darray_find(&(factory->creators), (void*)protocol);
if (item != NULL) {
if (item->create != create) {
item->create = create;
}
} else {
item = TKMEM_ZALLOC(creator_item_t);
return_value_if_fail(item != NULL, RET_OOM);
item->create = create;
tk_strncpy(item->protocol, protocol, TK_NAME_LEN);
darray_push(&(factory->creators), item);
}
return RET_OK;
}
data_reader_t* data_reader_factory_create_reader(data_reader_factory_t* factory, const char* url) {
char protocol[TK_NAME_LEN + 1];
const char* p = NULL;
const creator_item_t* iter = NULL;
return_value_if_fail(factory != NULL && url != NULL, NULL);
p = strchr(url, ':');
memset(protocol, 0x00, sizeof(protocol));
if (p != NULL) {
return_value_if_fail((p - url) < TK_NAME_LEN, NULL);
tk_strncpy(protocol, url, p - url);
if (tk_strlen(protocol) <= 1) {
/*是Windows下的盘符(如 D:/a/b/c.txt)*/
tk_strncpy(protocol, "file", 4);
}
} else {
tk_strncpy(protocol, "file", 4);
}
iter = darray_find(&(factory->creators), (void*)protocol);
if (iter != NULL) {
return iter->create(url);
}
return NULL;
}
ret_t data_reader_factory_set(data_reader_factory_t* factory) {
s_data_reader_factory = factory;
return RET_OK;
}
static ret_t data_reader_factory_deinit(data_reader_factory_t* factory) {
return_value_if_fail(factory != NULL, RET_BAD_PARAMS);
darray_deinit(&(factory->creators));
return RET_OK;
}
ret_t data_reader_factory_destroy(data_reader_factory_t* factory) {
return_value_if_fail(factory != NULL, RET_BAD_PARAMS);
data_reader_factory_deinit(factory);
TKMEM_FREE(factory);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mutex_nest.h
|
/**
* File: mutex_nest.h
* Author: AWTK Develop Team
* Brief: mutex recursive
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-24 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MUTEX_NEST_H
#define TK_MUTEX_NEST_H
#include "tkc/mutex.h"
BEGIN_C_DECLS
/**
* @class tk_mutex_nest_t
* 嵌套互斥锁。允许同一个线程多次加锁。
*/
typedef struct _tk_mutex_nest_t {
/*private*/
tk_mutex_t* mutex;
volatile uint64_t owner;
volatile int32_t ref;
} tk_mutex_nest_t;
/**
* @method tk_mutex_nest_create
* 创建嵌套互斥锁。
*
* @return {tk_mutex_nest_t*} mutex_nest对象。
*/
tk_mutex_nest_t* tk_mutex_nest_create(void);
/**
* @method tk_mutex_nest_lock
* 加锁。
* @param {tk_mutex_nest_t*} mutex_nest mutex_nest对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_nest_lock(tk_mutex_nest_t* mutex_nest);
/**
* @method tk_mutex_nest_try_lock
* 尝试加锁。
* @param {tk_mutex_nest_t*} mutex_nest mutex_nest对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_nest_try_lock(tk_mutex_nest_t* mutex_nest);
/**
* @method tk_mutex_nest_unlock
* 解锁。只允许解锁当前线程所加的锁。
* @param {tk_mutex_nest_t*} mutex_nest mutex_nest对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_nest_unlock(tk_mutex_nest_t* mutex_nest);
/**
* @method tk_mutex_nest_destroy
* 销毁mutex_nest对象。
* @param {tk_mutex_nest_t*} mutex_nest mutex_nest对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_nest_destroy(tk_mutex_nest_t* mutex_nest);
END_C_DECLS
#endif /*TK_MUTEX_NEST_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/cmd_args.c
|
/**
* File: cmd_args.c
* Author: AWTK Develop Team
* Brief: command line args parser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2023-04-14 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/tokenizer.h"
#include "tkc/cmd_args.h"
BEGIN_C_DECLS
cmd_args_t* cmd_args_init(cmd_args_t* args, const char* usage, const cmd_arg_desc_t* desc,
uint32_t desc_nr, cmd_arg_on_arg_t on_arg, void* on_arg_ctx) {
return_value_if_fail(desc_nr > 0, NULL);
return_value_if_fail(args != NULL && desc != NULL && on_arg != NULL, NULL);
args->desc = desc;
args->usage = usage;
args->desc_nr = desc_nr;
args->on_arg = on_arg;
args->on_arg_ctx = on_arg_ctx;
return args;
}
static const cmd_arg_desc_t* cmd_args_find(cmd_args_t* args, const char* name) {
uint32_t i = 0;
uint32_t len = 0;
const char* p = NULL;
return_value_if_fail(name != NULL, NULL);
while (*name == '-') {
name++;
}
p = strchr(name, '=');
if (p != NULL) {
len = p - name;
} else {
len = strlen(name);
}
for (i = 0; i < args->desc_nr; i++) {
const cmd_arg_desc_t* iter = args->desc + i;
if (p != NULL) {
if (tk_str_eq_with_len(name, iter->name, len) ||
tk_str_eq_with_len(name, iter->short_name, len)) {
return iter;
}
} else {
if (tk_str_eq(name, iter->name) ||
tk_str_eq(name, iter->short_name)) {
return iter;
}
}
}
return NULL;
}
ret_t cmd_args_show_help(cmd_args_t* args) {
uint32_t i = 0;
log_info("Usage: %s\n", args->usage);
log_info(" --help/-h show help info.\n");
for (i = 0; i < args->desc_nr; i++) {
const cmd_arg_desc_t* iter = args->desc + i;
log_info(" --%s/-%s %s\n", iter->name, iter->short_name, iter->desc);
(void)iter;
}
return RET_OK;
}
static ret_t cmd_args_on_arg(cmd_args_t* args, value_type_t type, const char* name,
const char* value) {
if (value == NULL || type == VALUE_TYPE_INVALID) {
args->on_arg(args->on_arg_ctx, name, NULL);
} else {
value_t v;
switch (type) {
case VALUE_TYPE_BOOL: {
value_set_bool(&v, tk_atob(value));
break;
}
case VALUE_TYPE_INT8:
case VALUE_TYPE_INT16:
case VALUE_TYPE_INT32:
case VALUE_TYPE_UINT8:
case VALUE_TYPE_UINT16:
case VALUE_TYPE_UINT32: {
value_set_int(&v, tk_atoi(value));
break;
}
case VALUE_TYPE_FLOAT32:
case VALUE_TYPE_DOUBLE:
case VALUE_TYPE_FLOAT: {
value_set_double(&v, tk_atof(value));
break;
}
default: {
value_set_str(&v, value);
break;
}
}
args->on_arg(args->on_arg_ctx, name, &v);
}
return RET_OK;
}
ret_t cmd_args_process(cmd_args_t* args, int argc, char* argv[]) {
uint32_t i = 0;
const cmd_arg_desc_t* desc = NULL;
return_value_if_fail(args != NULL && argv != NULL, RET_BAD_PARAMS);
for (i = 1; i < argc; i++) {
const char* iter = argv[i];
if (*iter == '-') {
if (tk_str_eq(iter, "-h") || tk_str_eq(iter, "--help")) {
cmd_args_show_help(args);
return RET_STOP;
}
desc = cmd_args_find(args, iter);
if (desc != NULL && desc->value_type != VALUE_TYPE_INVALID) {
const char* value = strchr(iter, '=');
if (value != NULL) {
value++;
} else if ((i + 1) < argc) {
value = argv[++i];
}
cmd_args_on_arg(args, desc->value_type, desc->name, value);
} else {
if (desc != NULL) {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, desc->name, NULL);
} else {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, iter, NULL);
}
}
} else {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, iter, NULL);
}
}
return RET_OK;
}
ret_t cmd_args_process_str(cmd_args_t* args, const char* cmd_line) {
tokenizer_t t;
const cmd_arg_desc_t* desc = NULL;
return_value_if_fail(args != NULL && cmd_line != NULL, RET_BAD_PARAMS);
tokenizer_init(&t, cmd_line, strlen(cmd_line), " \t");
while (tokenizer_has_more(&t)) {
const char* iter = tokenizer_next_str(&t);
if (*iter == '-') {
if (tk_str_eq(iter, "-h") || tk_str_eq(iter, "--help")) {
cmd_args_show_help(args);
return RET_STOP;
}
desc = cmd_args_find(args, iter);
if (desc != NULL && desc->value_type != VALUE_TYPE_INVALID) {
const char* value = strchr(iter, '=');
if (value != NULL) {
value++;
} else {
value = tokenizer_next_str(&t);
}
cmd_args_on_arg(args, desc->value_type, desc->name, value);
} else {
if (desc != NULL) {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, desc->name, NULL);
} else {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, iter, NULL);
}
}
} else {
cmd_args_on_arg(args, VALUE_TYPE_INVALID, iter, NULL);
}
}
tokenizer_deinit(&t);
return RET_OK;
}
ret_t cmd_args_process_wstr(cmd_args_t* args, int argc, wchar_t* _argv[]) {
ret_t ret = RET_OK;
char** argv = NULL;
return_value_if_fail(args != NULL && _argv != NULL, RET_BAD_PARAMS);
argv = tk_to_utf8_argv(argc, _argv);
return_value_if_fail(argv != NULL, RET_OOM);
ret = cmd_args_process(args, argc, argv);
tk_free_utf8_argv(argc, argv);
return ret;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/darray.c
|
/**
* File: darray.c
* Author: AWTK Develop Team
* Brief: dynamic darray.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#include "tkc/darray.h"
#include "tkc/utils.h"
#include "tkc/mem.h"
darray_t* darray_create(uint32_t capacity, tk_destroy_t destroy, tk_compare_t compare) {
darray_t* darray = TKMEM_ZALLOC(darray_t);
return_value_if_fail(darray != NULL, NULL);
if (darray_init(darray, capacity, destroy, compare)) {
return darray;
} else {
TKMEM_FREE(darray);
return NULL;
}
}
darray_t* darray_init(darray_t* darray, uint32_t capacity, tk_destroy_t destroy,
tk_compare_t compare) {
return_value_if_fail(darray != NULL, NULL);
darray->size = 0;
darray->capacity = 0;
darray->elms = NULL;
darray->destroy = destroy != NULL ? destroy : dummy_destroy;
darray->compare = compare != NULL ? compare : pointer_compare;
if (capacity > 0) {
darray->elms = TKMEM_ZALLOCN(void*, capacity);
return_value_if_fail(darray->elms != NULL, NULL);
darray->capacity = capacity;
}
return darray;
}
static bool_t darray_extend(darray_t* darray) {
if (darray->elms != NULL && darray->size < darray->capacity) {
return TRUE;
} else {
void* elms = NULL;
uint32_t capacity = (darray->capacity >> 1) + darray->capacity + 1;
elms = TKMEM_REALLOCT(void*, darray->elms, capacity);
if (elms) {
darray->elms = elms;
darray->capacity = capacity;
return TRUE;
} else {
return FALSE;
}
}
}
int32_t darray_find_index_ex(darray_t* darray, tk_compare_t compare, void* data) {
int32_t i = 0;
int32_t size = 0;
void** elms = NULL;
return_value_if_fail(darray != NULL, -1);
elms = darray->elms;
size = darray->size;
if (compare == NULL) {
compare = darray->compare ? darray->compare : pointer_compare;
}
for (i = 0; i < size; i++) {
void* iter = elms[i];
if (compare(iter, data) == 0) {
return i;
}
}
return -1;
}
int32_t darray_find_index(darray_t* darray, void* data) {
return darray_find_index_ex(darray, NULL, data);
}
ret_t darray_remove_index(darray_t* darray, uint32_t index) {
int32_t i = 0;
int32_t size = 0;
void** elms = NULL;
return_value_if_fail(darray != NULL && index < darray->size, RET_BAD_PARAMS);
elms = darray->elms;
darray->destroy(elms[index]);
elms[index] = NULL;
for (size = darray->size - 1, i = index; i < size; i++) {
elms[i] = elms[i + 1];
}
elms[i] = NULL;
darray->size--;
return RET_OK;
}
ret_t darray_remove_range(darray_t* darray, uint32_t start, uint32_t end) {
return_value_if_fail(darray != NULL && start < end && end <= darray->size, RET_BAD_PARAMS);
if (darray->elms != NULL) {
uint32_t i = 0, j = 0;
void** elms = darray->elms;
for (i = start, j = end; i < darray->size; i++, j++) {
if (i < end) {
void* iter = elms[i];
darray->destroy(iter);
}
if (j < darray->size) {
elms[i] = elms[j];
} else {
elms[i] = NULL;
}
}
darray->size -= (end - start);
}
return RET_OK;
}
ret_t darray_remove_ex(darray_t* darray, tk_compare_t cmp, void* ctx) {
int32_t index = 0;
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
index = darray_find_index_ex(darray, cmp, ctx);
if (index < 0) {
return RET_NOT_FOUND;
} else {
return darray_remove_index(darray, index);
}
}
ret_t darray_remove(darray_t* darray, void* data) {
return darray_remove_ex(darray, NULL, data);
}
ret_t darray_remove_all(darray_t* darray, tk_compare_t cmp, void* ctx) {
int32_t i = 0;
int32_t k = 0;
int32_t size = 0;
void** elms = NULL;
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
elms = darray->elms;
size = darray->size;
cmp = cmp != NULL ? cmp : darray->compare;
for (i = 0, k = 0; i < size; i++) {
void* iter = elms[i];
if (cmp(iter, ctx) == 0) {
if (iter != NULL) {
darray->destroy(iter);
}
elms[i] = NULL;
} else {
if (k != i) {
elms[k] = elms[i];
}
k++;
}
}
darray->size = k;
return RET_OK;
}
ret_t darray_sort(darray_t* darray, tk_compare_t cmp) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
cmp = cmp != NULL ? cmp : darray->compare;
return tk_qsort(darray->elms, darray->size, cmp);
}
ret_t darray_find_all(darray_t* darray, tk_compare_t cmp, void* ctx, darray_t* matched) {
int32_t i = 0;
int32_t size = 0;
void** elms = NULL;
return_value_if_fail(darray != NULL && matched != NULL, RET_BAD_PARAMS);
elms = darray->elms;
size = darray->size;
cmp = cmp != NULL ? cmp : darray->compare;
for (i = 0; i < size; i++) {
void* iter = elms[i];
if (cmp(iter, ctx) == 0) {
return_value_if_fail(darray_push(matched, iter) == RET_OK, RET_OOM);
}
}
return RET_OK;
}
void* darray_find_ex(darray_t* darray, tk_compare_t cmp, void* ctx) {
int32_t pos = darray_find_index_ex(darray, cmp, ctx);
return pos >= 0 ? darray->elms[pos] : NULL;
}
void* darray_find(darray_t* darray, void* data) {
return darray_find_ex(darray, NULL, data);
}
void* darray_pop(darray_t* darray) {
return_value_if_fail(darray != NULL, NULL);
if (darray->size > 0) {
return darray->elms[--darray->size];
} else {
return NULL;
}
}
void* darray_tail(darray_t* darray) {
return_value_if_fail(darray != NULL && darray->size > 0, NULL);
return darray->elms[darray->size - 1];
}
void* darray_head(darray_t* darray) {
return_value_if_fail(darray != NULL && darray->size > 0, NULL);
return darray->elms[0];
}
ret_t darray_insert(darray_t* darray, uint32_t index, void* data) {
void** s = NULL;
void** d = NULL;
void** p = NULL;
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
index = tk_min(index, darray->size);
return_value_if_fail(darray_extend(darray), RET_OOM);
p = darray->elms + index;
d = darray->elms + darray->size;
s = d - 1;
while (s >= p) {
*d-- = *s--;
}
*p = data;
darray->size++;
return RET_OK;
}
ret_t darray_sorted_insert(darray_t* darray, void* data, tk_compare_t cmp,
bool_t replace_if_exist) {
int32_t low = -1;
int32_t index = 0;
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
if (darray->size == 0) {
return darray_push(darray, data);
}
index = darray_bsearch_index_ex(darray, cmp, data, &low);
if (index >= 0) {
if (replace_if_exist) {
return darray_replace(darray, index, data);
}
} else {
index = low;
}
if (index >= darray->size) {
return darray_push(darray, data);
} else {
return darray_insert(darray, index, data);
}
}
ret_t darray_push(darray_t* darray, void* data) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
return darray_insert(darray, darray->size, data);
}
ret_t darray_push_unique(darray_t* darray, void* data) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
if (darray_find_index(darray, data) >= 0) {
return RET_FAIL;
}
return darray_insert(darray, darray->size, data);
}
int32_t darray_count(darray_t* darray, void* data) {
int32_t n = 0;
return_value_if_fail(darray != NULL, 0);
if (darray->elms != NULL) {
uint32_t i = 0;
void** elms = darray->elms;
for (i = 0; i < darray->size; i++) {
void* iter = elms[i];
if (darray->compare(iter, data) == 0) {
n++;
}
}
}
return n;
}
ret_t darray_foreach(darray_t* darray, tk_visit_t visit, void* ctx) {
return_value_if_fail(darray != NULL && visit != NULL, RET_BAD_PARAMS);
if (darray->elms != NULL) {
uint32_t i = 0;
void** elms = darray->elms;
for (i = 0; i < darray->size; i++) {
void* iter = elms[i];
ret_t ret = visit(ctx, iter);
if (ret != RET_OK) {
return ret;
}
}
}
return RET_OK;
}
ret_t darray_clear(darray_t* darray) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
if (darray->elms != NULL) {
uint32_t i = 0;
void** elms = darray->elms;
for (i = 0; i < darray->size; i++) {
void* iter = elms[i];
darray->destroy(iter);
}
darray->size = 0;
}
return RET_OK;
}
ret_t darray_set(darray_t* darray, uint32_t index, void* data) {
return_value_if_fail(darray != NULL && index < darray->size, RET_BAD_PARAMS);
darray->elms[index] = data;
return RET_OK;
}
ret_t darray_replace(darray_t* darray, uint32_t index, void* data) {
return_value_if_fail(darray != NULL && index < darray->size, RET_BAD_PARAMS);
if (darray->destroy != NULL) {
darray->destroy(darray->elms[index]);
}
darray->elms[index] = data;
return RET_OK;
}
void* darray_get(darray_t* darray, uint32_t index) {
return_value_if_fail(darray != NULL && index < darray->size, NULL);
return darray->elms[index];
}
ret_t darray_deinit(darray_t* darray) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
if (darray->elms != NULL) {
darray_clear(darray);
TKMEM_FREE(darray->elms);
memset(darray, 0x00, sizeof(darray_t));
}
return RET_OK;
}
ret_t darray_destroy(darray_t* darray) {
return_value_if_fail(darray != NULL, RET_BAD_PARAMS);
darray_deinit(darray);
TKMEM_FREE(darray);
return RET_OK;
}
int32_t darray_bsearch_index_ex(darray_t* darray, tk_compare_t cmp, void* ctx, int32_t* ret_low) {
int32_t low = 0;
int32_t mid = 0;
int32_t high = 0;
int32_t result = 0;
void* iter = NULL;
return_value_if_fail(darray != NULL, -1);
if (darray->size == 0) {
return -1;
}
if (cmp == NULL) {
cmp = darray->compare;
}
high = darray->size - 1;
while (low <= high) {
mid = low + ((high - low) >> 1);
iter = darray->elms[mid];
result = cmp(iter, ctx);
if (result == 0) {
return mid;
} else if (result < 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
if (ret_low != NULL) {
*ret_low = low;
}
return -1;
}
int32_t darray_bsearch_index(darray_t* darray, tk_compare_t cmp, void* ctx) {
return darray_bsearch_index_ex(darray, cmp, ctx, NULL);
}
void* darray_bsearch(darray_t* darray, tk_compare_t cmp, void* ctx) {
int32_t index = darray_bsearch_index(darray, cmp, ctx);
if (index >= 0) {
return darray->elms[index];
} else {
return NULL;
}
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/sha256.h
|
#ifndef TK_SHA256_H
#define TK_SHA256_H
#include "tkc/str.h"
BEGIN_C_DECLS
/**
* @class tk_sha256_t
* sha256
*/
typedef struct {
uint32_t buf[16];
uint32_t hash[8];
uint32_t len[2];
} tk_sha256_t;
#define TK_SHA256_HASH_LEN 32
/**
* @method tk_sha256_init
* 初始化。
* @param {tk_sha256_t*} sha256 sha256对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_sha256_init(tk_sha256_t* sha256);
/**
* @method tk_sha256_hash
* 更新数据。
* @param {tk_sha256_t*} sha256 sha256对象。
* @param {const uint8_t*} data 数据。
* @param {uint32_t} len 数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_sha256_hash(tk_sha256_t* sha256, const uint8_t* data, uint32_t len);
/**
* @method tk_sha256_done
* 完成计算。
* @param {tk_sha256_t*} sha256 sha256对象。
* @param {uint8_t*} hash 用于返回计算结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_sha256_done(tk_sha256_t* sha256, uint8_t hash[TK_SHA256_HASH_LEN + 1]);
/**
* @method tk_sha256
* 计算数据的sha256哈希值。
* @param {const void*} data 数据。
* @param {uint32_t} len 数据长度。
* @param {str_t*} hash 用于返回计算结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_sha256(const void* data, uint32_t len, str_t* hash);
/**
* @method tk_sha256_file
* 计算文件的sha256哈希值。
* @param {const char*} filename 文件名。
* @param {uint32_t} block_size 数据块长度。
* @param {str_t*} hash 用于返回计算结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_sha256_file(const char* filename, uint32_t block_size, str_t* hash);
END_C_DECLS
#endif /*TK_SHA256_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/utf8.c
|
/**
* File: utf8.c
* Author: AWTK Develop Team
* Brief: utf8 encode decode
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-14 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
/*UTF8-related functions are copied from glib.*/
#define UTF8_COMPUTE(Char, Mask, Len) \
if (Char < 128) { \
Len = 1; \
Mask = 0x7f; \
} else if ((Char & 0xe0) == 0xc0) { \
Len = 2; \
Mask = 0x1f; \
} else if ((Char & 0xf0) == 0xe0) { \
Len = 3; \
Mask = 0x0f; \
} else if ((Char & 0xf8) == 0xf0) { \
Len = 4; \
Mask = 0x07; \
} else if ((Char & 0xfc) == 0xf8) { \
Len = 5; \
Mask = 0x03; \
} else if ((Char & 0xfe) == 0xfc) { \
Len = 6; \
Mask = 0x01; \
} else \
Len = -1;
#define UTF8_LENGTH(Char) \
((Char) < 0x80 \
? 1 \
: ((Char) < 0x800 \
? 2 \
: ((Char) < 0x10000 ? 3 : ((Char) < 0x200000 ? 4 : ((Char) < 0x4000000 ? 5 : 6)))))
#define UTF8_GET(Result, Chars, Count, Mask, Len) \
(Result) = (Chars)[0] & (Mask); \
for ((Count) = 1; (Count) < (Len); ++(Count)) { \
if (((Chars)[(Count)] & 0xc0) != 0x80) { \
(Result) = -1; \
break; \
} \
(Result) <<= 6; \
(Result) |= ((Chars)[(Count)] & 0x3f); \
}
#define UNICODE_VALID(Char) \
((Char) < 0x110000 && (((Char)&0xFFFFF800) != 0xD800) && ((Char) < 0xFDD0 || (Char) > 0xFDEF) && \
((Char)&0xFFFE) != 0xFFFE)
static const char utf8_skip_data[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1};
uint32_t tk_utf8_get_bytes_of_leading(uint8_t c) {
return utf8_skip_data[c];
}
const char* const g_utf8_skip = utf8_skip_data;
#define g_utf8_next_char(p) (char*)((p) + g_utf8_skip[*(const unsigned char*)(p)])
static int32_t utf8_get_char(const char* p, const char** next) {
uint32_t mask = 0;
int32_t result = 0;
int32_t i = 0, len = 0;
unsigned char c = (unsigned char)*p;
UTF8_COMPUTE(c, mask, len);
if (len == -1) return -1;
UTF8_GET(result, p, i, mask, len);
if (next != NULL) {
*next = g_utf8_next_char(p);
}
return result;
}
static int unichar_to_utf8(uint32_t c, char* outbuf) {
/* If this gets modified, also update the copy in g_string_insert_unichar() */
size_t len = 0;
int first;
int i;
if (c < 0x80) {
first = 0;
len = 1;
} else if (c < 0x800) {
first = 0xc0;
len = 2;
} else if (c < 0x10000) {
first = 0xe0;
len = 3;
} else if (c < 0x200000) {
first = 0xf0;
len = 4;
} else if (c < 0x4000000) {
first = 0xf8;
len = 5;
} else {
first = 0xfc;
len = 6;
}
if (outbuf) {
for (i = len - 1; i > 0; --i) {
outbuf[i] = (c & 0x3f) | 0x80;
c >>= 6;
}
outbuf[0] = c | first;
}
return len;
}
#define SURROGATE_VALUE(h, l) (((h)-0xd800) * 0x400 + (l)-0xdc00 + 0x10000)
static char* utf16_to_utf8(const wchar_t* str, int32_t len, char* utf8, int out_len) {
/* This function and g_utf16_to_ucs4 are almost exactly identical - The lines
* that differ are marked.
*/
const wchar_t* in;
char* out;
char* result = NULL;
int n_bytes;
wchar_t high_surrogate;
return_value_if_fail(str != NULL, NULL);
n_bytes = 0;
in = str;
high_surrogate = 0;
while ((len < 0 || in - str < len) && *in) {
wchar_t c = *in;
uint32_t wc;
if (c >= 0xdc00 && c < 0xe000) /* low surrogate */
{
if (high_surrogate) {
wc = SURROGATE_VALUE(high_surrogate, c);
high_surrogate = 0;
} else {
log_error("Invalid sequence in conversion input");
goto err_out;
}
} else {
if (high_surrogate) {
log_error("Invalid sequence in conversion input");
goto err_out;
}
if (c >= 0xd800 && c < 0xdc00) /* high surrogate */
{
high_surrogate = c;
goto next1;
} else
wc = c;
}
/********** DIFFERENT for UTF8/UCS4 **********/
n_bytes += UTF8_LENGTH(wc);
next1:
in++;
}
if (high_surrogate) {
log_error("Partial character sequence at end of input");
goto err_out;
}
/* At this point, everything is valid, and we just need to convert
*/
/********** DIFFERENT for UTF8/UCS4 **********/
// result = g_malloc (n_bytes + 1);
result = utf8;
if (out_len <= n_bytes) {
log_error("utf16_to_utf8: out_len is not big enough\n");
goto err_out;
}
high_surrogate = 0;
out = result;
in = str;
while (out < result + n_bytes) {
wchar_t c = *in;
uint32_t wc;
if (c >= 0xdc00 && c < 0xe000) /* low surrogate */
{
wc = SURROGATE_VALUE(high_surrogate, c);
high_surrogate = 0;
} else if (c >= 0xd800 && c < 0xdc00) /* high surrogate */
{
high_surrogate = c;
goto next2;
} else
wc = c;
/********** DIFFERENT for UTF8/UCS4 **********/
out += unichar_to_utf8(wc, out);
next2:
in++;
}
/********** DIFFERENT for UTF8/UCS4 **********/
*out = '\0';
return result;
err_out:
return NULL;
}
char* tk_utf8_from_utf16_ex(const wchar_t* in, uint32_t in_size, char* out, uint32_t out_size) {
return_value_if_fail(in != NULL && out != NULL && out_size > 0, NULL);
if (in_size == 0) {
*out = '\0';
return out;
}
return utf16_to_utf8(in, in_size, out, out_size);
}
char* tk_utf8_from_utf16(const wchar_t* str, char* out, uint32_t out_size) {
return_value_if_fail(str != NULL && out != NULL && out_size > 0, NULL);
return utf16_to_utf8(str, wcslen(str), out, out_size);
}
wchar_t* tk_utf8_to_utf16(const char* str, wchar_t* out, uint32_t out_size) {
return_value_if_fail(str != NULL && out != NULL && out_size > 0, NULL);
return tk_utf8_to_utf16_ex(str, strlen(str), out, out_size);
}
wchar_t* tk_utf8_to_utf16_ex(const char* str, uint32_t size, wchar_t* out, uint32_t out_size) {
uint32_t i = 0;
int32_t val = 0;
const char* p = str;
const char* end = NULL;
const char* next = NULL;
return_value_if_fail(str != NULL && out != NULL, NULL);
end = str + size;
while (p != NULL && p < end && (i + 1) < out_size) {
val = utf8_get_char(p, &next);
return_value_if_fail(val != -1, NULL);
if (sizeof(wchar_t) == 4) {
out[i++] = val;
} else if (sizeof(wchar_t) == 2) {
if (val < 0x10000) {
out[i++] = val;
} else {
val -= 0x10000;
out[i++] = 0xd800 + (val / 0x400);
return_value_if_fail((i + 1) < out_size, NULL);
out[i++] = 0xdc00 + (val & 0x3FF);
}
} else {
return NULL;
}
p = next;
}
out[i] = '\0';
return out;
}
char* tk_utf8_dup_utf16(const wchar_t* in, int32_t size) {
char* out = NULL;
uint32_t out_size = 0;
return_value_if_fail(in != NULL, NULL);
if (size < 0) {
size = wcslen(in);
}
out_size = size * 4 + 2;
out = TKMEM_ALLOC(out_size);
return_value_if_fail(out != NULL, NULL);
memset(out, 0x00, out_size);
return tk_utf8_from_utf16_ex(in, size, out, out_size - 1);
}
char* tk_utf8_trim_invalid_char(char* str) {
int32_t i = 0;
int32_t n = 0;
char* p = str;
return_value_if_fail(str != NULL, str);
while (*p) {
n = tk_utf8_get_bytes_of_leading(*p);
if (n > 0) {
for (i = 0; i < n; i++) {
if (p[i] == '\0') {
*p = '\0';
return str;
}
}
}
p += n;
}
return str;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_compat.h
|
#ifndef USE_TK_PREFIX
#define object_can_exec tk_object_can_exec
#define object_can_exec_by_path tk_object_can_exec_by_path
#define object_can_exec_t tk_object_can_exec_t
#define object_clone tk_object_clone
#define object_clone_t tk_object_clone_t
#define object_compare tk_object_compare
#define object_compare_t tk_object_compare_t
#define object_copy_prop tk_object_copy_prop
#define object_copy_props tk_object_copy_props
#define object_create tk_object_create
#define object_create_ex tk_object_create_ex
#define object_eval tk_object_eval
#define object_exec tk_object_exec
#define object_exec_by_path tk_object_exec_by_path
#define object_exec_t tk_object_exec_t
#define object_foreach_prop tk_object_foreach_prop
#define object_foreach_prop_t tk_object_foreach_prop_t
#define object_get_child_object tk_object_get_child_object
#define object_get_desc tk_object_get_desc
#define object_get_prop tk_object_get_prop
#define object_get_prop_bool tk_object_get_prop_bool
#define object_get_prop_bool_by_path tk_object_get_prop_bool_by_path
#define object_get_prop_by_path tk_object_get_prop_by_path
#define object_get_prop_double tk_object_get_prop_double
#define object_get_prop_float tk_object_get_prop_float
#define object_get_prop_float_by_path tk_object_get_prop_float_by_path
#define object_get_prop_int tk_object_get_prop_int
#define object_get_prop_int16 tk_object_get_prop_int16
#define object_get_prop_int32 tk_object_get_prop_int32
#define object_get_prop_int64 tk_object_get_prop_int64
#define object_get_prop_int8 tk_object_get_prop_int8
#define object_get_prop_int_by_path tk_object_get_prop_int_by_path
#define object_get_prop_object tk_object_get_prop_object
#define object_get_prop_object_by_path tk_object_get_prop_object_by_path
#define object_get_prop_pointer tk_object_get_prop_pointer
#define object_get_prop_pointer_by_path tk_object_get_prop_pointer_by_path
#define object_get_prop_str tk_object_get_prop_str
#define object_get_prop_str_by_path tk_object_get_prop_str_by_path
#define object_get_prop_t tk_object_get_prop_t
#define object_get_prop_uint16 tk_object_get_prop_uint16
#define object_get_prop_uint32 tk_object_get_prop_uint32
#define object_get_prop_uint64 tk_object_get_prop_uint64
#define object_get_prop_uint8 tk_object_get_prop_uint8
#define object_get_size tk_object_get_size
#define object_get_type tk_object_get_type
#define object_has_prop tk_object_has_prop
#define object_has_prop_by_path tk_object_has_prop_by_path
#define object_is_collection tk_object_is_collection
#define object_notify_changed tk_object_notify_changed
#define object_on_destroy_t tk_object_on_destroy_t
#define object_ref tk_object_ref
#define object_remove_prop tk_object_remove_prop
#define object_remove_prop_t tk_object_remove_prop_t
#define object_set_name tk_object_set_name
#define object_set_prop tk_object_set_prop
#define object_set_prop_bool tk_object_set_prop_bool
#define object_set_prop_bool_by_path tk_object_set_prop_bool_by_path
#define object_set_prop_by_path tk_object_set_prop_by_path
#define object_set_prop_double tk_object_set_prop_double
#define object_set_prop_float tk_object_set_prop_float
#define object_set_prop_float_by_path tk_object_set_prop_float_by_path
#define object_set_prop_int tk_object_set_prop_int
#define object_set_prop_int16 tk_object_set_prop_int16
#define object_set_prop_int32 tk_object_set_prop_int32
#define object_set_prop_int64 tk_object_set_prop_int64
#define object_set_prop_int8 tk_object_set_prop_int8
#define object_set_prop_int_by_path tk_object_set_prop_int_by_path
#define object_set_prop_object tk_object_set_prop_object
#define object_set_prop_object_by_path tk_object_set_prop_object_by_path
#define object_set_prop_pointer tk_object_set_prop_pointer
#define object_set_prop_pointer_ex tk_object_set_prop_pointer_ex
#define object_set_prop_pointer_by_path tk_object_set_prop_pointer_by_path
#define object_set_prop_str tk_object_set_prop_str
#define object_set_prop_str_by_path tk_object_set_prop_str_by_path
#define object_set_prop_t tk_object_set_prop_t
#define object_set_prop_uint16 tk_object_set_prop_uint16
#define object_set_prop_uint32 tk_object_set_prop_uint32
#define object_set_prop_uint64 tk_object_set_prop_uint64
#define object_set_prop_uint8 tk_object_set_prop_uint8
#define object_unref tk_object_unref
#define OBJECT TK_OBJECT
#define OBJECT_REF TK_OBJECT_REF
#define OBJECT_UNREF TK_OBJECT_UNREF
#define OBJECT_CMD_SAVE TK_OBJECT_CMD_SAVE
#define OBJECT_CMD_RELOAD TK_OBJECT_CMD_RELOAD
#define OBJECT_CMD_MOVE_UP TK_OBJECT_CMD_MOVE_UP
#define OBJECT_CMD_MOVE_DOWN TK_OBJECT_CMD_MOVE_DOWN
#define OBJECT_CMD_REMOVE TK_OBJECT_CMD_REMOVE
#define OBJECT_CMD_REMOVE_CHECKED TK_OBJECT_CMD_REMOVE_CHECKED
#define OBJECT_CMD_CLEAR TK_OBJECT_CMD_CLEAR
#define OBJECT_CMD_ADD TK_OBJECT_CMD_ADD
#define OBJECT_CMD_DETAIL TK_OBJECT_CMD_DETAIL
#define OBJECT_CMD_EDIT TK_OBJECT_CMD_EDIT
#define OBJECT_PROP_SIZE TK_OBJECT_PROP_SIZE
#define OBJECT_PROP_CHECKED TK_OBJECT_PROP_CHECKED
#define OBJECT_PROP_SELECTED_INDEX TK_OBJECT_PROP_SELECTED_INDEX
#endif /*USE_TK_PREFIX*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_std.h
|
/**
* File: mem_allocator_std.h
* Author: AWTK Develop Team
* Brief: mem_allocator_std
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_STD_H
#define TK_MEM_ALLOCATOR_STD_H
#include "tkc/mem_allocator.h"
#ifdef WITH_SDL
#ifdef MACOS
#include <malloc/malloc.h>
#define msize(ptr) malloc_size(ptr)
#elif defined(WIN32) && !defined(MINGW)
#define msize(ptr) _msize(ptr)
#elif defined(LINUX)
#include <malloc.h>
#define msize(ptr) malloc_usable_size(ptr)
#elif !defined(msize)
#define msize(ptr) 0
#endif
#else
#define msize(ptr) 0
#endif
BEGIN_C_DECLS
/**
* @class mem_allocator_std_t
* @parent mem_allocator_t
* @annotation ["fake"]
* 将标准的C的内存分配函数包装成内存分配器。
*
*/
typedef struct _mem_allocator_std_t {
mem_allocator_t allocator;
uint32_t max_used_nr;
uint32_t max_used_size;
uint32_t used_nr;
uint32_t used_size;
} mem_allocator_std_t;
static ret_t mem_allocator_std_update_status(mem_allocator_std_t* std_allocator) {
if (std_allocator->used_size > std_allocator->max_used_size) {
std_allocator->max_used_size = std_allocator->used_size;
}
if (std_allocator->used_nr > std_allocator->max_used_nr) {
std_allocator->max_used_nr = std_allocator->used_nr;
}
return RET_OK;
}
static inline void* mem_allocator_std_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
void* ptr = NULL;
mem_allocator_std_t* std_allocator = (mem_allocator_std_t*)allocator;
size = TK_ROUND_TO_MACH(size);
ptr = malloc(size);
if (ptr != NULL) {
std_allocator->used_nr++;
std_allocator->used_size += msize(ptr);
mem_allocator_std_update_status(std_allocator);
}
return ptr;
}
static inline void* mem_allocator_std_realloc(mem_allocator_t* allocator, void* ptr, uint32_t size,
const char* func, uint32_t line) {
void* new_ptr = NULL;
size_t old_size = ptr != NULL ? msize(ptr) : 0;
mem_allocator_std_t* std_allocator = (mem_allocator_std_t*)allocator;
size = TK_ROUND_TO_MACH(size);
new_ptr = realloc(ptr, size);
if (new_ptr != NULL) {
size = msize(new_ptr);
if (ptr != NULL) {
std_allocator->used_size += size - old_size;
} else {
std_allocator->used_nr++;
std_allocator->used_size += size;
}
mem_allocator_std_update_status(std_allocator);
}
return new_ptr;
}
static inline void mem_allocator_std_free(mem_allocator_t* allocator, void* ptr) {
mem_allocator_std_t* std_allocator = (mem_allocator_std_t*)allocator;
if (ptr != NULL) {
size_t size = msize(ptr);
free(ptr);
std_allocator->used_nr--;
std_allocator->used_size -= size;
}
}
static inline ret_t mem_allocator_std_dump(mem_allocator_t* allocator) {
mem_allocator_std_t* std_allocator = (mem_allocator_std_t*)allocator;
log_debug("used_nr=%u used_size=%u max_used_nr=%u max_used_size=%u\n", std_allocator->used_nr,
std_allocator->used_size, std_allocator->max_used_nr, std_allocator->max_used_size);
return RET_OK;
}
static inline ret_t mem_allocator_std_destroy(mem_allocator_t* allocator) {
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_std_vtable = {
.alloc = mem_allocator_std_alloc,
.realloc = mem_allocator_std_realloc,
.free = mem_allocator_std_free,
.dump = mem_allocator_std_dump,
.destroy = mem_allocator_std_destroy};
static inline mem_allocator_t* mem_allocator_std_init(mem_allocator_std_t* allocator) {
return_value_if_fail(allocator != NULL, NULL);
memset(allocator, 0x00, sizeof(mem_allocator_std_t));
allocator->allocator.vt = &s_mem_allocator_std_vtable;
return (mem_allocator_t*)allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_STD_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/idle_info.c
|
/**
* File: idle_info.h
* Author: AWTK Develop Team
* Brief: idle info
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/idle_info.h"
#include "tkc/idle_manager.h"
#ifdef AWTK_WEB_JS
#include <emscripten.h>
#endif /*AWTK_WEB_JS*/
static ret_t idle_info_on_destroy(idle_info_t* info) {
if (info->on_destroy != NULL) {
info->on_destroy(info);
}
#ifdef AWTK_WEB_JS
EM_ASM_INT({ return TBrowser.releaseFunction($0); }, info->on_idle);
#endif /*AWTK_WEB_JS*/
return RET_OK;
}
static const object_vtable_t s_idle_info_vtable = {
.type = "idle_info",
.desc = "idle_info",
.size = sizeof(idle_info_t),
.is_collection = FALSE,
.on_destroy = (tk_object_on_destroy_t)idle_info_on_destroy};
idle_info_t* idle_info_create(idle_manager_t* idle_manager, uint32_t id, idle_func_t on_idle,
void* ctx, uint16_t idle_info_type) {
tk_object_t* obj = tk_object_create(&s_idle_info_vtable);
idle_info_t* idle = IDLE_INFO(obj);
return_value_if_fail(idle != NULL, NULL);
idle->ctx = ctx;
idle->on_idle = on_idle;
idle->idle_info_type = idle_info_type;
if (idle_manager != NULL) {
idle->id = id;
if (id != TK_INVALID_ID) {
idle_manager_append(idle_manager, idle);
} else {
tk_object_unref(obj);
return_value_if_fail(id != TK_INVALID_ID, NULL);
}
}
return idle;
}
int idle_info_compare_by_id(const void* a, const void* b) {
return ((const idle_info_t*)a)->id - ((const idle_info_t*)b)->id;
}
int idle_info_compare_by_ctx(const void* a, const void* b) {
const idle_info_t* info_a = (const idle_info_t*)a;
return (char*)(info_a->ctx) - (char*)(b);
}
int idle_info_compare_by_ctx_and_type(const void* a, const void* b) {
const idle_info_t* info_a = (const idle_info_t*)a;
const idle_info_t* info_b = (const idle_info_t*)b;
if (info_a->idle_info_type == info_b->idle_info_type) {
return (char*)(info_a->ctx) - (char*)(info_b->ctx);
}
return -1;
}
idle_info_t* idle_info_init_dummy_with_ctx_and_type(idle_info_t* idle, uint16_t type, void* ctx) {
return_value_if_fail(idle != NULL, NULL);
memset(idle, 0x00, sizeof(idle_info_t));
idle->ctx = ctx;
idle->idle_info_type = type;
return idle;
}
idle_info_t* idle_info_init_dummy(idle_info_t* idle, uint32_t id) {
return_value_if_fail(idle != NULL, NULL);
memset(idle, 0x00, sizeof(idle_info_t));
idle->id = id;
return idle;
}
idle_info_t* idle_info_cast(idle_info_t* idle) {
return_value_if_fail(idle != NULL, NULL);
return idle;
}
bool_t idle_info_is_available(idle_info_t* idle, uint32_t dispatch_id) {
return idle != NULL && !(idle->busy) && idle->dispatch_id != dispatch_id;
}
ret_t idle_info_on_idle(idle_info_t* idle, uint32_t dispatch_id) {
ret_t ret = RET_OK;
return_value_if_fail(idle != NULL && idle->on_idle != NULL, RET_BAD_PARAMS);
if (idle->busy) {
return RET_BUSY;
}
idle->busy = TRUE;
idle->dispatch_id = dispatch_id;
ret = idle->on_idle(idle);
idle->busy = FALSE;
return ret;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/compressor.h
|
/**
* File: compressor.h
* Author: AWTK Develop Team
* Brief: compressor interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed data the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-12 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COMPRESSOR_H
#define TK_COMPRESSOR_H
#include "tkc/buffer.h"
BEGIN_C_DECLS
struct _compressor_t;
typedef struct _compressor_t compressor_t;
typedef ret_t (*compressor_compress_t)(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out);
typedef ret_t (*compressor_uncompress_t)(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out);
typedef ret_t (*compressor_destroy_t)(compressor_t* compressor);
typedef enum _compressor_options_t {
COMPRESSOR_SPEED_FIRST = 0,
COMPRESSOR_RATIO_FIRST
} compressor_options_t;
/**
* @class compressor_t
*
* 压缩解压接口。
*
*/
struct _compressor_t {
const char* type;
compressor_options_t options;
compressor_compress_t compress;
compressor_uncompress_t uncompress;
compressor_destroy_t destroy;
};
/**
* @method compressor_compress
*
* 压缩数据。
*
* @param {compressor_t*} compressor compressor对象。
* @param {const void*} data 待压缩的数据。
* @param {uint32_t} size 数据长度。
* @param {wbuffer_t*} out 压缩之后的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t compressor_compress(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out);
/**
* @method compressor_uncompress
*
* 解压数据。
*
* @param {compressor_t*} compressor compressor对象。
* @param {const void*} data 待解压的数据。
* @param {uint32_t} size 数据长度。
* @param {wbuffer_t*} out 解压之后的数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t compressor_uncompress(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out);
/**
* @method compressor_destroy
*
* 销毁compressor对象。
*
* @param {compressor_t*} compressor compressor对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t compressor_destroy(compressor_t* compressor);
#define TK_COMPRESSOR(obj) ((compressor_t*)(obj))
END_C_DECLS
#endif /*TK_COMPRESSOR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/rom_fs.h
|
/**
* File: rom_file.h
* Author: AWTK Develop Team
* Brief: posix file api for rom data.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-23 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ROM_FS_H
#define TK_ROM_FS_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class rom_file_t
* @annotation ["fake"]
* rom_file接口。
*
* > 主要用于给google pinyin输入提供兼容的文件系统API。
*
* 示例：
*
* ```c
* char rbuff[100];
* size_t len = 0;
* const char* buff = "hello world";
* rom_file_t* f = rom_fopen_buff((const uint8_t*)buff, sizeof(buff));
* len = rom_fread(rbuff, 2, 1, f);
* rom_fclose(f);
* ```
*
*/
typedef struct _rom_file_t {
uint32_t cursor;
uint32_t capacity;
const uint8_t* data;
} rom_file_t;
/**
* @method rom_fopen
*
* 打开文件。
*
* @param {const char*} name 文件名。
* @param {const char*} mode 打开方式。
*
* @return {rom_file_t*} 返回不是NULL表示成功，否则表示失败。
*/
rom_file_t* rom_fopen(const char* name, const char* mode);
/**
* @method rom_fopen_buff
* 打开文件。
* @param {const uint8_t*} data 数据。
* @param {uint32_t} capacity 容量。
*
* @return {rom_file_t*} 打开成功则返回rom_file_t对象，否则返回NULL。
*/
rom_file_t* rom_fopen_buff(const uint8_t* data, uint32_t capacity);
/**
* @method rom_ftell
*
* 返回文件当前位置。
*
* @param {rom_file_t*} f rom_file_t对象。
*
* @return {long} 返回当前位置。
*/
long rom_ftell(rom_file_t* f);
/**
* @method rom_feof
*
* 判断是否到文件末尾。
*
* @param {rom_file_t*} f rom_file_t对象。
*
* @return {int} 返回当前位置。
*/
int rom_feof(rom_file_t* f);
int rom_ferror(rom_file_t* f);
/**
* @method rom_fseek
*
* 设置文件当前位置。
*
* @param {rom_file_t*} f rom_file_t对象。
* @param {long} offset 偏移量。
* @param {int} whence 要从哪个位置开始偏移， SEEK_SET表示从头开始，SEEK_CUR表示从当前位置开始，SEEK_END表示从文件末尾开始。
*
* @return {int} 返回0表示成功。
*/
int rom_fseek(rom_file_t* f, long offset, int whence);
/**
* @method rom_fread
*
* 读取文件。
*
* @param {void*} ptr 数据的缓冲区。
* @param {size_t} size 缓冲区大小。
* @param {size_t} nitems 元素的个数。
* @param {rom_file_t*} f rom_file_t对象。
*
* @return {size_t} 返回实际读取的字节数。
*/
size_t rom_fread(void* ptr, size_t size, size_t nitems, rom_file_t* f);
/**
* @method rom_fwrite
*
* 写文件。
*> 本函数什么也不做。
* @param {const void*} ptr 数据的缓冲区。
* @param {size_t} size 缓冲区大小。
* @param {size_t} nitems 元素的个数。
* @param {rom_file_t*} f rom_file_t对象。
*
* @return {size_t} 返回实际写的字节数。
*/
size_t rom_fwrite(const void* ptr, size_t size, size_t nitems, rom_file_t* f);
/**
* @method rom_fclose
*
* 关闭文件。
*
* @param {rom_file_t*} f rom_file_t对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rom_fclose(rom_file_t* f);
END_C_DECLS
#endif /*TK_ROM_FS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/named_value_hash.h
|
/**
* File: named_value_hash.h
* Author: AWTK Develop Team
* Brief: 带有散列值的named value
*
* Copyright (c) 2024 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2024-08-21 Shen ZhaoKun <[email protected]> created
*
*/
#ifndef TK_NAMED_VALUE_HASH_H
#define TK_NAMED_VALUE_HASH_H
#include "tkc/named_value.h"
BEGIN_C_DECLS
/**
* @class named_value_hash_t
* @parent named_value_t
* @annotation ["scriptable"]
* 带有散列值的命名的值。
*
*/
typedef struct _named_value_hash_t {
named_value_t base;
/**
* @property {uint64_t} hash
* @annotation ["readable"]
* 散列值。
*/
uint64_t hash;
} named_value_hash_t;
/**
* @method named_value_hash_create
*
* 创建named_value_hash对象。
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {named_value_hash_t*} 返回named_value_hash对象。
*/
named_value_hash_t* named_value_hash_create(void);
/**
* @method named_value_hash_create_ex
*
* 创建named_value_hash对象。
* @annotation ["constructor"]
*
* @param {const char*} name 名称。
* @param {const value_t*} value 值。
*
* @return {named_value_hash_t*} 返回named_value_hash对象。
*/
named_value_hash_t* named_value_hash_create_ex(const char* name, const value_t* value);
/**
* @method named_value_hash_init
*
* 初始化。
* @annotation ["constructor"]
*
* @param {named_value_hash_t*} nvh named_value_hash对象。
* @param {const char*} name 名称。
* @param {const value_t*} value 值。
*
* @return {named_value_hash_t*} 返回named_value_hash对象。
*/
named_value_hash_t* named_value_hash_init(named_value_hash_t* nvh, const char* name,
const value_t* value);
/**
* @method named_value_hash_set_name
*
* 设置散列值。
* @annotation ["scriptable"]
*
* @param {named_value_hash_t*} nvh named_value_hash对象。
* @param {const char*} name 名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_hash_set_name(named_value_hash_t* nvh, const char* name);
/**
* @method named_value_hash_deinit
*
* 重置named_value_hash对象。
* @annotation ["deconstructor"]
*
* @param {named_value_hash_t*} nvh named_value_hash对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_hash_deinit(named_value_hash_t* nvh);
/**
* @method named_value_hash_compare
*
* 比较。
*
* @param {const named_value_hash_t*} nvh named_value_hash对象。
* @param {const named_value_hash_t*} other named_value_hash对象。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_hash_compare(const named_value_hash_t* nvh, const named_value_hash_t* other);
/**
* @method named_value_hash_compare_by_hash
*
* 比较。
*
* @param {const named_value_hash_t*} nvh named_value_hash对象。
* @param {uint64_t} hash 散列值。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_hash_compare_by_hash(const named_value_hash_t* nvh, uint64_t hash);
/**
* @method named_value_hash_destroy
*
* 销毁named_value_hash对象。
* @annotation ["deconstructor", "scriptable", "gc"]
*
* @param {named_value_hash_t*} nvh named_value_hash对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_hash_destroy(named_value_hash_t* nvh);
/**
* @method named_value_hash_clone
*
* 克隆named_value_hash对象。
* @annotation ["scriptable"]
*
* @param {named_value_hash_t*} nvh named_value_hash对象。
*
* @return {named_value_hash_t*} 返回named_value_hash对象。
*/
named_value_hash_t* named_value_hash_clone(named_value_hash_t* nvh);
/**
* @method named_value_hash_get_hash_from_str
*
* 获取字符串散列值。
* @annotation ["static", "scriptable"]
*
* @param {const char*} str 字符串。
*
* @return {uint64_t} 返回散列值。
*/
uint64_t named_value_hash_get_hash_from_str(const char* str);
END_C_DECLS
#endif /*TK_NAMED_VALUE_HASH_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/crc.h
|
/*
Copyright 2016-2019 (C) Alexey Dynda
This file is part of Tiny Protocol Library.
Protocol Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Protocol Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with Protocol Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TK_CRC_H
#define TK_CRC_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class crc_t
* @annotation ["fake"]
* crc相关函数。
*/
#define CONFIG_ENABLE_FCS16
#define CONFIG_ENABLE_FCS32
#define CONFIG_ENABLE_CHECKSUM
#ifdef CONFIG_ENABLE_CHECKSUM
#define INITCHECKSUM 0x0000
#define GOODCHECKSUM 0x0000
/**
* @method tk_chksum
* 计算检验和。
* @annotation ["static"]
* @param {uint16_t} sum 初始值(一般用INITCHECKSUM)
* @param {const void*} data 数据。
* @param {int} size 数据长度。
*
* @return {uint16_t} 返回计算结果。
*/
uint16_t tk_chksum(uint16_t sum, const void* data, int size);
/**
* @method tk_chksum_byte
* 计算单子节的检验和。
* @annotation ["static"]
* @param {uint16_t} sum 初始值(一般用0，或者之前的值)
* @param {uint8_t} data 数据。
*
* @return {uint16_t} 返回计算结果。
*/
uint16_t tk_chksum_byte(uint16_t sum, uint8_t data);
#endif
#ifdef CONFIG_ENABLE_FCS16
#define PPPINITFCS16 0xffff /* Initial FCS value */
#define PPPGOODFCS16 0xf0b8 /* Good final FCS value */
/**
* @method tk_crc16
* 计算crc16。
* @annotation ["static"]
* @param {uint16_t} crc 初始值(一般用PPPINITFCS16)
* @param {const void*} data 数据。
* @param {int} size 数据长度。
*
* @return {uint16_t} 返回计算结果。
*/
uint16_t tk_crc16(uint16_t crc, const void* data, int size);
/**
* @method tk_crc16_byte
* 计算单子节的crc16。
* @annotation ["static"]
* @param {uint16_t} crc 初始值(一般用PPPINITFCS16，或者之前的值)
* @param {uint8_t} data 数据。
*
* @return {uint16_t} 返回计算结果。
*/
uint16_t tk_crc16_byte(uint16_t crc, uint8_t data);
/**
* @method tk_crc16_modbus
* 计算crc16(MODBUS)。
* @annotation ["static"]
* @param {const void*} data 数据。
* @param {int} size 数据长度。
*
* @return {uint16_t} 返回计算结果。
*/
uint16_t tk_crc16_modbus(const void* data, uint32_t len);
#endif
#ifdef CONFIG_ENABLE_FCS32
#define PPPINITFCS32 0xffffffff /* Initial FCS value */
#define PPPGOODFCS32 0xdebb20e3 /* Good final FCS value */
/**
* @method tk_crc32
* 计算crc32。
* @annotation ["static"]
* @param {uint32_t} crc 初始值(一般用PPPINITFCS32)
* @param {const void*} data 数据。
* @param {int} size 数据长度。
*
* @return {uint32_t} 返回计算结果。
*/
uint32_t tk_crc32(uint32_t crc, const void* data, int size);
/**
* @method tk_crc32_byte
* 计算单子节的crc32。
* @annotation ["static"]
* @param {uint32_t} crc 初始值(一般用PPPINITFCS32，或者之前的值)
* @param {uint8_t} data 数据。
*
* @return {uint32_t} 返回计算结果。
*/
uint32_t tk_crc32_byte(uint32_t crc, uint8_t data);
/**
* @method tk_crc32_file
* 计算文件的crc32哈希值。
* @param {const char*} filename 文件名。
* @param {uint32_t} block_size 数据块长度。
*
* @return {uint32_t} 返回计算结果。
*/
uint32_t tk_crc32_file(const char* filename, uint32_t block_size);
#endif
END_C_DECLS
#endif /*TK_CRC_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_fd.h
|
/**
* File: event_source_fd.h
* Author: AWTK Develop Team
* Brief: event source fd
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_SOURCE_FD_H
#define TK_EVENT_SOURCE_FD_H
#include "tkc/event_source.h"
BEGIN_C_DECLS
struct _event_source_fd_t;
typedef struct _event_source_fd_t event_source_fd_t;
/**
* @class event_source_fd_t
* @parent tk_object_t
*
* fd事件源。用于文件、管道和套接字。
*
*/
struct _event_source_fd_t {
event_source_t event_source;
int fd;
void* ctx;
void* ctx2;
event_source_on_event_t on_event;
};
/**
* @method event_source_fd_create
*
* 创建fd事件源。
*
* @param {int} fd 可以用select等待的文件描述符。
* @param {event_source_on_event_t} on_event 用户的事件处理函数。
* @param {void*} ctx on_event函数的上下文。
*
* @return {event_source_t*} 返回事件源对象。
*
*/
event_source_t* event_source_fd_create(int fd, event_source_on_event_t on_event, void* ctx);
#define EVENT_SOURCE_FD(obj) ((event_source_fd_t*)(obj))
END_C_DECLS
#endif /*TK_EVENT_SOURCE_FD_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_hash.c
|
/**
* File: object_hash.c
* Author: AWTK Develop Team
* Brief: 用散列值查询属性的object
*
* Copyright (c) 2024 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2024-08-19 Shen ZhaoKun <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/named_value_hash.h"
#include "tkc/object_hash.h"
static int32_t object_hash_find_prop_index_by_name(tk_object_t* obj, const char* name,
bool_t* p_is_gen_hash, uint64_t* p_hash) {
int32_t ret = -1;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL && name != NULL, -1);
if (*name == '[' && tk_isdigit(name[1]) && tk_str_end_with(name, "]")) {
ret = tk_atoi(name + 1);
return_value_if_fail(ret < o->props.size, -1);
} else {
uint64_t hash = named_value_hash_get_hash_from_str(name);
if (p_hash != NULL) {
(*p_hash) = hash;
}
if (p_is_gen_hash != NULL) {
(*p_is_gen_hash) = TRUE;
}
ret = darray_bsearch_index(&(o->props), (tk_compare_t)named_value_hash_compare_by_hash,
(void*)hash);
if (ret >= 0) {
named_value_hash_t* nvh = (named_value_hash_t*)darray_get(&o->props, ret);
if (!tk_str_eq(name, nvh->base.name)) {
darray_t bucket;
darray_init(&bucket, 8, NULL, (tk_compare_t)named_value_compare);
log_debug("%s: Hashing collision!\r\n", __FUNCTION__);
log_debug("Hash: %lld\r\n", hash);
log_debug("Wrong name: %s\r\n", nvh->base.name);
log_debug("Target name: %s\r\n\r\n", name);
ret = -1;
if (RET_OK == darray_find_all(&o->props, (tk_compare_t)named_value_hash_compare_by_hash,
(void*)hash, &bucket)) {
named_value_hash_t* right_nvh = NULL;
darray_sort(&bucket, (tk_compare_t)named_value_compare);
right_nvh = (named_value_hash_t*)darray_bsearch(
&bucket, (tk_compare_t)named_value_compare_by_name, (void*)name);
if (right_nvh != NULL) {
ret = darray_find_index_ex(&o->props, pointer_compare, (void*)right_nvh);
}
}
darray_deinit(&bucket);
}
}
}
return ret;
}
static value_t* object_hash_find_prop_by_name(tk_object_t* obj, const char* name,
bool_t* p_is_gen_hash, uint64_t* p_hash) {
named_value_hash_t* nvh = NULL;
object_hash_t* o = OBJECT_HASH(obj);
int32_t index = -1;
return_value_if_fail(o != NULL && name != NULL, NULL);
index = object_hash_find_prop_index_by_name(obj, name, p_is_gen_hash, p_hash);
if (index >= 0) {
nvh = (named_value_hash_t*)darray_get(&o->props, index);
}
return nvh != NULL ? &(nvh->base.value) : NULL;
}
static ret_t object_hash_clear_props(tk_object_t* obj) {
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return darray_clear(&(o->props));
}
static ret_t object_hash_on_destroy(tk_object_t* obj) {
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return darray_deinit(&(o->props));
}
static int32_t object_hash_compare(tk_object_t* obj, tk_object_t* other) {
return_value_if_fail(obj != NULL && other != NULL, -1);
return tk_str_cmp(obj->name, other->name);
}
static ret_t object_hash_remove_prop(tk_object_t* obj, const char* name) {
int32_t index = 0;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_remove_prop(sub, name);
}
}
index = object_hash_find_prop_index_by_name(obj, name, NULL, NULL);
if (index >= 0) {
return darray_remove_index(&(o->props), index);
} else {
return RET_NOT_FOUND;
}
}
static ret_t value_deep_copy_keep_type(value_t* dst, const value_t* src) {
ret_t ret = RET_OK;
return_value_if_fail(dst != NULL && src != NULL, RET_BAD_PARAMS);
switch (dst->type) {
case VALUE_TYPE_BOOL: {
value_set_bool(dst, value_bool(src));
break;
}
case VALUE_TYPE_INT8: {
value_set_int8(dst, value_int8(src));
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(dst, value_uint8(src));
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(dst, value_int16(src));
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(dst, value_uint16(src));
break;
}
case VALUE_TYPE_INT32: {
value_set_int32(dst, value_int32(src));
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(dst, value_uint32(src));
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(dst, value_int64(src));
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(dst, value_uint64(src));
break;
}
case VALUE_TYPE_FLOAT: {
value_set_float(dst, value_float(src));
break;
}
case VALUE_TYPE_DOUBLE: {
value_set_double(dst, value_double(src));
break;
}
case VALUE_TYPE_STRING: {
value_reset(dst);
value_dup_str(dst, value_str(src));
break;
}
default: {
if (dst->type == src->type) {
value_reset(dst);
value_deep_copy(dst, src);
} else {
ret = RET_FAIL;
log_debug("not support type:%d\n", dst->type);
}
break;
}
}
return ret;
}
static ret_t object_hash_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
value_t* vv = NULL;
ret_t ret = RET_NOT_FOUND;
object_hash_t* o = OBJECT_HASH(obj);
bool_t is_gen_hash = FALSE;
uint64_t hash = 0;
ENSURE(o);
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_set_prop(sub, name, v);
}
}
vv = object_hash_find_prop_by_name(obj, name, &is_gen_hash, &hash);
if (vv != NULL) {
if (o->keep_prop_type) {
ret = value_deep_copy_keep_type(vv, v);
} else {
value_reset(vv);
ret = value_deep_copy(vv, v);
}
} else {
named_value_hash_t* nvh = named_value_hash_create_ex(NULL, v);
return_value_if_fail(nvh != NULL, RET_OOM);
if (is_gen_hash) {
named_value_set_name(&nvh->base, name);
nvh->hash = hash;
} else {
named_value_hash_set_name(nvh, name);
}
ret = darray_sorted_insert(&(o->props), nvh, (tk_compare_t)named_value_hash_compare, FALSE);
if (ret != RET_OK) {
named_value_hash_destroy(nvh);
}
}
return ret;
}
static ret_t object_hash_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, TK_OBJECT_PROP_SIZE)) {
value_set_uint32(v, o->props.size);
return RET_OK;
}
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_get_prop(sub, name, v);
}
}
if (o->props.size > 0) {
const value_t* vv = object_hash_find_prop_by_name(obj, name, NULL, NULL);
if (vv != NULL) {
ret = value_copy(v, vv);
} else {
ret = RET_NOT_FOUND;
}
}
return ret;
}
static bool_t object_hash_can_exec(tk_object_t* obj, const char* name, const char* args) {
bool_t ret = FALSE;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_can_exec(sub, name, args);
}
}
return ret;
}
static ret_t object_hash_exec(tk_object_t* obj, const char* name, const char* args) {
ret_t ret = RET_NOT_FOUND;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_exec(sub, name, args);
}
}
return ret;
}
static ret_t object_hash_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_OK;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL && on_prop != NULL, RET_BAD_PARAMS);
if (o->props.size > 0) {
uint32_t i = 0;
for (i = 0; i < o->props.size; i++) {
named_value_hash_t* iter = (named_value_hash_t*)(o->props.elms[i]);
ret = on_prop(ctx, iter);
if (ret == RET_REMOVE) {
named_value_hash_destroy(iter);
o->props.elms[i] = NULL;
} else if (ret != RET_OK) {
break;
}
}
darray_remove_all(&(o->props), pointer_compare, NULL);
}
return ret;
}
static value_t* object_hash_find_prop(tk_object_t* obj, tk_compare_t cmp, const void* data) {
named_value_hash_t* nvh = NULL;
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL && cmp != NULL, NULL);
nvh = (named_value_hash_t*)darray_find_ex(&(o->props), cmp, (void*)data);
return nvh != NULL ? &(nvh->base.value) : NULL;
}
static tk_object_t* object_hash_clone(object_hash_t* o) {
uint32_t i = 0;
tk_object_t* dup = NULL;
object_hash_t* dupo = NULL;
return_value_if_fail(o != NULL, NULL);
dup = object_hash_create();
return_value_if_fail(dup != NULL, NULL);
dupo = OBJECT_HASH(dup);
dupo->enable_path = o->enable_path;
dupo->keep_prop_type = o->keep_prop_type;
for (i = 0; i < o->props.size; i++) {
named_value_hash_t* iter = (named_value_hash_t*)(o->props.elms[i]);
named_value_hash_t* nvh = named_value_hash_clone(iter);
if (darray_push(&(dupo->props), nvh) != RET_OK) {
named_value_hash_destroy(nvh);
break;
}
}
return dup;
}
static const object_vtable_t s_object_hash_vtable = {
.type = OBJECT_HASH_TYPE,
.desc = OBJECT_HASH_TYPE,
.size = sizeof(object_hash_t),
.is_collection = FALSE,
.on_destroy = object_hash_on_destroy,
.clone = (tk_object_clone_t)object_hash_clone,
.compare = object_hash_compare,
.get_prop = object_hash_get_prop,
.set_prop = object_hash_set_prop,
.can_exec = object_hash_can_exec,
.exec = object_hash_exec,
.remove_prop = object_hash_remove_prop,
.foreach_prop = object_hash_foreach_prop,
.clear_props = object_hash_clear_props,
.find_prop = object_hash_find_prop,
};
tk_object_t* object_hash_create_ex(bool_t enable_path) {
tk_object_t* obj = tk_object_create(&s_object_hash_vtable);
object_hash_t* o = OBJECT_HASH(obj);
ENSURE(o);
return_value_if_fail(obj != NULL, NULL);
o->enable_path = enable_path;
darray_init(&(o->props), 8, (tk_destroy_t)named_value_hash_destroy,
(tk_compare_t)named_value_hash_compare);
return obj;
}
tk_object_t* object_hash_create(void) {
return object_hash_create_ex(TRUE);
}
ret_t object_hash_set_keep_prop_type(tk_object_t* obj, bool_t keep_prop_type) {
object_hash_t* o = OBJECT_HASH(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
o->keep_prop_type = keep_prop_type;
return RET_OK;
}
object_hash_t* object_hash_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_hash_vtable, NULL);
return (object_hash_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/emitter.h
|
/**
* File: emitter.h
* Author: AWTK Develop Team
* Brief: emitter dispatcher
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EMITTER_H
#define TK_EMITTER_H
#include "tkc/event.h"
BEGIN_C_DECLS
struct _emitter_item_t;
typedef struct _emitter_item_t emitter_item_t;
struct _emitter_item_t {
void* ctx;
uint32_t id;
uint32_t type;
event_func_t handler;
uint32_t tag;
bool_t working;
bool_t pending_remove;
tk_destroy_t on_destroy;
void* on_destroy_ctx;
emitter_item_t* next;
};
/**
* @class emitter_t
* @order -10
* @annotation ["scriptable"]
*
* 事件分发器, 用于实现观察者模式。
*/
typedef struct _emitter_t {
/**
* @property {emitter_item_t*} items
* @annotation ["private"]
* 注册的回调函数集合。
*/
emitter_item_t* items;
/**
* @property {uint32_t} next_id
* @annotation ["private"]
* 下一次emitter_on返回的ID，emitter_on成功后会自动增加next_id。
*/
uint32_t next_id;
/**
* @property {int32_t} disable
* @annotation ["readable"]
* 禁用标志。禁用时dispatch无效。
*/
int32_t disable;
} emitter_t;
/**
* @method emitter_create
* @annotation ["constructor", "scriptable", "gc"]
* 创建emitter对象。
*
* @return {emitter_t*} 对象。
*/
emitter_t* emitter_create(void);
/**
* @method emitter_init
* @annotation ["constructor"]
* 初始化emitter对象。
* @param {emitter_t*} emitter emitter对象。
*
* @return {emitter_t*} 对象。
*/
emitter_t* emitter_init(emitter_t* emitter);
/**
* @method emitter_dispatch
* 分发事件。如果当前分发的回调函数返回RET_REMOVE，该回调函数将被移出。
* 禁用状态下，本函数不做任何事情。
* @annotation ["scriptable"]
* @param {emitter_t*} emitter emitter对象。
* @param {event_t*} e 事件对象。
* @return {ret_t} 如果当前分发的回调函数返回RET_STOP，dispatch中断分发，并返回RET_STOP，否则返回RET_OK。
*/
ret_t emitter_dispatch(emitter_t* emitter, event_t* e);
/**
* @method emitter_dispatch_simple_event
* 分发事件。
* > 对emitter_dispatch的包装，分发一个简单的事件。
* @annotation ["scriptable"]
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} type 事件类型。
* @return {ret_t}
* 如果当前分发的回调函数返回RET_STOP，dispatch中断分发，并返回RET_STOP，否则返回RET_OK。
*/
ret_t emitter_dispatch_simple_event(emitter_t* emitter, uint32_t type);
/**
* @method emitter_on
* 注册指定事件的处理函数。
* @annotation ["scriptable:custom"]
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} etype 事件类型。
* @param {event_func_t} handler 事件处理函数。
* @param {void*} ctx 事件处理函数上下文。
*
* @return {uint32_t} 返回id，用于emitter_off。
*/
uint32_t emitter_on(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx);
/**
* @method emitter_exist
* 判断指定的事件和回调函数是否已经注册。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} etype 事件类型。
* @param {event_func_t} handler 事件处理函数。
* @param {void*} ctx 事件处理函数上下文。
*
* @return {bool_t} 返回TRUE表示已经注册，否则表示没有注册。
*/
bool_t emitter_exist(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx);
/**
* @method emitter_on_with_tag
* 注册指定事件的处理函数。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} etype 事件类型。
* @param {event_func_t} handler 事件处理函数。
* @param {void*} ctx 事件处理函数上下文。
* @param {uint32_t} tag tag。
*
* @return {uint32_t} 返回id，用于emitter_off。
*/
uint32_t emitter_on_with_tag(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx,
uint32_t tag);
/**
* @method emitter_off
* 注销指定事件的处理函数。
* @annotation ["scriptable"]
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} id emitter_on返回的ID。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_off(emitter_t* emitter, uint32_t id);
/**
* @method emitter_off_by_func
* 注销指定事件的处理函数。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} etype 事件类型。
* @param {event_func_t} handler 事件处理函数。
* @param {void*} ctx 事件处理函数上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_off_by_func(emitter_t* emitter, uint32_t etype, event_func_t handler, void* ctx);
/**
* @method emitter_off_by_ctx
* 注销指定事件的处理函数。
* @param {emitter_t*} emitter emitter对象。
* @param {void*} ctx 事件处理函数上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_off_by_ctx(emitter_t* emitter, void* ctx);
/**
* @method emitter_off_by_tag
* 注销指定事件的处理函数。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} tag tag。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_off_by_tag(emitter_t* emitter, uint32_t tag);
/**
* @method emitter_set_on_destroy
* 设置一个回调函数，在emitter被销毁时调用(方便脚本语言去释放回调函数)。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} id emitter_on返回的ID。
* @param {tk_destroy_t} on_destroy 回调函数。
* @param {void*} on_destroy_ctx 回调函数上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_set_on_destroy(emitter_t* emitter, uint32_t id, tk_destroy_t on_destroy,
void* on_destroy_ctx);
/**
* @method emitter_find
* 通过ID查找emitter_item_t，主要用于辅助测试。
* @param {emitter_t*} emitter emitter对象。
* @param {uint32_t} id emitter_on返回的ID。
*
* @return {emitter_item_t*} 若存在,返回id对应的emitter_item_t，否则返回NULL。
*/
emitter_item_t* emitter_find(emitter_t* emitter, uint32_t id);
/**
* @method emitter_enable
* 启用。
* @annotation ["scriptable"]
* @param {emitter_t*} emitter emitter对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_enable(emitter_t* emitter);
/**
* @method emitter_disable
* 禁用。
*
* 禁用后emitter_dispatch无效，但可以注册和注销。
*
* @annotation ["scriptable"]
* @param {emitter_t*} emitter emitter对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_disable(emitter_t* emitter);
/**
* @method emitter_size
* 获取注册的回调函数个数，主要用于辅助测试。
* @param {emitter_t*} emitter emitter对象。
*
* @return {uint32_t} 回调函数个数。
*/
uint32_t emitter_size(emitter_t* emitter);
/**
* @method emitter_deinit
* 析构。
*
* @annotation ["deconstructor"]
* @param {emitter_t*} emitter emitter对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_deinit(emitter_t* emitter);
/**
* @method emitter_destroy
* 销毁。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {emitter_t*} emitter emitter对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_destroy(emitter_t* emitter);
/**
* @method emitter_cast
* 转换为emitter对象(供脚本语言使用)。
*
* 主要给脚本语言使用。
* @annotation ["cast", "scriptable"]
* @param {emitter_t*} emitter emitter对象。
*
* @return {emitter_t*} 对象。
*/
emitter_t* emitter_cast(emitter_t* emitter);
/**
* @method emitter_forward
* 分发事件
*
* @param {void*} ctx emitter对象。
* @param {event_t*} e 分发的事件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_forward(void* ctx, event_t* e);
/**
* @method emitter_forward_retarget
* 分发事件。并将e->target强制设置为ctx。
*
* @param {void*} ctx emitter对象。
* @param {event_t*} e 分发的事件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t emitter_forward_retarget(void* ctx, event_t* e);
#define EMITTER(emitter) ((emitter_t*)(emitter))
#define EMITTER_ENABLE(emitter) \
if ((emitter) != NULL) { \
emitter_enable(EMITTER(emitter)); \
}
#define EMITTER_DISABLE(emitter) \
if ((emitter) != NULL) { \
emitter_disable(EMITTER(emitter)); \
}
/*public for test*/
ret_t emitter_remove_item(emitter_t* emitter, emitter_item_t* item);
emitter_item_t* emitter_get_item(emitter_t* emitter, uint32_t index);
END_C_DECLS
#endif /*TK_EMITTER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/compressor.c
|
/**
* File: compressor.c
* Author: AWTK Develop Team
* Brief: compressor interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed data the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-12 Li XianJing <[email protected]> created
*
*/
#include "tkc/compressor.h"
ret_t compressor_compress(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out) {
return_value_if_fail(compressor != NULL && compressor->compress, RET_BAD_PARAMS);
return_value_if_fail(data != NULL && out != NULL && out->extendable, RET_BAD_PARAMS);
return compressor->compress(compressor, data, size, out);
}
ret_t compressor_uncompress(compressor_t* compressor, const void* data, uint32_t size,
wbuffer_t* out) {
return_value_if_fail(compressor != NULL && compressor->uncompress, RET_BAD_PARAMS);
return_value_if_fail(data != NULL && out != NULL && out->extendable, RET_BAD_PARAMS);
return compressor->uncompress(compressor, data, size, out);
}
ret_t compressor_destroy(compressor_t* compressor) {
return_value_if_fail(compressor != NULL && compressor->destroy, RET_BAD_PARAMS);
return compressor->destroy(compressor);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/func_call_parser.c
|
/**
* File: func_call_parser.h
* Author: AWTK Develop Team
* Brief: func_call_parser
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is difunc_call_parseributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-10-20 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/utils.h"
#include "tkc/object_default.h"
#include "tkc/func_call_parser.h"
func_call_parser_t* func_call_parser_init(func_call_parser_t* parser, const char* str,
uint32_t size) {
return_value_if_fail(parser != NULL && str != NULL, NULL);
tokenizer_init(&(parser->tokenizer), str, size, "(=,)\r\n\t ");
return parser;
}
ret_t func_call_parser_parse(func_call_parser_t* parser) {
const char* token = NULL;
char name[TK_NAME_LEN + 1];
tokenizer_t* tokenizer = NULL;
return_value_if_fail(parser != NULL, RET_BAD_PARAMS);
tokenizer = &(parser->tokenizer);
return_value_if_fail(tokenizer_has_more(tokenizer) == TRUE, RET_BAD_PARAMS);
token = tokenizer_next(tokenizer);
if (parser->on_name != NULL) {
parser->on_name(parser, token);
}
while (tokenizer_has_more(tokenizer)) {
token = tokenizer_next(tokenizer);
if (token == NULL) {
break;
}
tk_strncpy(name, token, TK_NAME_LEN);
return_value_if_fail(tokenizer_has_more(tokenizer), RET_BAD_PARAMS);
token = tokenizer_next_str(tokenizer);
if (parser->on_param != NULL) {
parser->on_param(parser, name, token);
}
}
if (parser->on_done != NULL) {
parser->on_done(parser);
}
return RET_OK;
}
ret_t func_call_parser_deinit(func_call_parser_t* parser) {
return_value_if_fail(parser != NULL, RET_BAD_PARAMS);
tokenizer_deinit(&(parser->tokenizer));
memset(parser, 0x00, sizeof(func_call_parser_t));
return RET_OK;
}
typedef struct _object_parser_t {
func_call_parser_t base;
tk_object_t* obj;
} object_parser_t;
static ret_t parser_on_param(func_call_parser_t* parser, const char* name, const char* value) {
object_parser_t* p = (object_parser_t*)parser;
return tk_object_set_prop_str(p->obj, name, value);
}
static ret_t parser_on_name(func_call_parser_t* parser, const char* func_name) {
object_parser_t* p = (object_parser_t*)parser;
return tk_object_set_name(p->obj, func_name);
}
tk_object_t* func_call_parse(const char* str, uint32_t size) {
object_parser_t parser;
return_value_if_fail(str != NULL && size > 0, NULL);
memset(&parser, 0x00, sizeof(parser));
func_call_parser_init(&(parser.base), str, size);
parser.obj = object_default_create();
parser.base.on_name = parser_on_name;
parser.base.on_param = parser_on_param;
return_value_if_fail(parser.obj != NULL, NULL);
func_call_parser_parse(&(parser.base));
func_call_parser_deinit(&(parser.base));
return parser.obj;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_file.c
|
/**
* File: data_writer.c
* Author: AWTK Develop Team
* Brief: data_writer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/fs.h"
#include "tkc/data_writer_file.h"
typedef struct _data_writer_file_t {
data_writer_t data_writer;
fs_file_t* file;
} data_writer_file_t;
static int32_t data_writer_file_write(data_writer_t* writer, uint64_t offset, const void* data,
uint32_t size) {
data_writer_file_t* file = (data_writer_file_t*)writer;
return_value_if_fail(fs_file_seek(file->file, offset) == RET_OK, 0);
return fs_file_write(file->file, data, size);
}
static ret_t data_writer_file_destroy(data_writer_t* writer) {
data_writer_file_t* file = (data_writer_file_t*)writer;
fs_file_close(file->file);
TKMEM_FREE(file);
return RET_OK;
}
static ret_t data_writer_file_truncate(data_writer_t* writer, uint64_t size) {
data_writer_file_t* file = (data_writer_file_t*)writer;
return fs_file_truncate(file->file, size);
}
static ret_t data_writer_file_flush(data_writer_t* writer) {
data_writer_file_t* file = (data_writer_file_t*)writer;
return fs_file_sync(file->file);
}
static const data_writer_vtable_t s_data_writer_file_vtable = {
.write = data_writer_file_write,
.truncate = data_writer_file_truncate,
.flush = data_writer_file_flush,
.destroy = data_writer_file_destroy,
};
data_writer_t* data_writer_file_create(const char* filename) {
data_writer_file_t* file = NULL;
return_value_if_fail(filename != NULL, NULL);
file = TKMEM_ZALLOC(data_writer_file_t);
return_value_if_fail(file != NULL, NULL);
file->file = fs_open_file(os_fs(), filename, "wb+");
file->data_writer.vt = &s_data_writer_file_vtable;
if (file->file == NULL) {
TKMEM_FREE(file);
}
return (data_writer_t*)file;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/idle_info.h
|
/**
* File: idle_info.h
* Author: AWTK Develop Team
* Brief: idle info
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_IDLE_INFO_H
#define TK_IDLE_INFO_H
#include "tkc/object.h"
BEGIN_C_DECLS
struct _idle_info_t;
typedef struct _idle_info_t idle_info_t;
struct _idle_manager_t;
typedef struct _idle_manager_t idle_manager_t;
typedef ret_t (*idle_func_t)(const idle_info_t* idle);
typedef enum _idle_info_type_t {
IDLE_INFO_NORMAL = 0,
IDLE_INFO_WIDGET_ADD,
} idle_info_type_t;
/**
* @class idle_info_t
* @parent tk_object_t
* @annotation ["scriptable"]
*
* 单个idle的信息。
*/
struct _idle_info_t {
tk_object_t object;
/**
* @property {idle_func_t} on_idle
* @annotation ["readable"]
* idle回调函数。
*/
idle_func_t on_idle;
/**
* @property {void*} ctx
* @annotation ["readable", "scriptable"]
* idle回调函数上下文。
*/
void* ctx;
/**
* @property {void*} extra_ctx
* @annotation ["readable", "scriptable"]
* idle回调函数上下文。
*/
void* extra_ctx;
/**
* @property {uint32_t} id
* @annotation ["readable", "scriptable"]
* idle的ID
*
* > 为TK\_INVALID\_ID时表示无效idle。
*/
uint32_t id;
/**
* @property {void*} on_destroy_ctx
* @annotation ["readable"]
* idle销毁时的回调函数的上下文。
*/
void* on_destroy_ctx;
/**
* @property {tk_destroy_t} on_destroy
* @annotation ["readable"]
* idle销毁时的回调函数。
*/
tk_destroy_t on_destroy;
/*private*/
uint32_t dispatch_id;
bool_t busy;
uint16_t idle_info_type;
};
/**
* @method idle_info_cast
* 转换为idle_info对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {idle_info_t*} idle idle_info对象。
*
* @return {idle_info_t*} idle_info对象。
*/
idle_info_t* idle_info_cast(idle_info_t* idle);
/*internal use*/
int idle_info_compare_by_id(const void* a, const void* b);
int idle_info_compare_by_ctx(const void* a, const void* b);
int idle_info_compare_by_ctx_and_type(const void* a, const void* b);
idle_info_t* idle_info_init_dummy(idle_info_t* idle, uint32_t id);
idle_info_t* idle_info_init_dummy_with_ctx_and_type(idle_info_t* idle, uint16_t idle_info_type,
void* ctx);
ret_t idle_info_on_idle(idle_info_t* idle, uint32_t dispatch_id);
bool_t idle_info_is_available(idle_info_t* idle, uint32_t dispatch_id);
idle_info_t* idle_info_create(idle_manager_t* idle_manager, uint32_t id, idle_func_t on_idle,
void* ctx, uint16_t idle_info_type);
#define IDLE_INFO(o) ((idle_info_t*)(o))
END_C_DECLS
#endif /*TK_IDLE_INFO_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_file.h
|
/**
* File: data_reader_file.h
* Author: AWTK Develop Team
* Brief: data_reader file
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-26 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_READER_FILE_H
#define TK_DATA_READER_FILE_H
#include "tkc/data_reader.h"
BEGIN_C_DECLS
/**
* @class data_reader_file_t
* @parent data_reader_t
* @annotation ["fake"]
* 基于文件实现的 data_reader。通过 data_reader_factory 创建 reader 时，URL的格式如下(请用函数data_reader_file_build_url生成)：
*
* ```
* file://filename
* ```
*/
/**
* @method data_reader_file_create
* 创建基于文件的data reader。
* > 不要直接调用，而是注册到 data\_reader\_factory后，通过data\_reader\_factory调用。
* @annotation ["constructor"]
*
* @param {const char*} filename 文件名。
*
* @return {data_reader_t*} 返回data reader对象。
*/
data_reader_t* data_reader_file_create(const char* filename);
END_C_DECLS
#endif /*TK_DATA_READER_FILE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/func_call_parser.h
|
/**
* File: func_call_parser.h
* Author: AWTK Develop Team
* Brief: func_call_parser
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is difunc_call_parseributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-10-20 Li XianJing <[email protected]> adapt from uclib
*
*/
#ifndef TK_FUNC_CALL_PARSER_H
#define TK_FUNC_CALL_PARSER_H
#include "tkc/object.h"
#include "tkc/tokenizer.h"
BEGIN_C_DECLS
struct _func_call_parser_t;
typedef struct _func_call_parser_t func_call_parser_t;
/*子类需要实现的虚函数*/
typedef ret_t (*func_call_parser_on_name_t)(func_call_parser_t* parser, const char* func_name);
typedef ret_t (*func_call_parser_on_param_t)(func_call_parser_t* parser, const char* name,
const char* value);
typedef ret_t (*func_call_parser_on_done_t)(func_call_parser_t* parser);
/**
* @class func_call_parser_t
* 从字符串中解析出函数调用需要的参数。
*
* ```
* func_call => func_name '(' params ')'
* params => param ',' params
* param => name '=' value
* func_name => ID
* name = ID
* value = int | float | ID
*```
*
* 如:move(x=10, y=20)
* 如:rename(old_name=aa, new_name=bb)
*/
struct _func_call_parser_t {
tokenizer_t tokenizer;
func_call_parser_on_name_t on_name;
func_call_parser_on_param_t on_param;
func_call_parser_on_done_t on_done;
};
/**
* @method func_call_parser_init
* 初始化parser对象。
* @annotation ["constructor"]
* @param {func_call_parser_t*} parser parser对象。
* @param {const char*} str 要解析的字符串。
* @param {uint32_t} size 字符串长度。
*
* @return {func_call_parser_t*} parser对象本身。
*/
func_call_parser_t* func_call_parser_init(func_call_parser_t* parser, const char* str,
uint32_t size);
/**
* @method func_call_parser_parse
* 开始解析。
* @param {func_call_parser_t*} parser parser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t func_call_parser_parse(func_call_parser_t* parser);
/**
* @method func_call_parser_deinit
* 重置parser。
* @param {func_call_parser_t*} parser parser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t func_call_parser_deinit(func_call_parser_t* parser);
/**
* @method func_call_parse
* 解析参数，并将结果生成一个object对象。
*
*> 调用者负责释放返回的object对象。
* @param {const char*} str 要解析的字符串。
* @param {uint32_t} size 字符串长度。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* func_call_parse(const char* str, uint32_t size);
END_C_DECLS
#endif /*TK_FUNC_CALL_PARSER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/idle_manager.h
|
/**
* File: idle.h
* Author: AWTK Develop Team
* Brief: idle manager
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_IDLE_MANAGER_H
#define TK_IDLE_MANAGER_H
#include "tkc/slist.h"
#include "tkc/idle_info.h"
BEGIN_C_DECLS
/**
* @class idle_manager_t
* @annotation ["scriptable"]
* idle_manager_t管理器。
*/
struct _idle_manager_t {
slist_t idles;
uint32_t next_idle_id;
uint32_t dispatch_times;
};
/**
* @method idle_manager
* 获取缺省的idle_manager_t管理器。
* @annotation ["constructor"]
* @return {idle_manager_t*} 返回idle_manager_t管理器对象。
*/
idle_manager_t* idle_manager(void);
/**
* @method idle_manager_set
* 设置缺省的idle_manager_t管理器。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_set(idle_manager_t* idle_manager);
/**
* @method idle_manager_create
* 创建idle_manager_t管理器。
* @annotation ["constructor"]
*
* @return {idle_manager_t*} 返回idle_manager_t管理器对象。
*/
idle_manager_t* idle_manager_create(void);
/**
* @method idle_manager_init
* 初始化idle_manager_t管理器。
* @annotation ["constructor"]
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {idle_manager_t*} 返回idle_manager_t管理器对象。
*/
idle_manager_t* idle_manager_init(idle_manager_t* idle_manager);
/**
* @method idle_manager_deinit
* 析构idle_manager_t管理器。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_deinit(idle_manager_t* idle_manager);
/**
* @method idle_manager_destroy
* 析构并释放idle_manager_t管理器。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_destroy(idle_manager_t* idle_manager);
/**
* @method idle_manager_count
* 返回idle的个数。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {uint32_t} 返回timer的个数。
*/
uint32_t idle_manager_count(idle_manager_t* idle_manager);
/**
* @method idle_manager_dispatch
* 检查全部idle的函数，如果时间到期，调用相应的idle函数。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_dispatch(idle_manager_t* idle_manager);
/**
* @method idle_manager_remove_all
* 删除全部idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_remove_all(idle_manager_t* idle_manager);
/**
* @method idle_manager_remove_all_by_ctx
* 根据上下文删除所有符合条件的idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {void*} ctx idle回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_remove_all_by_ctx(idle_manager_t* idle_manager, void* ctx);
/**
* @method idle_manager_remove
* 根据idle_id删除idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {uint32_t} idle_id idle_id。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_remove(idle_manager_t* idle_manager, uint32_t idle_id);
/**
* @method idle_manager_append
* 追加idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {idle_info_t*} idle idle对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_append(idle_manager_t* idle_manager, idle_info_t* idle);
/**
* @method idle_manager_find
* 查找指定ID的idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {uint32_t} idle_id idle_id。
*
* @return {const idle_info_t*} 返回idle的信息。
*/
const idle_info_t* idle_manager_find(idle_manager_t* idle_manager, uint32_t idle_id);
/**
* @method idle_manager_add
* 添加idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {idle_func_t} on_idle idle回调函数。
* @param {void*} ctx idle回调函数的上下文。
*
* @return {uint32_t} 返回idle的ID，TK_INVALID_ID表示失败。
*/
uint32_t idle_manager_add(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx);
/**
* @method idle_manager_add_with_id
* 添加 idle（可以指定 idle_id ，如果发现 idle_id 冲突则添加失败）。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {uint32_t} id idle_id。
* @param {idle_func_t} on_idle idle回调函数。
* @param {void*} ctx idle回调函数的上下文。
*
* @return {uint32_t} 返回idle的ID，TK_INVALID_ID表示失败。
*/
uint32_t idle_manager_add_with_id(idle_manager_t* idle_manager, uint32_t id, idle_func_t on_idle,
void* ctx);
/**
* @method idle_manager_get_next_idle_id
* 获取下一个可用的 idle_id。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
*
* @return {uint32_t} 返回idle的ID，TK_INVALID_ID表示失败。
*/
uint32_t idle_manager_get_next_idle_id(idle_manager_t* idle_manager);
/*internal use*/
/**
* @method idle_manager_remove_all_by_ctx_and_type
* 移除对应类型和上下文的所有idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {uint16_t} type 类型。
* @param {void*} ctx 上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t idle_manager_remove_all_by_ctx_and_type(idle_manager_t* idle_manager, uint16_t type,
void* ctx);
/**
* @method idle_manager_add_with_type
* 添加对应类型的idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {idle_func_t} on_idle idle回调函数。
* @param {void*} ctx 上下文。
* @param {uint16_t} type 类型。
*
* @return {uint32_t} 返回idle_id。
*/
uint32_t idle_manager_add_with_type(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx,
uint16_t type);
/**
* @method idle_manager_add_with_type_and_id
* 添加对应类型和id的idle。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {uint32_t} id id。
* @param {idle_func_t} on_idle idle回调函数。
* @param {void*} ctx 上下文。
* @param {uint16_t} type 类型。
* @param {bool_t} check_id 是否校验id。
*
* @return {uint32_t} 返回idle_id。
*/
uint32_t idle_manager_add_with_type_and_id(idle_manager_t* idle_manager, uint32_t id,
idle_func_t on_idle, void* ctx, uint16_t type,
bool_t check_id);
/**
* @method idle_manager_exist
* 对应回调函数和上下文的idle是否存在。
* @param {idle_manager_t*} idle_manager idle_manager_t管理器对象。
* @param {idle_func_t} on_idle idle回调函数。
* @param {void*} ctx 上下文。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t idle_manager_exist(idle_manager_t* idle_manager, idle_func_t on_idle, void* ctx);
END_C_DECLS
#endif /*TK_IDLE_MANAGER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_mem.h
|
/**
* File: data_reader_mem.h
* Author: AWTK Develop Team
* Brief: data_reader mem
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License mem for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-23 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_READER_MEM_H
#define TK_DATA_READER_MEM_H
#include "tkc/utils.h"
#include "tkc/data_reader.h"
BEGIN_C_DECLS
/**
* @class data_reader_mem_t
* @parent data_reader_t
* @annotation ["fake"]
* 基于内存实现的 data_reader。通过 data_reader_factory 创建 reader 时，URL的格式如下(请用函数data_reader_mem_build_url生成)：
*
* ```
* mem://addr:size
* ```
*/
/**
* @method data_reader_mem_create
* 创建基于内存的 data reader。
*
* > 不要直接调用，而是注册到 data\_reader\_factory后，通过data\_reader\_factory调用。
* @annotation ["constructor"]
* @param {const char*} memname 内存地址和大小的字符串格式表示 。
*
* @return {data_reader_t*} 返回data reader对象。
*/
data_reader_t* data_reader_mem_create(const char* memname);
/**
* @method data_reader_mem_build_url
* 构造内存URL。
* @annotation ["static"]
*
* @param {const void*} buffer 内存的地址。
* @param {uint32_t} size 内存的长度。
* @param {char*} url 生成的URL。
*
* @return {const char*} 返回URL。
*/
const char* data_reader_mem_build_url(const void* buffer, uint32_t size, char url[MAX_PATH + 1]);
#define DATA_READER_MEM(reader) ((data_reader_t*)(reader))
END_C_DECLS
#endif /*TK_DATA_READER_MEM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/socket_helper.h
|
/**
* File: socket_helper.h
* Author: AWTK Develop Team
* Brief: socket helper functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/types_def.h"
#ifdef WITH_SOCKET
#ifndef TK_SOCKET_HELPER_H
#define TK_SOCKET_HELPER_H
BEGIN_C_DECLS
/**
* @class tk_socket_t
* @annotation ["fake"]
*/
/**
* @method tk_socket_init
* @annotation ["static"]
* tcp/udp 平台初始化。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_init(void);
/**
* @method tk_socket_deinit
* @annotation ["static"]
* tcp/udp 平台~初始化。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_deinit(void);
/**
* @method tk_socket_close
* @annotation ["static"]
* 关闭socket句柄。
*
* @param {int} sock socket句柄。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_close(int sock);
/**
* @method tk_socket_send
* @annotation ["static"]
*
* 发送数据。
*
* @param {int} sock socket句柄。
* @param {const void*} buffer 数据缓冲区。
* @param {uint32_t} size 数据长度。
* @param {int} flags 标志。
*
* @return {int32_t} 返回实际发送的字节数。
*/
int32_t tk_socket_send(int sock, const void* buffer, uint32_t size, int flags);
/**
* @method tk_socket_sendto
* @annotation ["static"]
*
* 发送数据到指定地址。
*
* @param {int} sock socket句柄。
* @param {const void*} buffer 数据缓冲区。
* @param {uint32_t} size 数据长度。
* @param {int} flags 标志。
* @param {const struct sockaddr*} dest_addr 目标地址。
* @param {uint32_t} dest_len 目标地址长度。
*
* @return {int32_t} 返回实际发送的字节数。
*/
int32_t tk_socket_sendto(int sock, const void* buffer, uint32_t size, int flags,
const struct sockaddr* dest_addr, uint32_t dest_len);
/**
* @method tk_socket_recv
* @annotation ["static"]
*
* 接收数据。
*
* @param {int} sock socket句柄。
* @param {void*} buffer 用于返回数据的缓冲区。
* @param {uint32_t} size 缓冲区大小。
* @param {int} flags 标志。
*
* @return {int32_t} 返回实际接收的字节数。
*/
int32_t tk_socket_recv(int sock, void* buffer, uint32_t size, int flags);
/**
* @method tk_socket_recvfrom
* @annotation ["static"]
* 从指定地址接收数据。
*
* @param {int} sock socket句柄。
* @param {void*} buffer 用于返回数据的缓冲区。
* @param {uint32_t} size 缓冲区大小。
* @param {int} flags 标志。
* @param {struct sockaddr*} dest_addr 目标地址。
* @param {uint32_t*} dest_len 目标地址长度。
*
* @return {int32_t} 返回实际接收的字节数。
*/
int32_t tk_socket_recvfrom(int sock, void* buffer, uint32_t size, int flags,
struct sockaddr* dest_addr, uint32_t* dest_len);
/**
* @method tk_socket_bind_ex
* @annotation ["static"]
* 绑定到指定IP和端口。
*
* @param {int} sock socket句柄。
* @param {const char*} ip IP地址(可以为NULL)。
* @param {int} port 端口号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_bind_ex(int sock, const char* ip, int port);
/**
* @method tk_socket_bind
* @annotation ["static"]
* 绑定到指定端口。
*
* @param {int} sock socket句柄。
* @param {int} port 端口号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_bind(int sock, int port);
/**
* @method tk_socket_last_io_has_error
* @annotation ["static"]
* 判断最后一次IO操作是否正常。
*
* @return {bool_t} 返回TRUE表示有错误，否则表示正常。
*/
bool_t tk_socket_last_io_has_error(void);
/**
* @method tk_socket_wait_for_data
* @annotation ["static"]
* 等待数据。
*
* @param {int} sock socket句柄。
* @param {uint32_t} timeout_ms 等待时间(毫秒)。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_wait_for_data(int sock, uint32_t timeout_ms);
/**
* @method tk_socket_set_blocking
* @annotation ["static"]
* 设置为阻塞或非阻塞模式。
*
* @param {int} sock socket句柄。
* @param {bool_t} blocking 是否阻塞。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_socket_set_blocking(int sock, bool_t blocking);
/**
* @method tk_socket_resolve
* @annotation ["static"]
* 解析主机名，并初始化addr对象。
*
* @param {const char*} host 主机名。
* @param {int} port 端口号。
* @param {struct sockaddr_in*} addr 地址对象。
*
* @return {struct sockaddr*} 返回地址对象。
*/
struct sockaddr* tk_socket_resolve(const char* host, int port, struct sockaddr_in* addr);
/**
* @method tk_socket_get_client_ip
* @annotation ["static"]
* 获取客户端IP。
*
* @param {int} sockfd socket句柄。
*
* @return {uint32_t} 返回客户端IP。
*/
uint32_t tk_socket_get_client_ip(int sockfd);
/**
* @method tk_socket_get_self_ip
* @annotation ["static"]
* 获取本地IP。
*
* @param {int} sockfd socket句柄。
*
* @return {uint32_t} 返回本地IP。
*/
uint32_t tk_socket_get_self_ip(int sockfd);
/**
* @method tk_socket_get_client_ip_str
* @annotation ["static"]
* 获取客户端IP。
*
* @param {int} sockfd socket句柄。
* @param {char*} ip 存放IP地址的内存。
* @param {int} len 存放IP地址的内存的长度。
*
* @return {const char*} 返回IP地址。
*/
const char* tk_socket_get_client_ip_str(int sockfd, char* ip, int len);
/**
* @method tk_socket_get_self_ip_str
* @annotation ["static"]
* 获取本地IP。
*
* @param {int} sockfd socket句柄。
* @param {char*} ip 存放IP地址的内存。
* @param {int} len 存放IP地址的内存的长度。
*
* @return {const char*} 返回IP地址。
*/
const char* tk_socket_get_self_ip_str(int sockfd, char* ip, int len);
/**
* @class tcp_t
* @annotation ["fake"]
*/
/**
* @method tk_tcp_listen
* @annotation ["static"]
* 监听指定端口，成功返回sock句柄。
* @param {int} port 端口号。
*
* @return {int} 返回sock句柄。
*/
int tk_tcp_listen(int port);
/**
* @method tk_socket_get_port
* @annotation ["static"]
* 获取当前 socket 的监听指定端口。
* @param {int} sock socket句柄。
*
* @return {int} 成功返回端口，失败返回 -1。
*/
int tk_socket_get_port(int sock);
/**
* @method tk_tcp_accept
* @annotation ["static"]
* 监听指定端口，成功返回sock句柄。
* @param {int} sock socket句柄。
*
* @return {int} 返回sock句柄。
*/
int tk_tcp_accept(int sock);
/**
* @method tk_tcp_connect
* @annotation ["static"]
* 连接到指定服务器。
* @param {const char*} host 主机名或IP地址。
* @param {int} port 端口号。
*
* @return {int} 返回sock句柄。
*/
int tk_tcp_connect(const char* host, int port);
/**
* @method tk_tcp_is_port_in_use
* @annotation ["static"]
* 判断指定端口是否被占用。
* @param {int} port 端口号。
*
* @return {bool_t} 返回TRUE表示被占用，否则表示未被占用。
*/
bool_t tk_tcp_is_port_in_use(int port);
/**
* @method tk_tcp_connect_ex
* @annotation ["static"]
* 连接到指定服务器。
* @param {const char*} host 主机名或IP地址。
* @param {int} port 端口号。
* @param {int} timeout 连接超时（毫秒）设置，设置为0代表按系统默认超时。
* @param {void*} opts 保留参数设置，当前只接受NULL值。
*
* @return {int} 返回sock句柄。
*/
int tk_tcp_connect_ex(const char* host, int port, int timeout, void* opts);
/**
* @class udp_t
* @annotation ["fake"]
*/
/**
* @method tk_udp_listen
* @annotation ["static"]
* 监听指定端口，成功返回sock句柄。
* @param {int} port 端口号。
*
* @return {int} 返回sock句柄。
*/
int tk_udp_listen(int port);
/**
* @method tk_udp_connect
* @annotation ["static"]
* 连接到指定服务器。
*
* @param {const char*} host 主机名或IP地址。
* @param {int} port 端口号。
*
* @return {int} 返回sock句柄。
*/
int tk_udp_connect(const char* host, int port);
/**
* @method tk_udp_socket
* @annotation ["static"]
* 创建UDP socket。
*
* @return {int} 返回sock句柄。
*/
int tk_udp_socket(void);
END_C_DECLS
#include "tkc/socket_helper_compat.h"
#endif /*TK_SOCKET_HELPER_H*/
#else
/*提供两个空函数*/
ret_t tk_socket_init(void);
ret_t tk_socket_deinit(void);
#endif /*WITH_SOCKET*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/typed_array.c
|
/**
* File: typed_array.c
* Author: AWTK Develop Team
* Brief: dynamic typed_array.
*
* Copyright (c) 2021 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/typed_array.h"
static bool_t typed_array_is_type_supported(value_type_t type) {
switch (type) {
case VALUE_TYPE_BOOL:
case VALUE_TYPE_INT8:
case VALUE_TYPE_UINT8:
case VALUE_TYPE_INT16:
case VALUE_TYPE_UINT16:
case VALUE_TYPE_INT32:
case VALUE_TYPE_UINT32:
case VALUE_TYPE_INT64:
case VALUE_TYPE_UINT64:
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_FLOAT32:
case VALUE_TYPE_DOUBLE: {
return TRUE;
}
default: {
return FALSE;
}
}
}
typed_array_t* typed_array_create(value_type_t type, uint32_t capacity) {
typed_array_t* typed_array = NULL;
uint32_t element_size = value_type_size(type);
return_value_if_fail(typed_array_is_type_supported(type), NULL);
typed_array = TKMEM_ZALLOC(typed_array_t);
return_value_if_fail(typed_array != NULL, NULL);
typed_array->type = type;
typed_array->element_size = element_size;
if (capacity > 0) {
if (typed_array_extend(typed_array, capacity) != RET_OK) {
TKMEM_FREE(typed_array);
return NULL;
}
}
return typed_array;
}
ret_t typed_array_get(typed_array_t* typed_array, uint32_t index, value_t* v) {
uint8_t* p = NULL;
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(typed_array->data != NULL && index < typed_array->size, RET_BAD_PARAMS);
p = typed_array->data + index * typed_array->element_size;
switch (typed_array->type) {
case VALUE_TYPE_BOOL: {
value_set_bool(v, *(bool_t*)p);
return RET_OK;
}
case VALUE_TYPE_INT8: {
value_set_int8(v, *(int8_t*)p);
return RET_OK;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(v, *(uint8_t*)p);
return RET_OK;
}
case VALUE_TYPE_INT16: {
value_set_int16(v, *(int16_t*)p);
return RET_OK;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(v, *(uint16_t*)p);
return RET_OK;
}
case VALUE_TYPE_INT32: {
value_set_int32(v, *(int32_t*)p);
return RET_OK;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(v, *(uint32_t*)p);
return RET_OK;
}
case VALUE_TYPE_INT64: {
value_set_int64(v, *(int64_t*)p);
return RET_OK;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(v, *(uint64_t*)p);
return RET_OK;
}
case VALUE_TYPE_FLOAT: {
value_set_float(v, *(float_t*)p);
return RET_OK;
}
case VALUE_TYPE_FLOAT32: {
value_set_float32(v, *(float*)p);
return RET_OK;
}
case VALUE_TYPE_DOUBLE: {
value_set_double(v, *(double*)p);
return RET_OK;
}
default: {
assert(!"not supported type");
return RET_NOT_IMPL;
}
}
}
ret_t typed_array_set(typed_array_t* typed_array, uint32_t index, const value_t* v) {
uint8_t* p = NULL;
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(typed_array->data != NULL && index < typed_array->size, RET_BAD_PARAMS);
p = typed_array->data + index * typed_array->element_size;
switch (typed_array->type) {
case VALUE_TYPE_BOOL: {
*(bool_t*)p = value_bool(v);
return RET_OK;
}
case VALUE_TYPE_INT8: {
*(int8_t*)p = value_int8(v);
return RET_OK;
}
case VALUE_TYPE_UINT8: {
*(uint8_t*)p = value_uint8(v);
return RET_OK;
}
case VALUE_TYPE_INT16: {
*(int16_t*)p = value_int16(v);
return RET_OK;
}
case VALUE_TYPE_UINT16: {
*(uint16_t*)p = value_uint16(v);
return RET_OK;
}
case VALUE_TYPE_INT32: {
*(int32_t*)p = value_int32(v);
return RET_OK;
}
case VALUE_TYPE_UINT32: {
*(uint32_t*)p = value_uint32(v);
return RET_OK;
}
case VALUE_TYPE_INT64: {
*(int64_t*)p = value_int64(v);
return RET_OK;
}
case VALUE_TYPE_UINT64: {
*(uint64_t*)p = value_uint64(v);
return RET_OK;
}
case VALUE_TYPE_FLOAT: {
*(float_t*)p = value_float(v);
return RET_OK;
}
case VALUE_TYPE_FLOAT32: {
*(float*)p = value_float32(v);
return RET_OK;
}
case VALUE_TYPE_DOUBLE: {
*(double*)p = value_double(v);
return RET_OK;
}
default: {
assert(!"not supported type");
return RET_NOT_IMPL;
}
}
}
ret_t typed_array_extend(typed_array_t* typed_array, uint32_t capacity) {
return_value_if_fail(typed_array != NULL, RET_BAD_PARAMS);
if (capacity > typed_array->capacity) {
uint8_t* p = NULL;
uint32_t mem_size = (capacity + 1) * typed_array->element_size;
uint32_t data_size = typed_array->element_size * typed_array->size;
uint8_t* data = (uint8_t*)TKMEM_REALLOC(typed_array->data, mem_size);
return_value_if_fail(data != NULL, RET_OOM);
ENSURE(((uintptr_t)data % 8) == 0);
typed_array->data = data;
typed_array->capacity = capacity;
p = data + data_size;
memset(p, 0x00, mem_size - data_size);
}
return RET_OK;
}
static ret_t typed_array_extend_delta(typed_array_t* typed_array, uint32_t delta) {
return_value_if_fail(typed_array != NULL, RET_BAD_PARAMS);
if ((typed_array->size + delta) > typed_array->capacity) {
uint32_t capacity = (typed_array->size + delta) + 1.2F;
return typed_array_extend(typed_array, capacity);
}
return RET_OK;
}
ret_t typed_array_insert(typed_array_t* typed_array, uint32_t index, const value_t* v) {
uint8_t* p = NULL;
uint8_t* s = NULL;
uint8_t* d = NULL;
uint32_t element_size = 0;
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
index = tk_min(index, typed_array->size);
return_value_if_fail(typed_array_extend_delta(typed_array, 1) == RET_OK, RET_OOM);
element_size = typed_array->element_size;
p = typed_array->data + index * element_size;
d = typed_array->data + element_size * typed_array->size;
s = d - element_size;
while (s >= p) {
memcpy(d, s, element_size);
s -= element_size;
d -= element_size;
}
typed_array->size++;
return typed_array_set(typed_array, index, v);
}
ret_t typed_array_remove(typed_array_t* typed_array, uint32_t index) {
uint8_t* p = NULL;
uint8_t* s = NULL;
uint8_t* d = NULL;
uint32_t element_size = 0;
return_value_if_fail(typed_array != NULL, RET_BAD_PARAMS);
return_value_if_fail(typed_array->data != NULL && index < typed_array->size, RET_BAD_PARAMS);
element_size = typed_array->element_size;
d = typed_array->data + index * element_size;
s = d + element_size;
p = typed_array->data + element_size * typed_array->size;
while (s < p) {
memcpy(d, s, element_size);
s += element_size;
d += element_size;
}
typed_array->size--;
return RET_OK;
}
ret_t typed_array_pop(typed_array_t* typed_array, value_t* v) {
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(typed_array->size > 0, RET_BAD_PARAMS);
typed_array_get(typed_array, typed_array->size - 1, v);
typed_array->size--;
return RET_OK;
}
ret_t typed_array_tail(typed_array_t* typed_array, value_t* v) {
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(typed_array->size > 0, RET_BAD_PARAMS);
return typed_array_get(typed_array, typed_array->size - 1, v);
}
ret_t typed_array_push(typed_array_t* typed_array, const value_t* v) {
return_value_if_fail(typed_array != NULL && v != NULL, RET_BAD_PARAMS);
return typed_array_insert(typed_array, typed_array->size, v);
}
ret_t typed_array_clear(typed_array_t* typed_array) {
return_value_if_fail(typed_array != NULL, RET_BAD_PARAMS);
typed_array->size = 0;
return RET_OK;
}
ret_t typed_array_destroy(typed_array_t* typed_array) {
return_value_if_fail(typed_array != NULL, RET_BAD_PARAMS);
typed_array_clear(typed_array);
TKMEM_FREE(typed_array->data);
memset(typed_array, 0x00, sizeof(typed_array_t));
TKMEM_FREE(typed_array);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_wbuffer.c
|
/**
* File: object_wbuffer.c
* Author: AWTK Develop Team
* Brief: wrap wbuffer to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "object_wbuffer.h"
static ret_t object_wbuffer_on_destroy(tk_object_t* obj) {
object_wbuffer_t* o = OBJECT_WBUFFER(obj);
return_value_if_fail(o != NULL && o->wbuffer != NULL, RET_BAD_PARAMS);
wbuffer_deinit(o->wbuffer);
o->wbuffer = NULL;
return RET_OK;
}
static ret_t object_wbuffer_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
return RET_NOT_FOUND;
}
static ret_t object_wbuffer_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_wbuffer_t* o = OBJECT_WBUFFER(obj);
return_value_if_fail(o != NULL && o->wbuffer != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, "cursor")) {
value_set_uint32(v, o->wbuffer->cursor);
ret = RET_OK;
} else if (tk_str_eq(name, "capacity")) {
value_set_uint32(v, o->wbuffer->capacity);
ret = RET_OK;
} else if (tk_str_eq(name, "data")) {
value_set_pointer(v, o->wbuffer->data);
ret = RET_OK;
}
return ret;
}
static const object_vtable_t s_object_wbuffer_vtable = {.type = OBJECT_WBUFFER_TYPE,
.desc = OBJECT_WBUFFER_TYPE,
.size = sizeof(object_wbuffer_t),
.is_collection = FALSE,
.on_destroy = object_wbuffer_on_destroy,
.get_prop = object_wbuffer_get_prop,
.set_prop = object_wbuffer_set_prop};
tk_object_t* object_wbuffer_create_ex(bool_t extendable, uint8_t* data, uint32_t capacity) {
tk_object_t* o = NULL;
object_wbuffer_t* wrapper = NULL;
o = tk_object_create(&s_object_wbuffer_vtable);
return_value_if_fail(o != NULL, NULL);
wrapper = OBJECT_WBUFFER(o);
return_value_if_fail(wrapper != NULL, NULL);
if (extendable) {
wrapper->wbuffer = wbuffer_init_extendable(&(wrapper->awbuffer));
} else {
wrapper->wbuffer = wbuffer_init(&(wrapper->awbuffer), data, capacity);
}
return o;
}
tk_object_t* object_wbuffer_create(uint8_t* data, uint32_t capacity) {
return_value_if_fail(data != NULL, NULL);
return object_wbuffer_create_ex(FALSE, data, capacity);
}
tk_object_t* object_wbuffer_create_extendable(void) {
return object_wbuffer_create_ex(TRUE, NULL, 0);
}
object_wbuffer_t* object_wbuffer_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_wbuffer_vtable, NULL);
return (object_wbuffer_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_typed_array.c
|
/**
* File: object_typed_array.c
* Author: AWTK Develop Team
* Brief: wrap typed array to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "object_typed_array.h"
static ret_t object_typed_array_on_destroy(tk_object_t* obj) {
object_typed_array_t* o = OBJECT_TYPED_ARRAY(obj);
return_value_if_fail(o != NULL && o->arr != NULL, RET_BAD_PARAMS);
typed_array_destroy(o->arr);
o->arr = NULL;
return RET_OK;
}
static ret_t object_typed_array_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
object_typed_array_t* o = OBJECT_TYPED_ARRAY(obj);
return_value_if_fail(o != NULL && o->arr != NULL, RET_BAD_PARAMS);
if (*name == '[') {
int32_t index = tk_atoi(name + 1);
return typed_array_set(o->arr, index, v);
}
return RET_NOT_FOUND;
}
static ret_t object_typed_array_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_typed_array_t* o = OBJECT_TYPED_ARRAY(obj);
return_value_if_fail(o != NULL && o->arr != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, "size") || tk_str_eq(name, TK_OBJECT_PROP_SIZE)) {
value_set_uint32(v, o->arr->size);
ret = RET_OK;
} else if (tk_str_eq(name, "capacity")) {
value_set_uint32(v, o->arr->capacity);
ret = RET_OK;
} else if (tk_str_eq(name, "bytes") || tk_str_eq(name, "size_in_bytes")) {
value_set_uint32(v, o->arr->size * o->arr->element_size);
ret = RET_OK;
} else if (tk_str_eq(name, "capacity_in_bytes")) {
value_set_uint32(v, o->arr->capacity * o->arr->element_size);
ret = RET_OK;
} else if (tk_str_eq(name, "data")) {
value_set_pointer(v, o->arr->data);
ret = RET_OK;
} else if (*name == '[') {
int32_t index = tk_atoi(name + 1);
ret = typed_array_get(o->arr, index, v);
}
return ret;
}
static const object_vtable_t s_object_typed_array_vtable = {
.type = OBJECT_TYPED_ARRAY_TYPE,
.desc = OBJECT_TYPED_ARRAY_TYPE,
.size = sizeof(object_typed_array_t),
.is_collection = FALSE,
.on_destroy = object_typed_array_on_destroy,
.get_prop = object_typed_array_get_prop,
.set_prop = object_typed_array_set_prop};
tk_object_t* object_typed_array_create(value_type_t type, uint32_t capacity) {
tk_object_t* o = NULL;
object_typed_array_t* wrapper = NULL;
o = tk_object_create(&s_object_typed_array_vtable);
return_value_if_fail(o != NULL, NULL);
wrapper = OBJECT_TYPED_ARRAY(o);
return_value_if_fail(wrapper != NULL, NULL);
wrapper->arr = typed_array_create(type, capacity);
if (wrapper->arr == NULL) {
TK_OBJECT_UNREF(o);
}
return o;
}
object_typed_array_t* object_typed_array_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_typed_array_vtable, NULL);
return (object_typed_array_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_composite.h
|
/**
* File: mem_allocator_composite.h
* Author: AWTK Develop Team
* Brief: mem_allocator_composite
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-04-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_COMPOSITE_H
#define TK_MEM_ALLOCATOR_COMPOSITE_H
#include "tkc/mutex.h"
#include "tkc/mem_allocator_simple.h"
BEGIN_C_DECLS
/*最多支持的内存块数目*/
#ifndef TK_MAX_MEM_BLOCK_NR
#define TK_MAX_MEM_BLOCK_NR 1
#endif /*TK_MAX_MEM_BLOCK_NR*/
/**
* @class mem_allocator_composite_t
* @parent mem_allocator_t
*
* 支持多个不连续的内存块。
*
*/
typedef struct _mem_allocator_composite_t {
mem_allocator_t allocator;
mem_allocator_simple_t allocators[TK_MAX_MEM_BLOCK_NR];
} mem_allocator_composite_t;
#define MEM_ALLOCATOR_COMPOSITE(allocator) ((mem_allocator_composite_t*)(allocator))
static inline void* mem_allocator_composite_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
uint32_t i = 0;
void* addr = NULL;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_is_valid(iter)) {
addr = mem_allocator_alloc(iter, size, func, line);
if (addr != NULL) {
return addr;
}
}
}
return NULL;
}
static inline bool_t mem_allocator_composite_is_valid_addr(mem_allocator_t* allocator, void* ptr) {
uint32_t i = 0;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_contains(iter, ptr)) {
return TRUE;
}
}
return FALSE;
}
static inline void mem_allocator_composite_free(mem_allocator_t* allocator, void* ptr) {
uint32_t i = 0;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_contains(iter, ptr)) {
mem_allocator_free(iter, ptr);
break;
}
}
return;
}
static inline void* mem_allocator_composite_realloc(mem_allocator_t* allocator, void* ptr,
uint32_t size, const char* func,
uint32_t line) {
uint32_t i = 0;
void* addr = NULL;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
if (ptr == NULL) {
return mem_allocator_composite_alloc(allocator, size, func, line);
}
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_contains(iter, ptr)) {
addr = mem_allocator_realloc(iter, ptr, size, func, line);
if (addr == NULL) {
uint32_t old_size = mem_allocator_simple_get_mem_size(iter, ptr);
addr = mem_allocator_composite_alloc(allocator, size, func, line);
if (addr != NULL) {
uint32_t data_size = tk_min(old_size, size);
memcpy(addr, ptr, data_size);
mem_allocator_simple_free(iter, ptr);
}
}
break;
}
}
return addr;
}
static inline ret_t mem_allocator_composite_dump(mem_allocator_t* allocator) {
uint32_t i = 0;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_is_valid(iter)) {
mem_allocator_dump(iter);
}
}
return RET_OK;
}
static inline ret_t mem_allocator_composite_destroy(mem_allocator_t* allocator) {
uint32_t i = 0;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (mem_allocator_simple_is_valid(iter)) {
mem_allocator_destroy(iter);
}
}
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_composite_vtable = {
.alloc = mem_allocator_composite_alloc,
.realloc = mem_allocator_composite_realloc,
.free = mem_allocator_composite_free,
.dump = mem_allocator_composite_dump,
.destroy = mem_allocator_composite_destroy};
static inline ret_t mem_allocator_composite_add_mem(mem_allocator_t* allocator, char* addr,
uint32_t size) {
uint32_t i = 0;
mem_allocator_composite_t* impl = MEM_ALLOCATOR_COMPOSITE(allocator);
for (i = 0; i < ARRAY_SIZE(impl->allocators); i++) {
mem_allocator_t* iter = MEM_ALLOCATOR(impl->allocators + i);
if (!mem_allocator_simple_is_valid(iter)) {
mem_allocator_simple_init(MEM_ALLOCATOR_SIMPLE(iter), addr, size);
log_debug("add mem block %p %u\n", addr, size);
return RET_OK;
}
}
log_warn("no space to add mem, please increase TK_MAX_MEM_BLOCK_NR\n");
return RET_BAD_PARAMS;
}
static inline mem_allocator_t* mem_allocator_composite_init_va(mem_allocator_composite_t* composite,
void* buffer, uint32_t size,
va_list va) {
char* p = NULL;
mem_allocator_t* allocator = MEM_ALLOCATOR(composite);
return_value_if_fail(composite != NULL, NULL);
memset(composite, 0x00, sizeof(*composite));
allocator->vt = &s_mem_allocator_composite_vtable;
ENSURE(mem_allocator_composite_add_mem(allocator, buffer, size) == RET_OK);
do {
p = va_arg(va, char*);
if (p != NULL) {
uint32_t s = va_arg(va, uint32_t);
ENSURE(mem_allocator_composite_add_mem(allocator, p, s) == RET_OK);
}
} while (p != NULL);
return allocator;
}
static inline mem_allocator_t* mem_allocator_composite_init(mem_allocator_composite_t* composite,
void* buffer, uint32_t size, ...) {
va_list va;
mem_allocator_t* ret = NULL;
va_start(va, size);
ret = mem_allocator_composite_init_va(composite, buffer, size, va);
va_end(va);
return ret;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_COMPOSITE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mutex_nest.c
|
/**
* File: mutex_nest.c
* Author: AWTK Develop Team
* Brief: mutex recursive
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-24 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/thread.h"
#include "tkc/mutex_nest.h"
tk_mutex_nest_t* tk_mutex_nest_create(void) {
tk_mutex_nest_t* r = NULL;
tk_mutex_t* mutex = tk_mutex_create();
return_value_if_fail(mutex != NULL, NULL);
r = TKMEM_ZALLOC(tk_mutex_nest_t);
if (r != NULL) {
r->mutex = mutex;
} else {
tk_mutex_destroy(mutex);
}
return r;
}
ret_t tk_mutex_nest_lock(tk_mutex_nest_t* mutex_nest) {
ret_t ret = RET_OK;
return_value_if_fail(mutex_nest != NULL && mutex_nest->mutex != NULL, RET_BAD_PARAMS);
if (mutex_nest->owner == tk_thread_self()) {
mutex_nest->ref++;
} else {
if (tk_mutex_lock(mutex_nest->mutex) == RET_OK) {
mutex_nest->ref = 1;
mutex_nest->owner = tk_thread_self();
} else {
ret = RET_FAIL;
}
}
return ret;
}
ret_t tk_mutex_nest_try_lock(tk_mutex_nest_t* mutex_nest) {
ret_t ret = RET_OK;
return_value_if_fail(mutex_nest != NULL && mutex_nest->mutex != NULL, RET_BAD_PARAMS);
if (mutex_nest->owner == tk_thread_self()) {
mutex_nest->ref++;
} else {
if (tk_mutex_try_lock(mutex_nest->mutex) == RET_OK) {
mutex_nest->ref = 1;
mutex_nest->owner = tk_thread_self();
} else {
ret = RET_FAIL;
}
}
return ret;
}
ret_t tk_mutex_nest_unlock(tk_mutex_nest_t* mutex_nest) {
ret_t ret = RET_OK;
return_value_if_fail(mutex_nest != NULL && mutex_nest->mutex != NULL, RET_BAD_PARAMS);
if (mutex_nest->owner == tk_thread_self()) {
mutex_nest->ref--;
assert(mutex_nest->ref >= 0);
if (mutex_nest->ref == 0) {
mutex_nest->owner = 0;
ret = tk_mutex_unlock(mutex_nest->mutex);
}
} else {
log_debug("not mutex owner\n");
}
return ret;
}
ret_t tk_mutex_nest_destroy(tk_mutex_nest_t* mutex_nest) {
return_value_if_fail(mutex_nest != NULL && mutex_nest->mutex != NULL, RET_BAD_PARAMS);
tk_mutex_destroy(mutex_nest->mutex);
memset(mutex_nest, 0x00, sizeof(tk_mutex_nest_t));
TKMEM_FREE(mutex_nest);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_file.c
|
/**
* File: data_reader.c
* Author: AWTK Develop Team
* Brief: data_reader
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-26 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/fs.h"
#include "tkc/data_reader_file.h"
typedef struct _data_reader_file_t {
data_reader_t data_reader;
fs_file_t* file;
uint64_t size;
} data_reader_file_t;
static int32_t data_reader_file_read(data_reader_t* reader, uint64_t offset, void* data,
uint32_t size) {
data_reader_file_t* file = (data_reader_file_t*)reader;
return_value_if_fail(fs_file_seek(file->file, offset) == RET_OK, 0);
return fs_file_read(file->file, data, size);
}
static uint64_t data_reader_file_get_size(data_reader_t* reader) {
data_reader_file_t* file = (data_reader_file_t*)reader;
return file->size;
}
static ret_t data_reader_file_destroy(data_reader_t* reader) {
data_reader_file_t* file = (data_reader_file_t*)reader;
fs_file_close(file->file);
TKMEM_FREE(file);
return RET_OK;
}
static const data_reader_vtable_t s_data_reader_file_vtable = {
.read = data_reader_file_read,
.get_size = data_reader_file_get_size,
.destroy = data_reader_file_destroy,
};
data_reader_t* data_reader_file_create(const char* filename) {
fs_stat_info_t st;
const char* p = NULL;
data_reader_file_t* file = NULL;
return_value_if_fail(filename != NULL, NULL);
file = TKMEM_ZALLOC(data_reader_file_t);
return_value_if_fail(file != NULL, NULL);
p = strstr(filename, "://");
if (p != NULL) {
p += 3;
filename = p;
}
if (fs_stat(os_fs(), filename, &st) == RET_OK) {
file->size = st.size;
file->file = fs_open_file(os_fs(), filename, "rb");
file->data_reader.vt = &s_data_reader_file_vtable;
}
if (file->file == NULL) {
TKMEM_FREE(file);
}
return (data_reader_t*)file;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object.h
|
/**
* File: object.h
* Author: AWTK Develop Team
* Brief: reference count object
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-09 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_H
#define TK_OBJECT_H
#include "tkc/str.h"
#include "tkc/darray.h"
#include "tkc/emitter.h"
BEGIN_C_DECLS
struct _tk_object_vtable_t;
typedef struct _tk_object_vtable_t object_vtable_t;
typedef ret_t (*tk_object_on_destroy_t)(tk_object_t* obj);
typedef int32_t (*tk_object_compare_t)(tk_object_t* obj, tk_object_t* other);
typedef ret_t (*tk_object_remove_prop_t)(tk_object_t* obj, const char* name);
typedef ret_t (*tk_object_get_prop_t)(tk_object_t* obj, const char* name, value_t* v);
typedef ret_t (*tk_object_foreach_prop_t)(tk_object_t* obj, tk_visit_t on_prop, void* ctx);
typedef ret_t (*tk_object_set_prop_t)(tk_object_t* obj, const char* name, const value_t* v);
typedef ret_t (*tk_object_clear_props_t)(tk_object_t* obj);
typedef value_t* (*tk_object_find_prop_t)(tk_object_t* obj, tk_compare_t cmp, const void* ctx);
typedef ret_t (*tk_object_find_props_t)(tk_object_t* obj, tk_compare_t cmp, const void* ctx,
darray_t* matched);
typedef bool_t (*tk_object_can_exec_t)(tk_object_t* obj, const char* name, const char* args);
typedef ret_t (*tk_object_exec_t)(tk_object_t* obj, const char* name, const char* args);
typedef tk_object_t* (*tk_object_clone_t)(tk_object_t* obj);
struct _tk_object_vtable_t {
const char* type;
const char* desc;
uint32_t size : 28;
uint32_t is_collection : 1;
tk_object_on_destroy_t on_destroy;
tk_object_compare_t compare;
tk_object_get_prop_t get_prop;
tk_object_set_prop_t set_prop;
tk_object_remove_prop_t remove_prop;
tk_object_foreach_prop_t foreach_prop;
tk_object_clear_props_t clear_props;
tk_object_find_prop_t find_prop;
tk_object_find_props_t find_props;
tk_object_can_exec_t can_exec;
tk_object_exec_t exec;
tk_object_clone_t clone;
};
/**
* @class tk_object_t
* @order -9
* @parent emitter_t
* @annotation ["scriptable"]
*
* 对象接口。
*
*/
struct _tk_object_t {
emitter_t emitter;
/**
* @property {int32_t} ref_count
* @annotation ["readable", "scriptable"]
* 引用计数。
*/
int32_t ref_count;
/**
* @property {char*} name
* @annotation ["readable", "scriptable"]
* 对象的名称。
*/
char* name;
/*private*/
const object_vtable_t* vt;
uint32_t visiting;
};
/**
* @method tk_object_unref
* 引用计数减1。引用计数为0时，销毁对象。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {tk_object_t*} obj object对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_unref(tk_object_t* obj);
/**
* @method tk_object_ref
* 引用计数加1。
*
* @annotation ["constructor", "scriptable", "gc"]
* @param {tk_object_t*} obj object对象。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* tk_object_ref(tk_object_t* obj);
/**
* @method tk_object_clone
* clone对象。
*
* @annotation ["constructor"]
* @param {tk_object_t*} obj object对象。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* tk_object_clone(tk_object_t* obj);
/**
* @method tk_object_create
* 创建对象。
*
* > 仅供子类调用。
*
* @param {const object_vtable_t*} vt 虚函数表。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* tk_object_create(const object_vtable_t* vt);
/**
* @method tk_object_create_ex
* 创建对象。
*
* > 仅供子类调用。
*
* @param {const object_vtable_t*} vt 虚函数表。
* @param {uint32_t} extra_data_size 额外的内存大小。
*
* @return {tk_object_t*} 返回object对象。
*/
tk_object_t* tk_object_create_ex(const object_vtable_t* vt, uint32_t extra_data_size);
/**
* @method tk_object_get_type
* 获取对象的类型名称。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
*
* @return {const char*} 返回对象的类型名称。
*/
const char* tk_object_get_type(tk_object_t* obj);
/**
* @method tk_object_get_desc
* 获取对象的描述信息。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
*
* @return {const char*} 返回对象的描述信息。
*/
const char* tk_object_get_desc(tk_object_t* obj);
/**
* @method tk_object_get_size
* 获取对象占用内存的大小。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
*
* @return {uint32_t} 返回对象占用内存的大小。
*/
uint32_t tk_object_get_size(tk_object_t* obj);
/**
* @method tk_object_is_collection
* 判断对象是否是集合。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
*
* @return {bool_t} 返回TRUE表示是集合，否则不是。
*/
bool_t tk_object_is_collection(tk_object_t* obj);
/**
* @method tk_object_set_name
* 设置对象的名称。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 对象的名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_name(tk_object_t* obj, const char* name);
/**
* @method tk_object_compare
* 比较两个对象。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {tk_object_t*} other 比较的object对象。
*
* @return {int} 返回比较结果。
*/
int tk_object_compare(tk_object_t* obj, tk_object_t* other);
/**
* @method tk_object_get_prop
* 获取指定属性的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {value_t*} v 返回属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_get_prop(tk_object_t* obj, const char* name, value_t* v);
/**
* @method tk_object_get_prop_str
* 获取指定属性的字符串类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
*
* @return {const char*} 返回指定属性的字符串类型的值。
*/
const char* tk_object_get_prop_str(tk_object_t* obj, const char* name);
/**
* @method tk_object_get_prop_pointer
* 获取指定属性的指针类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
*
* @return {void*} 返回指定属性的指针类型的值。
*/
void* tk_object_get_prop_pointer(tk_object_t* obj, const char* name);
/**
* @method tk_object_get_prop_object
* 获取指定属性的object类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
*
* @return {tk_object_t*} 返回指定属性的object类型的值。
*/
tk_object_t* tk_object_get_prop_object(tk_object_t* obj, const char* name);
/**
* @method tk_object_get_prop_int
* 获取指定属性的整数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int32_t} defval 缺省值。
*
* @return {int32_t} 返回指定属性的整数类型的值。
*/
int32_t tk_object_get_prop_int(tk_object_t* obj, const char* name, int32_t defval);
/**
* @method tk_object_get_prop_bool
* 获取指定属性的bool类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {bool_t} defval 缺省值。
*
* @return {bool_t} 返回指定属性的bool类型的值。
*/
bool_t tk_object_get_prop_bool(tk_object_t* obj, const char* name, bool_t defval);
/**
* @method tk_object_get_prop_float
* 获取指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {float_t} defval 缺省值。
*
* @return {float_t} 返回指定属性的浮点数类型的值。
*/
float_t tk_object_get_prop_float(tk_object_t* obj, const char* name, float_t defval);
/**
* @method tk_object_get_prop_double
* 获取指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {double} defval 缺省值。
*
* @return {double} 返回指定属性的浮点数类型的值。
*/
double tk_object_get_prop_double(tk_object_t* obj, const char* name, double defval);
/**
* @method tk_object_remove_prop
* 删除指定属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_remove_prop(tk_object_t* obj, const char* name);
/**
* @method tk_object_set_prop
* 设置指定属性的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {const value_t*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop(tk_object_t* obj, const char* name, const value_t* value);
/**
* @method tk_object_set_prop_str
* 设置指定属性的字符串类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {const char*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_str(tk_object_t* obj, const char* name, const char* value);
/**
* @method tk_object_set_prop_str_with_format
* 设置指定属性的字符串类型的值。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {const char*} format 格式字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_str_with_format(tk_object_t* obj, const char* name, const char* format,
...);
/**
* @method tk_object_set_prop_pointer
* 设置指定属性的指针类型的值。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {void*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_pointer(tk_object_t* obj, const char* name, void* value);
/**
* @method tk_object_set_prop_pointer_ex
* 设置指定属性的指针类型的值。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {void*} value 属性的值。
* @param {tk_destroy_t} destroy 销毁函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_pointer_ex(tk_object_t* obj, const char* name, void* value,
tk_destroy_t destroy);
/**
* @method tk_object_set_prop_object
* 设置指定属性的object类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {tk_object_t*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_object(tk_object_t* obj, const char* name, tk_object_t* value);
/**
* @method tk_object_set_prop_int
* 设置指定属性的整数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int32_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int(tk_object_t* obj, const char* name, int32_t value);
/**
* @method tk_object_set_prop_bool
* 设置指定属性的bool类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {bool_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_bool(tk_object_t* obj, const char* name, bool_t value);
/**
* @method tk_object_set_prop_float
* 设置指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {float_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_float(tk_object_t* obj, const char* name, float_t value);
/**
* @method tk_object_set_prop_double
* 设置指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {double} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_double(tk_object_t* obj, const char* name, double value);
/**
* @method tk_object_copy_prop
* 拷贝指定的属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 目标对象。
* @param {tk_object_t*} src 源对象。
* @param {const char*} name 属性的名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_copy_prop(tk_object_t* obj, tk_object_t* src, const char* name);
/**
* @method tk_object_copy_props
* 拷贝全部的属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 目标对象。
* @param {tk_object_t*} src 源对象。
* @param {bool_t} overwrite 如果属性存在是否覆盖。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_copy_props(tk_object_t* obj, tk_object_t* src, bool_t overwrite);
/**
* @method tk_object_foreach_prop
* 遍历所有属性。
*
* @param {tk_object_t*} obj object对象。
* @param {tk_visit_t} on_prop 回调函数(data参数为named_value_t类型)。
* @param {void*} ctx 回调函数上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx);
/**
* @method tk_object_has_prop
* 检查是否存在指定的属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t tk_object_has_prop(tk_object_t* obj, const char* name);
/**
* @method tk_object_eval
* 计算一个表达式，表达式中引用的变量从prop中获取。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} expr 表达式。
* @param {value_t*} v 返回计算结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_eval(tk_object_t* obj, const char* expr, value_t* v);
/**
* @method tk_object_can_exec
* 检查是否可以执行指定的命令。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 命令的名称。
* @param {const char*} args 命令的参数。
*
* @return {bool_t} 返回TRUE表示可以执行，否则表示不可以执行。
*/
bool_t tk_object_can_exec(tk_object_t* obj, const char* name, const char* args);
/**
* @method tk_object_exec
* 执行指定的命令。
*
* @alias execute
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 命令的名称。
* @param {const char*} args 命令的参数。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_exec(tk_object_t* obj, const char* name, const char* args);
/**
* @method tk_object_notify_changed
* 触发EVT_PROPS_CHANGED事件。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_notify_changed(tk_object_t* obj);
/**
* @method tk_object_has_prop_by_path
* 检查是否存在指定的属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path，各级之间用.分隔。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t tk_object_has_prop_by_path(tk_object_t* obj, const char* path);
/**
* @method tk_object_get_prop_by_path
* 获取指定path属性的值。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path，各级之间用.分隔。
* @param {value_t*} v 返回属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_get_prop_by_path(tk_object_t* obj, const char* path, value_t* v);
/**
* @method tk_object_get_prop_str_by_path
* 获取指定属性的字符串类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
*
* @return {const char*} 返回指定属性的字符串类型的值。
*/
const char* tk_object_get_prop_str_by_path(tk_object_t* obj, const char* path);
/**
* @method tk_object_get_prop_pointer_by_path
* 获取指定属性的指针类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
*
* @return {void*} 返回指定属性的指针类型的值。
*/
void* tk_object_get_prop_pointer_by_path(tk_object_t* obj, const char* path);
/**
* @method tk_object_get_prop_object_by_path
* 获取指定属性的object类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
*
* @return {tk_object_t*} 返回指定属性的object类型的值。
*/
tk_object_t* tk_object_get_prop_object_by_path(tk_object_t* obj, const char* path);
/**
* @method tk_object_get_prop_int_by_path
* 获取指定属性的整数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {int32_t} defval 缺省值。
*
* @return {int32_t} 返回指定属性的整数类型的值。
*/
int32_t tk_object_get_prop_int_by_path(tk_object_t* obj, const char* path, int32_t defval);
/**
* @method tk_object_get_prop_bool_by_path
* 获取指定属性的bool类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {bool_t} defval 缺省值。
*
* @return {bool_t} 返回指定属性的bool类型的值。
*/
bool_t tk_object_get_prop_bool_by_path(tk_object_t* obj, const char* path, bool_t defval);
/**
* @method tk_object_get_prop_float_by_path
* 获取指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {float_t} defval 缺省值。
e
* @return {float_t} 返回指定属性的浮点数类型的值。
*/
float_t tk_object_get_prop_float_by_path(tk_object_t* obj, const char* path, float_t defval);
/**
* @method tk_object_set_prop_by_path
* 设置指定属性的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {const value_t*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_by_path(tk_object_t* obj, const char* path, const value_t* value);
/**
* @method tk_object_set_prop_str_by_path
* 设置指定属性的字符串类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {const char*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_str_by_path(tk_object_t* obj, const char* path, const char* value);
/**
* @method tk_object_set_prop_pointer_by_path
* 设置指定属性的指针类型的值。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {void*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_pointer_by_path(tk_object_t* obj, const char* path, void* value);
/**
* @method tk_object_set_prop_object_by_path
* 设置指定属性的object类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {tk_object_t*} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_object_by_path(tk_object_t* obj, const char* path, tk_object_t* value);
/**
* @method tk_object_set_prop_int_by_path
* 设置指定属性的整数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {int32_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int_by_path(tk_object_t* obj, const char* path, int32_t value);
/**
* @method tk_object_set_prop_bool_by_path
* 设置指定属性的bool类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {bool_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_bool_by_path(tk_object_t* obj, const char* path, bool_t value);
/**
* @method tk_object_set_prop_float_by_path
* 设置指定属性的浮点数类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性的path。
* @param {float_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_float_by_path(tk_object_t* obj, const char* path, float_t value);
/**
* @method tk_object_can_exec_by_path
* 检查是否可以执行指定的命令。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 命令的path。
* @param {const char*} args 命令的参数。
*
* @return {bool_t} 返回TRUE表示可以执行，否则表示不可以执行。
*/
bool_t tk_object_can_exec_by_path(tk_object_t* obj, const char* path, const char* args);
/**
* @method tk_object_exec_by_path
* 执行指定的命令。
*
* @alias execute_by_path
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 命令的path。
* @param {const char*} args 命令的参数。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_exec_by_path(tk_object_t* obj, const char* path, const char* args);
/**
* @method tk_object_get_prop_int8
* 获取指定属性的int8类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int8_t} defval 缺省值。
*
* @return {int8_t} 返回指定属性的int8类型的值。
*/
int8_t tk_object_get_prop_int8(tk_object_t* obj, const char* name, int8_t defval);
/**
* @method tk_object_set_prop_int8
* 设置指定属性的int8类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int8_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int8(tk_object_t* obj, const char* name, int8_t value);
/**
* @method tk_object_get_prop_uint8
* 获取指定属性的uint8类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint8_t} defval 缺省值。
*
* @return {uint8_t} 返回指定属性的uint8类型的值。
*/
uint8_t tk_object_get_prop_uint8(tk_object_t* obj, const char* name, uint8_t defval);
/**
* @method tk_object_set_prop_uint8
* 设置指定属性的uint8类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint8_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_uint8(tk_object_t* obj, const char* name, uint8_t value);
/**
* @method tk_object_get_prop_int16
* 获取指定属性的int16类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int16_t} defval 缺省值。
*
* @return {int16_t} 返回指定属性的int16类型的值。
*/
int16_t tk_object_get_prop_int16(tk_object_t* obj, const char* name, int16_t defval);
/**
* @method tk_object_set_prop_int16
* 设置指定属性的int16类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int16_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int16(tk_object_t* obj, const char* name, int16_t value);
/**
* @method tk_object_get_prop_uint16
* 获取指定属性的uint16类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint16_t} defval 缺省值。
*
* @return {uint16_t} 返回指定属性的uint16类型的值。
*/
uint16_t tk_object_get_prop_uint16(tk_object_t* obj, const char* name, uint16_t defval);
/**
* @method tk_object_set_prop_uint16
* 设置指定属性的uint16类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint16_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_uint16(tk_object_t* obj, const char* name, uint16_t value);
/**
* @method tk_object_get_prop_int32
* 获取指定属性的int32类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int32_t} defval 缺省值。
*
* @return {int32_t} 返回指定属性的int32类型的值。
*/
int32_t tk_object_get_prop_int32(tk_object_t* obj, const char* name, int32_t defval);
/**
* @method tk_object_set_prop_int32
* 设置指定属性的int32类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int32_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int32(tk_object_t* obj, const char* name, int32_t value);
/**
* @method tk_object_get_prop_uint32
* 获取指定属性的uint32类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint32_t} defval 缺省值。
*
* @return {uint32_t} 返回指定属性的uint32类型的值。
*/
uint32_t tk_object_get_prop_uint32(tk_object_t* obj, const char* name, uint32_t defval);
/**
* @method tk_object_set_prop_uint32
* 设置指定属性的uint32类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint32_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_uint32(tk_object_t* obj, const char* name, uint32_t value);
/**
* @method tk_object_get_prop_int64
* 获取指定属性的int64类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int64_t} defval 缺省值。
*
* @return {int64_t} 返回指定属性的int64类型的值。
*/
int64_t tk_object_get_prop_int64(tk_object_t* obj, const char* name, int64_t defval);
/**
* @method tk_object_set_prop_int64
* 设置指定属性的int64类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {int64_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_int64(tk_object_t* obj, const char* name, int64_t value);
/**
* @method tk_object_get_prop_uint64
* 获取指定属性的uint64类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint64_t} defval 缺省值。
*
* @return {uint64_t} 返回指定属性的uint64类型的值。
*/
uint64_t tk_object_get_prop_uint64(tk_object_t* obj, const char* name, uint64_t defval);
/**
* @method tk_object_set_prop_uint64
* 设置指定属性的uint64类型的值。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj object对象。
* @param {const char*} name 属性的名称。
* @param {uint64_t} value 属性的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_set_prop_uint64(tk_object_t* obj, const char* name, uint64_t value);
/**
* @method tk_object_clear_props
* 清除全部属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_clear_props(tk_object_t* obj);
/**
* @method tk_object_find_prop
* 查找满足条件的属性，并返回它的值。
*
* @param {tk_object_t*} obj 对象。
* @param {tk_compare_t} cmp 比较函数。
* @param {const void*} data 要比较的数据。
*
* @return {value_t*} 返回属性的值。
*
*/
value_t* tk_object_find_prop(tk_object_t* obj, tk_compare_t cmp, const void* data);
/**
* @method tk_object_find_props
* 查找全部满足条件的属性。
*
* ```c
* darray_t matched;
* darray_init(&matched, 0, NULL, NULL);
* tk_object_find_props(obj, my_cmp, my_data, &matched);
* ...
* darray_deinit(&matched);
* ```
* @param {tk_object_t*} obj 对象。
* @param {tk_compare_t} cmp 比较函数。
* @param {const void*} data 要比较的数据。
* @param {darray_t*} matched 返回满足条件的属性。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_find_props(tk_object_t* obj, tk_compare_t cmp, const void* data, darray_t* matched);
/**
* @method tk_object_to_json
* 转换成JSON字符串。
*
* @param {tk_object_t*} obj object对象。
* @param {str_t*} json 返回JSON字符串。
* @param {uint32_t} indent 缩进空格数。
* @param {uint32_t} level 初始缩进层级。
* @param {bool_t} oneline 是否不换行。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_object_to_json(tk_object_t* obj, str_t* json, uint32_t indent, uint32_t level,
bool_t oneline);
/**
* @method tk_object_get_child_object
* 获取下一级子对象。
* > 属性路径之间使用符号"."分割，例如：name.sub_name。
*
* @param {tk_object_t*} obj object对象。
* @param {const char*} path 属性路径。
* @param {const char**} next_path 返回下一级属性路径。
*
* @return {tk_object_t*} 返回下一级子对象，如果找不到则返回 NULL。
*/
tk_object_t* tk_object_get_child_object(tk_object_t* obj, const char* path, const char** next_path);
/**
* @method tk_object_is_instance_of
* 检查对象是否是指定类型的实例。
* ```
* if(tk_object_is_instance_of(obj, OBJECT_ARRRAY_TYPE)) {
* }
* ```
* @param {tk_object_t*} obj object对象。
* @param {const char*} type 类型。
*
* @return {bool_t} 返回TRUE表示是指定类型的实例，否则表示不是。
*/
bool_t tk_object_is_instance_of(tk_object_t* obj, const char* type);
#define TK_OBJECT(obj) ((tk_object_t*)(obj))
#define TK_OBJECT_REF(obj) tk_object_ref((tk_object_t*)(obj))
#define TK_OBJECT_UNREF(obj) \
if ((obj) != NULL) { \
tk_object_unref((tk_object_t*)(obj)); \
(obj) = NULL; \
}
/**
* @enum object_cmd_t
* @annotation ["scriptable", "string"]
* @prefix TK_OBJECT_CMD_
* 对象常见命令定义
*/
/**
* @const TK_OBJECT_CMD_SAVE
* 保存命令
*/
#define TK_OBJECT_CMD_SAVE "save"
/**
* @const TK_OBJECT_CMD_RELOAD
* 重新加载命令
*/
#define TK_OBJECT_CMD_RELOAD "reload"
/**
* @const TK_OBJECT_CMD_MOVE_UP
* 和前一个属性交换位置
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_MOVE_UP "move_up"
/**
* @const TK_OBJECT_CMD_MOVE_DOWN
* 和后一个属性交换位置
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_MOVE_DOWN "move_down"
/**
* @const TK_OBJECT_CMD_REMOVE
* 删除属性。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_REMOVE "remove"
/**
* @const TK_OBJECT_CMD_REMOVE_CHECKED
* 删除勾选的属性。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_REMOVE_CHECKED "remove_checked"
/**
* @const TK_OBJECT_CMD_CLEAR
* 清除全部属性。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_CLEAR "clear"
/**
* @const TK_OBJECT_CMD_ADD
* 增加子项。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_ADD "add"
/**
* @const TK_OBJECT_CMD_DETAIL
* 显示对象详细信息。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_DETAIL "detail"
/**
* @const TK_OBJECT_CMD_EDIT
* 编辑子项。
*>参数为属性的名称或路径。
*/
#define TK_OBJECT_CMD_EDIT "edit"
/**
* @enum object_prop_t
* @annotation ["scriptable", "string"]
* @prefix OBJECT_PROP_
* 对象常见属性定义
*/
/**
* @const TK_OBJECT_PROP_SIZE
* 属性的个数。
*/
#define TK_OBJECT_PROP_SIZE "#size"
/**
* @const TK_OBJECT_PROP_CHECKED
* 属性是否勾选。
*/
#define TK_OBJECT_PROP_CHECKED "checked"
/**
* @const TK_OBJECT_PROP_SELECTED_INDEX
* 选中的索引。
*/
#define TK_OBJECT_PROP_SELECTED_INDEX "selected_index"
#include "tkc/object_compat.h"
END_C_DECLS
#endif /*TK_OBJECT_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/ostream.c
|
/**
* File: tk_ostream.h
* Author: AWTK Develop Team
* Brief: output stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/utils.h"
#include "tkc/platform.h"
#include "tkc/time_now.h"
#include "tkc/ostream.h"
int32_t tk_ostream_write(tk_ostream_t* stream, const void* buff, uint32_t max_size) {
return_value_if_fail(stream != NULL && stream->write != NULL, -1);
return_value_if_fail(buff != NULL, 0);
return stream->write(stream, (const uint8_t*)buff, max_size);
}
ret_t tk_ostream_seek(tk_ostream_t* stream, uint32_t offset) {
return_value_if_fail(stream != NULL, RET_BAD_PARAMS);
return_value_if_fail(stream->seek != NULL, RET_NOT_IMPL);
return stream->seek(stream, offset);
}
int32_t tk_ostream_write_len(tk_ostream_t* stream, const void* buff, uint32_t max_size,
uint32_t timeout_ms) {
uint32_t now = 0;
uint32_t end = 0;
int32_t offset = 0;
int32_t write_bytes = 0;
int32_t remain_bytes = max_size;
const uint8_t* p = (const uint8_t*)buff;
return_value_if_fail(stream != NULL && stream->write != NULL, -1);
return_value_if_fail(buff != NULL, 0);
now = time_now_ms();
end = now + timeout_ms;
do {
errno = 0;
write_bytes = tk_ostream_write(stream, p + offset, remain_bytes);
if (write_bytes <= 0) {
if (errno != EAGAIN) {
break;
} else {
sleep_ms(20);
log_debug("write: %d/%d\n", offset, max_size);
log_debug("write:again, sleep 20ms\n");
continue;
}
}
offset += write_bytes;
remain_bytes -= write_bytes;
if (remain_bytes == 0) {
break;
}
now = time_now_ms();
if (now > end) {
log_debug("write timeout\n");
break;
}
log_debug("write: %d/%d\n", offset, max_size);
} while (remain_bytes > 0);
return offset;
}
ret_t tk_ostream_flush(tk_ostream_t* stream) {
return_value_if_fail(stream != NULL, RET_BAD_PARAMS);
if (stream->flush != NULL) {
return stream->flush(stream);
}
return RET_OK;
}
ret_t tk_ostream_write_byte(tk_ostream_t* stream, uint8_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_uint8(tk_ostream_t* stream, uint8_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_uint16(tk_ostream_t* stream, uint16_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_uint32(tk_ostream_t* stream, uint32_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_uint64(tk_ostream_t* stream, uint64_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_int8(tk_ostream_t* stream, int8_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_int16(tk_ostream_t* stream, int16_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_int32(tk_ostream_t* stream, int32_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_int64(tk_ostream_t* stream, int64_t value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_float(tk_ostream_t* stream, float value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
ret_t tk_ostream_write_double(tk_ostream_t* stream, double value) {
int32_t ret = tk_ostream_write_len(stream, &value, sizeof(value), TK_OSTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(value) ? RET_OK : RET_FAIL;
}
int32_t tk_ostream_tell(tk_ostream_t* stream) {
return_value_if_fail(stream != NULL, -1);
return_value_if_fail(stream->tell != NULL, -1);
return stream->tell(stream);
}
ret_t tk_ostream_write_str(tk_ostream_t* stream, const char* str) {
int32_t len = tk_strlen(str);
return tk_ostream_write(stream, str, len) == len ? RET_OK : RET_IO;
}
ret_t tk_ostream_printf(tk_ostream_t* stream, const char* format, ...) {
va_list va;
char buff[1024] = {0};
va_start(va, format);
tk_vsnprintf(buff, sizeof(buff) - 1, format, va);
va_end(va);
return tk_ostream_write_str(stream, buff);
}
ret_t tk_ostream_unref(tk_ostream_t* stream) {
return tk_object_unref(TK_OBJECT(stream));
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/color.c
|
#include "tkc/mem.h"
#include "tkc/color.h"
#include "tkc/utils.h"
color_t color_init(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
color_t c;
c.color = 0;
c.rgba.r = r;
c.rgba.g = g;
c.rgba.b = b;
c.rgba.a = a;
return c;
}
color_t* color_create(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
color_t* c = TKMEM_ZALLOC(color_t);
return_value_if_fail(c != NULL, NULL);
*c = color_init(r, g, b, a);
return c;
}
ret_t color_destroy(color_t* c) {
return_value_if_fail(c != NULL, RET_BAD_PARAMS);
TKMEM_FREE(c);
return RET_OK;
}
uint8_t color_r(color_t* c) {
return_value_if_fail(c != NULL, 0);
return c->rgba.r;
}
uint8_t color_g(color_t* c) {
return_value_if_fail(c != NULL, 0);
return c->rgba.g;
}
uint8_t color_b(color_t* c) {
return_value_if_fail(c != NULL, 0);
return c->rgba.b;
}
uint8_t color_a(color_t* c) {
return_value_if_fail(c != NULL, 0);
return c->rgba.a;
}
color_t* color_cast(color_t* color) {
return_value_if_fail(color != NULL, NULL);
return color;
}
const char* color_hex_str(color_t c, char str[TK_COLOR_HEX_LEN + 1]) {
if (c.rgba.a == 0xff) {
tk_snprintf(str, TK_COLOR_HEX_LEN, "#%02X%02X%02X", (int)(c.rgba.r), (int)(c.rgba.g),
(int)(c.rgba.b));
} else {
tk_snprintf(str, TK_COLOR_HEX_LEN, "#%02x%02x%02x%02x", (int)(c.rgba.r), (int)(c.rgba.g),
(int)(c.rgba.b), (int)(c.rgba.a));
}
return str;
}
const char* color_rgba_str(color_t c, char str[TK_COLOR_RGBA_LEN + 1]) {
float a = c.rgba.a / 255.0f;
tk_snprintf(str, TK_COLOR_RGBA_LEN, "rgba(%d,%d,%d,%1.1f)", (int)(c.rgba.r), (int)(c.rgba.g),
(int)(c.rgba.b), a);
return str;
}
uint32_t color_get_color(color_t* c) {
return_value_if_fail(c != NULL, 0);
return c->color;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/crc.c
|
/*
Copyright 2016 (C) Alexey Dynda
This file is part of Tiny Protocol Library.
Protocol Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Protocol Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with Protocol Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "tkc/crc.h"
/*
* The FCS-16 generator polynomial: x**0 + x**5 + x**12 + x**16.
*/
/*
* FCS lookup table as calculated by the table generator.
*/
#ifdef CONFIG_ENABLE_FCS16
static uint16_t fcstab_16[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3,
0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 0x2102, 0x308b, 0x0210, 0x1399,
0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42, 0x9ed9, 0x8f50,
0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e,
0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5,
0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 0x8408, 0x9581, 0xa71a, 0xb693,
0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948, 0x3bd3, 0x2a5a,
0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710,
0xf3af, 0xe226, 0xd0bd, 0xc134, 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd, 0x6956, 0x78df,
0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 0xe70e, 0xf687, 0xc41c, 0xd595,
0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c,
0x3de3, 0x2c6a, 0x1ef1, 0x0f78};
uint16_t tk_crc16_byte(uint16_t crc, uint8_t data) {
return (crc >> 8) ^ fcstab_16[(crc ^ (data)) & 0xff];
}
uint16_t tk_crc16(uint16_t crc, const void* data, int data_length) {
const uint8_t* pdata = (const uint8_t*)data;
while (data_length) {
crc = (crc >> 8) ^ fcstab_16[(crc ^ (*pdata)) & 0xff];
pdata++;
data_length--;
}
return crc;
}
/*https://modbus.org/docs/Modbus_over_serial_line_V1_01.pdf*/
/*https://en.wikipedia.org/wiki/Modbus#Modbus_RTU_frame_format*/
/*Polynomial: x16 + x15 + x2 + 1 (CRC-16-MODBUS, normal hexadecimal algebraic polynomial being 8005 and reversed A001).*/
/*Initial value: 65,535.*/
static const uint8_t table_crc_hi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40};
/* Table of CRC values for low-order byte */
static const uint8_t table_crc_lo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40};
uint16_t tk_crc16_modbus(const void* data, uint32_t len) {
unsigned int i = 0;
uint8_t crc_hi = 0xFF;
uint8_t crc_lo = 0xFF;
const uint8_t* pdata = (const uint8_t*)data;
while (len--) {
i = crc_lo ^ *pdata++;
crc_lo = crc_hi ^ table_crc_hi[i];
crc_hi = table_crc_lo[i];
}
return (crc_hi << 8 | crc_lo);
}
#endif
#ifdef CONFIG_ENABLE_CHECKSUM
uint16_t tk_chksum_byte(uint16_t sum, uint8_t data) {
return sum + data;
}
uint16_t tk_chksum(uint16_t sum, const void* data, int data_length) {
const uint8_t* pdata = (const uint8_t*)data;
while (data_length) {
sum = sum + *pdata;
pdata++;
data_length--;
}
return 0xFFFF - sum;
}
#endif
#ifdef CONFIG_ENABLE_FCS32
/*
* Library: libcrc
* File: src/crc32.c
* Author: Lammert Bies
*
* This file is licensed under the MIT License as stated below
*
* Copyright (c) 1999-2016 Lammert Bies
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Description
* -----------
* The source file src/crc32.c contains the routines which are needed to
* calculate a 32 bit CRC value of a sequence of bytes.
*/
static const uint32_t crc_tab32[] = {
0x00000000ul, 0x77073096ul, 0xEE0E612Cul, 0x990951BAul, 0x076DC419ul, 0x706AF48Ful,
0xE963A535ul, 0x9E6495A3ul, 0x0EDB8832ul, 0x79DCB8A4ul, 0xE0D5E91Eul, 0x97D2D988ul,
0x09B64C2Bul, 0x7EB17CBDul, 0xE7B82D07ul, 0x90BF1D91ul, 0x1DB71064ul, 0x6AB020F2ul,
0xF3B97148ul, 0x84BE41DEul, 0x1ADAD47Dul, 0x6DDDE4EBul, 0xF4D4B551ul, 0x83D385C7ul,
0x136C9856ul, 0x646BA8C0ul, 0xFD62F97Aul, 0x8A65C9ECul, 0x14015C4Ful, 0x63066CD9ul,
0xFA0F3D63ul, 0x8D080DF5ul, 0x3B6E20C8ul, 0x4C69105Eul, 0xD56041E4ul, 0xA2677172ul,
0x3C03E4D1ul, 0x4B04D447ul, 0xD20D85FDul, 0xA50AB56Bul, 0x35B5A8FAul, 0x42B2986Cul,
0xDBBBC9D6ul, 0xACBCF940ul, 0x32D86CE3ul, 0x45DF5C75ul, 0xDCD60DCFul, 0xABD13D59ul,
0x26D930ACul, 0x51DE003Aul, 0xC8D75180ul, 0xBFD06116ul, 0x21B4F4B5ul, 0x56B3C423ul,
0xCFBA9599ul, 0xB8BDA50Ful, 0x2802B89Eul, 0x5F058808ul, 0xC60CD9B2ul, 0xB10BE924ul,
0x2F6F7C87ul, 0x58684C11ul, 0xC1611DABul, 0xB6662D3Dul, 0x76DC4190ul, 0x01DB7106ul,
0x98D220BCul, 0xEFD5102Aul, 0x71B18589ul, 0x06B6B51Ful, 0x9FBFE4A5ul, 0xE8B8D433ul,
0x7807C9A2ul, 0x0F00F934ul, 0x9609A88Eul, 0xE10E9818ul, 0x7F6A0DBBul, 0x086D3D2Dul,
0x91646C97ul, 0xE6635C01ul, 0x6B6B51F4ul, 0x1C6C6162ul, 0x856530D8ul, 0xF262004Eul,
0x6C0695EDul, 0x1B01A57Bul, 0x8208F4C1ul, 0xF50FC457ul, 0x65B0D9C6ul, 0x12B7E950ul,
0x8BBEB8EAul, 0xFCB9887Cul, 0x62DD1DDFul, 0x15DA2D49ul, 0x8CD37CF3ul, 0xFBD44C65ul,
0x4DB26158ul, 0x3AB551CEul, 0xA3BC0074ul, 0xD4BB30E2ul, 0x4ADFA541ul, 0x3DD895D7ul,
0xA4D1C46Dul, 0xD3D6F4FBul, 0x4369E96Aul, 0x346ED9FCul, 0xAD678846ul, 0xDA60B8D0ul,
0x44042D73ul, 0x33031DE5ul, 0xAA0A4C5Ful, 0xDD0D7CC9ul, 0x5005713Cul, 0x270241AAul,
0xBE0B1010ul, 0xC90C2086ul, 0x5768B525ul, 0x206F85B3ul, 0xB966D409ul, 0xCE61E49Ful,
0x5EDEF90Eul, 0x29D9C998ul, 0xB0D09822ul, 0xC7D7A8B4ul, 0x59B33D17ul, 0x2EB40D81ul,
0xB7BD5C3Bul, 0xC0BA6CADul, 0xEDB88320ul, 0x9ABFB3B6ul, 0x03B6E20Cul, 0x74B1D29Aul,
0xEAD54739ul, 0x9DD277AFul, 0x04DB2615ul, 0x73DC1683ul, 0xE3630B12ul, 0x94643B84ul,
0x0D6D6A3Eul, 0x7A6A5AA8ul, 0xE40ECF0Bul, 0x9309FF9Dul, 0x0A00AE27ul, 0x7D079EB1ul,
0xF00F9344ul, 0x8708A3D2ul, 0x1E01F268ul, 0x6906C2FEul, 0xF762575Dul, 0x806567CBul,
0x196C3671ul, 0x6E6B06E7ul, 0xFED41B76ul, 0x89D32BE0ul, 0x10DA7A5Aul, 0x67DD4ACCul,
0xF9B9DF6Ful, 0x8EBEEFF9ul, 0x17B7BE43ul, 0x60B08ED5ul, 0xD6D6A3E8ul, 0xA1D1937Eul,
0x38D8C2C4ul, 0x4FDFF252ul, 0xD1BB67F1ul, 0xA6BC5767ul, 0x3FB506DDul, 0x48B2364Bul,
0xD80D2BDAul, 0xAF0A1B4Cul, 0x36034AF6ul, 0x41047A60ul, 0xDF60EFC3ul, 0xA867DF55ul,
0x316E8EEFul, 0x4669BE79ul, 0xCB61B38Cul, 0xBC66831Aul, 0x256FD2A0ul, 0x5268E236ul,
0xCC0C7795ul, 0xBB0B4703ul, 0x220216B9ul, 0x5505262Ful, 0xC5BA3BBEul, 0xB2BD0B28ul,
0x2BB45A92ul, 0x5CB36A04ul, 0xC2D7FFA7ul, 0xB5D0CF31ul, 0x2CD99E8Bul, 0x5BDEAE1Dul,
0x9B64C2B0ul, 0xEC63F226ul, 0x756AA39Cul, 0x026D930Aul, 0x9C0906A9ul, 0xEB0E363Ful,
0x72076785ul, 0x05005713ul, 0x95BF4A82ul, 0xE2B87A14ul, 0x7BB12BAEul, 0x0CB61B38ul,
0x92D28E9Bul, 0xE5D5BE0Dul, 0x7CDCEFB7ul, 0x0BDBDF21ul, 0x86D3D2D4ul, 0xF1D4E242ul,
0x68DDB3F8ul, 0x1FDA836Eul, 0x81BE16CDul, 0xF6B9265Bul, 0x6FB077E1ul, 0x18B74777ul,
0x88085AE6ul, 0xFF0F6A70ul, 0x66063BCAul, 0x11010B5Cul, 0x8F659EFFul, 0xF862AE69ul,
0x616BFFD3ul, 0x166CCF45ul, 0xA00AE278ul, 0xD70DD2EEul, 0x4E048354ul, 0x3903B3C2ul,
0xA7672661ul, 0xD06016F7ul, 0x4969474Dul, 0x3E6E77DBul, 0xAED16A4Aul, 0xD9D65ADCul,
0x40DF0B66ul, 0x37D83BF0ul, 0xA9BCAE53ul, 0xDEBB9EC5ul, 0x47B2CF7Ful, 0x30B5FFE9ul,
0xBDBDF21Cul, 0xCABAC28Aul, 0x53B39330ul, 0x24B4A3A6ul, 0xBAD03605ul, 0xCDD70693ul,
0x54DE5729ul, 0x23D967BFul, 0xB3667A2Eul, 0xC4614AB8ul, 0x5D681B02ul, 0x2A6F2B94ul,
0xB40BBE37ul, 0xC30C8EA1ul, 0x5A05DF1Bul, 0x2D02EF8Dul};
uint32_t tk_crc32(uint32_t init, const void* data, int size) {
size_t a = 0;
uint32_t crc = init;
const uint8_t* ptr = (const uint8_t*)data;
if (ptr != NULL)
for (a = 0; a < size; a++) {
crc = (crc >> 8) ^ crc_tab32[(crc ^ (uint32_t)*ptr++) & 0x000000FFul];
}
return crc;
} /* crc_32 */
uint32_t tk_crc32_byte(uint32_t crc, uint8_t data) {
return (crc >> 8) ^ crc_tab32[(crc ^ (uint32_t)data) & 0x000000FFul];
}
#include "tkc/fs.h"
#include "tkc/mem.h"
#include "tkc/utils.h"
uint32_t tk_crc32_file(const char* filename, uint32_t block_size) {
int32_t size = 0;
fs_file_t* fp = NULL;
void* buff = NULL;
uint32_t crc32 = PPPINITFCS32;
return_value_if_fail(filename != NULL, crc32);
fp = fs_open_file(os_fs(), filename, "rb");
return_value_if_fail(fp != NULL, crc32);
block_size = tk_max_int(block_size, 256);
block_size = tk_min_int(block_size, 1024 * 1024);
buff = TKMEM_ALLOC(block_size + 1);
goto_error_if_fail(buff != NULL);
while (!fs_file_eof(fp)) {
size = fs_file_read(fp, buff, block_size);
if (size <= 0) {
break;
}
crc32 = tk_crc32(crc32, buff, size);
}
error:
fs_file_close(fp);
TKMEM_FREE(buff);
return crc32;
}
#endif
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/timer_info.c
|
/**
* File: timer_info.h
* Author: AWTK Develop Team
* Brief: timer info
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/timer_info.h"
#include "tkc/timer_manager.h"
#ifdef AWTK_WEB_JS
#include <emscripten.h>
#endif /*AWTK_WEB_JS*/
static ret_t timer_info_on_destroy(timer_info_t* info) {
if (info->on_destroy != NULL) {
info->on_destroy(info);
}
#ifdef AWTK_WEB_JS
EM_ASM_INT({ return TBrowser.releaseFunction($0); }, info->on_timer);
#endif /*AWTK_WEB_JS*/
return RET_OK;
}
static const object_vtable_t s_timer_info_vtable = {
.type = "timer_info",
.desc = "timer_info",
.size = sizeof(timer_info_t),
.is_collection = FALSE,
.on_destroy = (tk_object_on_destroy_t)timer_info_on_destroy};
timer_info_t* timer_info_create(timer_manager_t* tm, uint32_t id, timer_func_t on_timer, void* ctx,
uint32_t duration, uint16_t timer_info_type) {
tk_object_t* obj = tk_object_create(&s_timer_info_vtable);
timer_info_t* timer = TIMER_INFO(obj);
return_value_if_fail(timer != NULL, NULL);
timer->ctx = ctx;
timer->suspend = FALSE;
timer->on_timer = on_timer;
timer->duration = duration;
timer->timer_info_type = timer_info_type;
if (tm != NULL) {
timer->id = id;
timer->timer_manager = tm;
timer->start = tm->get_time();
if (id != TK_INVALID_ID) {
timer_manager_append(tm, timer);
} else {
tk_object_unref(obj);
return_value_if_fail(id != TK_INVALID_ID, NULL);
}
}
return timer;
}
int timer_info_compare_by_id(const void* a, const void* b) {
return ((const timer_info_t*)a)->id - ((const timer_info_t*)b)->id;
}
int timer_info_compare_by_ctx(const void* a, const void* b) {
const timer_info_t* info_a = (const timer_info_t*)a;
return (char*)(info_a->ctx) - (char*)(b);
}
int timer_info_compare_by_ctx_and_type(const void* a, const void* b) {
const timer_info_t* info_a = (const timer_info_t*)a;
const timer_info_t* info_b = (const timer_info_t*)b;
if (info_a->timer_info_type == info_b->timer_info_type) {
return (char*)(info_a->ctx) - (char*)(info_b->ctx);
}
return -1;
}
timer_info_t* timer_info_init_dummy_with_ctx_and_type(timer_info_t* timer, uint16_t type,
void* ctx) {
return_value_if_fail(timer != NULL, NULL);
memset(timer, 0x00, sizeof(timer_info_t));
timer->ctx = ctx;
timer->timer_info_type = type;
return timer;
}
timer_info_t* timer_info_init_dummy(timer_info_t* timer, uint32_t id) {
return_value_if_fail(timer != NULL, NULL);
memset(timer, 0x00, sizeof(timer_info_t));
timer->id = id;
return timer;
}
timer_info_t* timer_info_cast(timer_info_t* timer) {
return_value_if_fail(timer != NULL, NULL);
return timer;
}
ret_t timer_info_on_timer(timer_info_t* timer, uint64_t now) {
ret_t ret = RET_OK;
return_value_if_fail(timer != NULL && timer->on_timer != NULL, RET_BAD_PARAMS);
if (timer->busy) {
return RET_BUSY;
}
timer->busy = TRUE;
timer->now = now;
ret = timer->on_timer(timer);
timer->busy = FALSE;
return ret;
}
bool_t timer_info_is_available(timer_info_t* timer, uint64_t now) {
return timer != NULL && !(timer->busy) && timer->now != now;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/cond_var.h
|
/**
* File: cond_var.h
* Author: AWTK Develop Team
* Brief: cond_var
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-05-11 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COND_VAR_SIMPLE_H
#define TK_COND_VAR_SIMPLE_H
#include "tkc/cond.h"
BEGIN_C_DECLS
/**
* @class tk_cond_var_t
* 简化版的条件变量。
*/
struct _tk_cond_var_t;
typedef struct _tk_cond_var_t tk_cond_var_t;
/**
* @method tk_cond_var_create
* 创建cond_var。
*
* @return {tk_cond_var_t*} cond_var对象。
*/
tk_cond_var_t* tk_cond_var_create(void);
/**
* @method tk_cond_var_wait
* 等待。
* @param {tk_cond_var_t*} cond_var cond_var对象。
* @param {uint32_t} timeout 最长等待时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_var_wait(tk_cond_var_t* cond_var, uint32_t timeout);
/**
* @method tk_cond_var_awake
* 唤醒。
* @param {tk_cond_var_t*} cond_var cond_var对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_var_awake(tk_cond_var_t* cond_var);
/**
* @method tk_cond_var_destroy
* 销毁cond_var对象。
* @param {tk_cond_var_t*} cond_var cond_var对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_var_destroy(tk_cond_var_t* cond_var);
END_C_DECLS
#endif /*TK_COND_VAR_SIMPLE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/ring_buffer.h
|
/**
* File: ring_buffer.h
* Author: AWTK Develop Team
* Brief: ring_buffer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-06 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RING_BUFFER_H
#define TK_RING_BUFFER_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class ring_buffer_t
* 循环缓存区。
*/
typedef struct _ring_buffer_t {
/**
* @property {uint32_t} r
* @annotation ["readable"]
* 读取位置。
*/
uint32_t r;
/**
* @property {uint32_t} w
* @annotation ["readable"]
* 写入位置。
*/
uint32_t w;
/**
* @property {bool_t} full
* @annotation ["readable"]
* 是否满。
*/
bool_t full;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 当前容量。
*/
uint32_t capacity;
/**
* @property {uint32_t} max_capacity
* @annotation ["readable"]
* 最大容量。
*/
uint32_t max_capacity;
/**
* @property {uint8_t*} data
* @annotation ["readable"]
* 数据。
*/
uint8_t* data;
} ring_buffer_t;
/**
* @method ring_buffer_create
* @annotation ["constructor"]
* 创建ring_buffer对象。
*
* @param {uint32_t} init_capacity 初始容量。
* @param {uint32_t} max_capacity 最大容量。
*
* @return {ring_buffer_t*} ring_buffer对象。
*/
ring_buffer_t* ring_buffer_create(uint32_t init_capacity, uint32_t max_capacity);
/**
* @method ring_buffer_is_full
* 检查ring_buffer是否满。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {bool_t} 是否满。
*/
bool_t ring_buffer_is_full(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_is_empty
* 检查ring_buffer是否空。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {bool_t} 是否空。
*/
bool_t ring_buffer_is_empty(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_size
* 获取数据长度。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {uint32_t} 数据长度。
*/
uint32_t ring_buffer_size(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_free_size
* 获取空闲空间的长度。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {uint32_t} 空闲空间的长度。
*/
uint32_t ring_buffer_free_size(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_capacity
* 获取容量。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {uint32_t} 容量。
*/
uint32_t ring_buffer_capacity(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_read
* 读取数据。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {void*} buff 缓冲区。
* @param {uint32_t} size 最大长度。
*
* @return {uint32_t} 返回实际读取数据的长度。
*/
uint32_t ring_buffer_read(ring_buffer_t* ring_buffer, void* buff, uint32_t size);
/**
* @method ring_buffer_peek
* 读取数据(不修改读取位置)。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {void*} buff 缓冲区。
* @param {uint32_t} size 最大长度。
*
* @return {uint32_t} 返回实际读取数据的长度。
*/
uint32_t ring_buffer_peek(ring_buffer_t* ring_buffer, void* buff, uint32_t size);
/**
* @method ring_buffer_write
* 写入数据。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {const void*} buff 缓冲区。
* @param {uint32_t} size 最大长度。
*
* @return {uint32_t} 返回实际写入数据的长度。
*/
uint32_t ring_buffer_write(ring_buffer_t* ring_buffer, const void* buff, uint32_t size);
/**
* @method ring_buffer_read_len
* 读取指定长度数据，要么成功要么失败。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {void*} buff 缓冲区。
* @param {uint32_t} size 最大长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_read_len(ring_buffer_t* ring_buffer, void* buff, uint32_t size);
/**
* @method ring_buffer_skip
* 跳过指定长度数据，要么成功要么失败。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} size 长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_skip(ring_buffer_t* ring_buffer, uint32_t size);
/**
* @method ring_buffer_write_len
* 写入指定长度数据，要么成功要么失败。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {const void*} buff 缓冲区。
* @param {uint32_t} size 最大长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_write_len(ring_buffer_t* ring_buffer, const void* buff, uint32_t size);
/**
* @method ring_buffer_reset
* 重置ring_buffer为空。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_reset(ring_buffer_t* ring_buffer);
/**
* @method ring_buffer_set_read_cursor
* 设置读取光标的位置。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} r 读取光标的位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_set_read_cursor(ring_buffer_t* ring_buffer, uint32_t r);
/**
* @method ring_buffer_set_read_cursor_delta
* 设置读取光标的位置(delta)。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} r_delta 读取光标的位置(delta)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_set_read_cursor_delta(ring_buffer_t* ring_buffer, uint32_t r_delta);
/**
* @method ring_buffer_set_write_cursor
* 设置写入光标的位置。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} w 写入光标的位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_set_write_cursor(ring_buffer_t* ring_buffer, uint32_t w);
/**
* @method ring_buffer_set_write_cursor_delta
* 设置写入光标的位置(delta)。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} w_delta 写入光标的位置(delta)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_set_write_cursor_delta(ring_buffer_t* ring_buffer, uint32_t w_delta);
/**
* @method ring_buffer_ensure_write_space
* 扩展buffer。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
* @param {uint32_t} size 需要的大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_ensure_write_space(ring_buffer_t* ring_buffer, uint32_t size);
/**
* @method ring_buffer_destroy
* 销毁ring_buffer。
*
* @param {ring_buffer_t*} ring_buffer ring_buffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t ring_buffer_destroy(ring_buffer_t* ring_buffer);
END_C_DECLS
#endif /*TK_RING_BUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_date_time.h
|
/**
* File: object_date_time.h
* Author: AWTK Develop Team
* Brief: wrap date time to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_DATE_TIME_H
#define TK_OBJECT_DATE_TIME_H
#include "tkc/object.h"
#include "tkc/date_time.h"
BEGIN_C_DECLS
/**
* @class object_date_time_t
* @parent tk_object_t
*
* 将date_time包装成object。
*
*/
typedef struct _object_date_time_t {
tk_object_t object;
/**
* @property {date_time_t*} dt
* @annotation ["readable"]
* date time对象。
*
*/
date_time_t* dt;
} object_date_time_t;
/**
* @method object_date_time_create
*
* 创建对象。
*
* @annotation ["constructor"]
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_date_time_create(void);
/**
* @method object_date_time_cast
* 转换为object_date_time对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_date_time对象。
*
* @return {object_date_time_t*} object_date_time对象。
*/
object_date_time_t* object_date_time_cast(tk_object_t* obj);
#define OBJECT_DATE_TIME(obj) object_date_time_cast(obj)
#define OBJECT_DATE_TIME_TYPE "object_date_time"
#define OBJECT_DATE_TIME_PROP_YEAR "year"
#define OBJECT_DATE_TIME_PROP_MONTH "month"
#define OBJECT_DATE_TIME_PROP_MINUTE "minute"
#define OBJECT_DATE_TIME_PROP_DAY "day"
#define OBJECT_DATE_TIME_PROP_HOUR "hour"
#define OBJECT_DATE_TIME_PROP_SECOND "second"
#define OBJECT_DATE_TIME_PROP_WDAY "wday"
END_C_DECLS
#endif /*TK_OBJECT_DATE_TIME_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/wstr.c
|
/**
* File: wstr.c
* Author: AWTK Develop Team
* Brief: width char
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-28 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/wstr.h"
#include "tkc/utils.h"
const wchar_t* wcs_chr(const wchar_t* s, wchar_t c) {
const wchar_t* p = s;
return_value_if_fail(s != NULL, NULL);
while (*p && *p != c) p++;
return *p ? p : NULL;
}
wchar_t* wcs_ncpy(wchar_t* s1, const wchar_t* s2, uint32_t n) {
wchar_t* d = s1;
const wchar_t* s = s2;
return_value_if_fail(s1 != NULL && s2 != NULL, NULL);
while (*s && n-- > 0) {
*d++ = *s++;
}
*d = '\0';
return s1;
}
wchar_t* wcs_cpy(wchar_t* s1, const wchar_t* s2) {
wchar_t* d = s1;
const wchar_t* s = s2;
return_value_if_fail(s1 != NULL && s2 != NULL, NULL);
while (*s) {
*d++ = *s++;
}
*d = '\0';
return s1;
}
int wcs_ncmp(const wchar_t* s1, const wchar_t* s2, uint32_t n) {
wchar_t c1 = L'\0';
wchar_t c2 = L'\0';
return_value_if_fail(s1 != NULL && s2 != NULL, -1);
if (n >= 4) {
size_t n4 = n >> 2;
do {
c1 = *s1++;
c2 = *s2++;
if (c1 == L'\0' || c1 != c2) {
return c1 > c2 ? 1 : (c1 < c2 ? -1 : 0);
}
c1 = *s1++;
c2 = *s2++;
if (c1 == L'\0' || c1 != c2) {
return c1 > c2 ? 1 : (c1 < c2 ? -1 : 0);
}
c1 = *s1++;
c2 = *s2++;
if (c1 == L'\0' || c1 != c2) {
return c1 > c2 ? 1 : (c1 < c2 ? -1 : 0);
}
c1 = *s1++;
c2 = *s2++;
if (c1 == L'\0' || c1 != c2) {
return c1 > c2 ? 1 : (c1 < c2 ? -1 : 0);
}
} while (--n4 > 0);
n &= 3;
}
while (n > 0) {
c1 = *s1++;
c2 = *s2++;
if (c1 == L'\0' || c1 != c2) {
return c1 > c2 ? 1 : (c1 < c2 ? -1 : 0);
}
n--;
}
return 0;
}
int wcs_cmp(const wchar_t* s1, const wchar_t* s2) {
uint32_t i = 0;
return_value_if_fail(s1 != NULL && s2 != NULL, -1);
for (i = 0; s1[i] && s2[i]; i++) {
int ret = s1[i] - s2[i];
if (ret) {
return ret;
}
}
return s1[i] - s2[i];
}
int wcs_case_cmp(const wchar_t* s1, const wchar_t* s2) {
uint32_t i = 0;
return_value_if_fail(s1 != NULL && s2 != NULL, -1);
for (i = 0; s1[i] && s2[i]; i++) {
int ret = tolower(s1[i]) - tolower(s2[i]);
if (ret) {
return ret;
}
}
return tolower(s1[i]) - tolower(s2[i]);
}
wchar_t* wcs_dup(const wchar_t* s) {
wchar_t* s1 = TKMEM_ZALLOCN(wchar_t, wcslen(s) + 1);
return wcs_cpy(s1, s);
}
size_t wcs_len(const wchar_t* s) {
size_t size = 0;
const wchar_t* p = s;
return_value_if_fail(s != NULL, 0);
while (*p++) {
size++;
}
return size;
}
#ifdef WITH_WCSXXX
size_t wcslen(const wchar_t* s) {
return wcs_len(s);
}
int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n) {
return wcs_ncmp(s1, s2, n);
}
int wcscmp(const wchar_t* s1, const wchar_t* s2) {
return wcs_cmp(s1, s2);
}
int wcscasecmp(const wchar_t* s1, const wchar_t* s2) {
return wcs_case_cmp(s1, s2);
}
wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2) {
return wcs_cpy(s1, s2);
}
wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n) {
return wcs_ncpy(s1, s2, n);
}
wchar_t* wcschr(const wchar_t* s, wchar_t c) {
return (wchar_t*)wcs_chr(s, c);
}
wchar_t* wcsdup(const wchar_t* s) {
return wcs_dup(s);
}
int iswspace(wint_t ch) {
return ch == ' ';
}
#endif /*WITH_WCSXXX*/
ret_t wstr_extend(wstr_t* str, uint32_t capacity) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
if (capacity <= str->capacity) {
return RET_OK;
}
if (!str->extendable) {
return RET_FAIL;
}
if (capacity > 0) {
wchar_t* s = TKMEM_REALLOCT(wchar_t, str->str, capacity + 1);
return_value_if_fail(s != NULL, RET_FAIL);
s[str->size] = 0;
str->str = s;
str->capacity = capacity;
}
return RET_OK;
}
ret_t wstr_shrink(wstr_t* str, uint32_t size) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
if (size < str->size) {
str->size = size;
str->str[size] = 0;
}
return RET_OK;
}
wstr_t* wstr_create(uint32_t capacity) {
wstr_t* str = TKMEM_ZALLOC(wstr_t);
return_value_if_fail(str != NULL, NULL);
return wstr_init(str, capacity);
}
ret_t wstr_destroy(wstr_t* str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
wstr_reset(str);
TKMEM_FREE(str);
return RET_OK;
}
wstr_t* wstr_init(wstr_t* str, uint32_t capacity) {
return_value_if_fail(str != NULL, NULL);
memset(str, 0x00, sizeof(wstr_t));
str->extendable = TRUE;
return wstr_extend(str, capacity) == RET_OK ? str : NULL;
}
wstr_t* wstr_attach(wstr_t* str, wchar_t* buff, uint32_t capacity) {
return_value_if_fail(str != NULL && buff != NULL && capacity > 0, NULL);
memset(str, 0x00, sizeof(str_t));
memset(buff, 0x00, capacity * sizeof(wchar_t));
str->str = buff;
str->size = 0;
str->capacity = capacity;
str->extendable = FALSE;
return str;
}
ret_t wstr_set(wstr_t* str, const wchar_t* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return wstr_set_with_len(str, text, 0xffffffff);
}
ret_t wstr_set_with_len(wstr_t* str, const wchar_t* text, uint32_t len) {
uint32_t size = 0;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
size = wcslen(text);
size = tk_min(size, len);
return_value_if_fail(wstr_extend(str, size + 1) == RET_OK, RET_BAD_PARAMS);
wcsncpy(str->str, text, size);
str->size = size;
str->str[size] = 0;
return RET_OK;
}
ret_t wstr_clear(wstr_t* str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
str->size = 0;
if (str->str != NULL) {
str->str[0] = '\0';
}
return RET_OK;
}
ret_t wstr_set_utf8_with_len(wstr_t* str, const char* text, uint32_t len) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, len + 2) == RET_OK, RET_OOM);
if (tk_utf8_to_utf16_ex(text, len, str->str, str->capacity - 1) == NULL) {
log_warn("wstr_set_utf8_with_len fail, please ensure the parameters are UTF-8 encoded!\n");
wstr_reset(str);
return RET_BAD_PARAMS;
}
str->size = wcslen(str->str);
return RET_OK;
}
ret_t wstr_set_utf8(wstr_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, strlen(text) + 2) == RET_OK, RET_OOM);
if (tk_utf8_to_utf16(text, str->str, str->capacity - 1) == NULL) {
log_warn("wstr_set_utf8 fail, please ensure the parameters are UTF-8 encoded!\n");
wstr_reset(str);
return RET_BAD_PARAMS;
}
str->size = wcslen(str->str);
return RET_OK;
}
ret_t wstr_append_utf8(wstr_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, str->size + strlen(text) + 2) == RET_OK, RET_OOM);
if (tk_utf8_to_utf16(text, str->str + str->size, str->capacity - str->size - 1) == NULL) {
log_warn("wstr_append_utf8 fail, please ensure the parameters are UTF-8 encoded!\n");
return RET_BAD_PARAMS;
}
str->size = wcslen(str->str);
return RET_OK;
}
ret_t wstr_get_utf8(wstr_t* str, char* text, uint32_t size) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
tk_utf8_from_utf16(str->str, text, size);
return RET_OK;
}
ret_t wstr_remove(wstr_t* str, uint32_t offset, uint32_t nr) {
wchar_t* p = NULL;
return_value_if_fail(str != NULL && offset < str->size && nr > 0, RET_BAD_PARAMS);
if ((offset + nr) > str->size) {
nr = str->size - offset;
}
if (nr > 0) {
p = str->str;
memmove(p + offset, p + offset + nr, (str->size - offset - nr) * sizeof(wchar_t));
str->size -= nr;
str->str[str->size] = 0;
}
return RET_OK;
}
ret_t wstr_insert(wstr_t* str, uint32_t offset, const wchar_t* text, uint32_t nr) {
wchar_t* p = NULL;
return_value_if_fail(str != NULL && text != NULL && offset <= str->size && nr > 0,
RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, str->size + nr + 1) == RET_OK, RET_BAD_PARAMS);
p = str->str;
if (str->size > offset) {
uint32_t i = 0;
uint32_t s = str->size - 1;
uint32_t d = str->size + nr - 1;
uint32_t move_nr = str->size - offset;
for (i = 0; i < move_nr; i++, d--, s--) {
p[d] = p[s];
}
}
memcpy(p + offset, text, nr * sizeof(wchar_t));
str->size += nr;
str->str[str->size] = 0;
return RET_OK;
}
ret_t wstr_append_with_len(wstr_t* str, const wchar_t* text, uint32_t size) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, str->size + size + 1) == RET_OK, RET_BAD_PARAMS);
memcpy(str->str + str->size, text, size * sizeof(wchar_t));
str->size += size;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t wstr_append(wstr_t* str, const wchar_t* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return wstr_append_with_len(str, text, wcslen(text));
}
ret_t wstr_push(wstr_t* str, const wchar_t c) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_extend(str, str->size + 2) == RET_OK, RET_BAD_PARAMS);
str->str[str->size++] = c;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t wstr_append_int(wstr_t* str, int32_t value) {
return wstr_push_int(str, "%d", value);
}
ret_t wstr_push_int(wstr_t* str, const char* format, int32_t value) {
char buff[TK_NUM_MAX_LEN + 1];
wchar_t s[TK_NUM_MAX_LEN + 1];
memset(s, 0x00, sizeof(s));
memset(buff, 0x00, sizeof(buff));
return_value_if_fail(str != NULL && format != NULL, RET_BAD_PARAMS);
tk_snprintf(buff, TK_NUM_MAX_LEN, format, value);
tk_utf8_to_utf16(buff, s, TK_NUM_MAX_LEN);
return wstr_append_with_len(str, s, wcslen(s));
}
ret_t wstr_pop(wstr_t* str) {
return_value_if_fail(str != NULL && str->size > 0, RET_BAD_PARAMS);
str->size--;
str->str[str->size] = '\0';
return RET_OK;
}
bool_t wstr_eq(wstr_t* str, const wchar_t* text) {
if ((str == NULL && text == NULL) || (str != NULL && str->str == NULL && text == NULL)) {
return TRUE;
}
if (str == NULL || text == NULL || str->str == NULL) {
return FALSE;
}
if (str->str[0] != text[0]) {
return FALSE;
}
return wcscmp(str->str, text) == 0;
}
bool_t wstr_equal(wstr_t* str, wstr_t* other) {
if (str == other) {
return TRUE;
}
if (str == NULL || other == NULL) {
return FALSE;
}
if (str->str == other->str) {
return TRUE;
}
if (str->str == NULL || other->str == NULL) {
return FALSE;
}
return wcscmp(str->str, other->str) == 0;
}
ret_t wstr_from_int(wstr_t* str, int32_t v) {
char buff[TK_NUM_MAX_LEN + 1];
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return wstr_set_utf8(str, tk_itoa(buff, sizeof(buff), v));
}
ret_t wstr_from_int64(wstr_t* str, int64_t v) {
char buff[TK_NUM_MAX_LEN + 1];
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return wstr_set_utf8(str, tk_lltoa(buff, sizeof(buff), v));
}
ret_t wstr_from_float(wstr_t* str, double v) {
char buff[TK_NUM_MAX_LEN + 1];
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return wstr_set_utf8(str, tk_ftoa(buff, sizeof(buff), v));
}
ret_t wstr_from_value(wstr_t* str, const value_t* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
if (v->type == VALUE_TYPE_STRING) {
return wstr_set_utf8(str, value_str(v));
} else if (v->type == VALUE_TYPE_WSTRING) {
return wstr_set(str, value_wstr(v));
} else if (v->type == VALUE_TYPE_FLOAT || v->type == VALUE_TYPE_FLOAT32 ||
v->type == VALUE_TYPE_DOUBLE) {
return wstr_from_float(str, value_float(v));
} else {
return wstr_from_int(str, value_int(v));
}
}
ret_t wstr_to_int(wstr_t* str, int32_t* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
if (str->size > 0) {
char buff[TK_NUM_MAX_LEN + 1] = {0};
wchar_t wbuff[TK_NUM_MAX_LEN] = {0};
uint32_t size = tk_min(str->size, TK_NUM_MAX_LEN) * sizeof(wchar_t);
memcpy(wbuff, str->str, size);
tk_utf8_from_utf16_ex(wbuff, ARRAY_SIZE(wbuff), buff, ARRAY_SIZE(buff));
*v = tk_atoi(buff);
} else {
*v = 0;
}
return RET_OK;
}
ret_t wstr_to_int64(wstr_t* str, int64_t* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
if (str->size > 0) {
char buff[TK_NUM_MAX_LEN * 2 + 1] = {0};
wchar_t wbuff[TK_NUM_MAX_LEN * 2] = {0};
uint32_t size = tk_min(str->size, TK_NUM_MAX_LEN * 2) * sizeof(wchar_t);
memcpy(wbuff, str->str, size);
tk_utf8_from_utf16_ex(wbuff, ARRAY_SIZE(wbuff), buff, ARRAY_SIZE(buff));
*v = tk_atol(buff);
} else {
*v = 0;
}
return RET_OK;
}
ret_t wstr_to_float(wstr_t* str, double* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
if (str->size > 0) {
char buff[TK_NUM_MAX_LEN + 1] = {0};
wchar_t wbuff[TK_NUM_MAX_LEN] = {0};
uint32_t size = tk_min(str->size, TK_NUM_MAX_LEN) * sizeof(wchar_t);
memcpy(wbuff, str->str, size);
if (tk_utf8_from_utf16_ex(wbuff, ARRAY_SIZE(wbuff), buff, ARRAY_SIZE(buff)) != NULL) {
*v = tk_atof(buff);
} else {
*v = 0.0f;
return RET_FAIL;
}
} else {
*v = 0.0f;
}
return RET_OK;
}
static uint32_t double_fraction_nr(double v) {
uint32_t nr = 0;
double d = v - floor(v);
if (tk_fequal(v, floor(v))) {
return nr;
}
d = d * 10;
nr++;
while (d < 1 || d > floor(d)) {
d = d * 10;
nr++;
}
return nr;
}
static uint32_t wstr_fraction_nr(wstr_t* str) {
uint32_t nr = 0;
wchar_t* p = NULL;
return_value_if_fail(str != NULL && str->str != NULL, 0);
p = (wchar_t*)wcschr(str->str, '.');
if (p != NULL) {
nr = wcslen(p + 1);
}
return nr;
}
ret_t wstr_trim_float_zero(wstr_t* str) {
wchar_t* p = NULL;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
if (wcschr(str->str, '.') == NULL) {
return RET_OK;
}
p = str->str + str->size - 1;
while (p > str->str) {
if (*p != '0') {
if (*p == '.') {
p--;
}
break;
}
p--;
}
str->size = p - str->str + 1;
str->str[str->size] = 0;
return RET_OK;
}
ret_t wstr_to_fix(wstr_t* str, uint32_t fraction_nr) {
wchar_t* p = NULL;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
p = (wchar_t*)wcschr(str->str, '.');
if (p) {
p++;
uint32_t nr = wcslen(p);
if (nr > fraction_nr) {
str->size = p - str->str + fraction_nr;
str->str[str->size] = 0;
}
}
return RET_OK;
}
ret_t wstr_add_float(wstr_t* str, double delta) {
double v = 0;
uint32_t fraction_nr1 = double_fraction_nr(delta);
uint32_t fraction_nr2 = wstr_fraction_nr(str);
uint32_t fraction_nr = tk_max(fraction_nr1, fraction_nr2);
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
wstr_to_float(str, &v);
v = v + delta;
wstr_from_float(str, v);
return wstr_to_fix(str, fraction_nr);
}
ret_t wstr_reset(wstr_t* str) {
return_value_if_fail(str != NULL, RET_OK);
if (str->extendable) {
TKMEM_FREE(str->str);
}
str->str = NULL;
str->size = 0;
str->capacity = 0;
return RET_OK;
}
ret_t wstr_normalize_newline(wstr_t* str, wchar_t newline) {
wchar_t* s = str->str;
wchar_t* d = str->str;
while (*s) {
if (*s == '\r') {
if (s[1] == '\n') {
s++;
}
s++;
*d++ = newline;
} else if (*s == '\n') {
s++;
*d++ = newline;
} else {
*d++ = *s++;
}
}
*d = '\0';
str->size = d - str->str;
return RET_OK;
}
uint32_t wstr_count_char(wstr_t* str, wchar_t c) {
uint32_t i = 0;
uint32_t n = 0;
wchar_t* p = NULL;
return_value_if_fail(str != NULL, 0);
p = str->str;
for (i = 0; i < str->size; i++) {
if (p[i] == c) {
n++;
}
}
return n;
}
ret_t wstr_append_more(wstr_t* str, const wchar_t* text, ...) {
va_list va;
const wchar_t* p = NULL;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_append(str, text) == RET_OK, RET_OOM);
va_start(va, text);
do {
p = va_arg(va, wchar_t*);
if (p != NULL) {
return_value_if_fail(wstr_append(str, p) == RET_OK, RET_OOM);
} else {
break;
}
} while (p != NULL);
va_end(va);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/fs.h
|
/**
* File: fs.h
* Author: AWTK Develop Team
* Brief: simple fs api
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FS_H
#define TK_FS_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class fs_stat_info_t
*
* 文件状态信息。
*
*/
typedef struct _fs_stat_info_t {
uint32_t dev;
uint16_t ino;
uint16_t mode;
int16_t nlink;
int16_t uid;
int16_t gid;
uint32_t rdev;
/**
* @property {uint64_t} size
* 文件大小。
*/
uint64_t size;
/**
* @property {uint64_t} atime
* 最后访问时间。
*/
uint64_t atime;
/**
* @property {uint64_t} mtime
* 最后修改时间。
*/
uint64_t mtime;
/**
* @property {uint64_t} ctime
* 创建时间。
*/
uint64_t ctime;
/**
* @property {bool_t} is_dir
* 是否为目录。
*/
bool_t is_dir;
/**
* @property {bool_t} is_link
* 是否为链接。
*/
bool_t is_link;
/**
* @property {bool_t} is_reg_file
* 是否普通文件。
*/
bool_t is_reg_file;
} fs_stat_info_t;
/**
* @method fs_stat_info_create
* 创建文件状态信息对象。
* @return {fs_stat_info_t*} 返回文件状态信息对象。
*/
fs_stat_info_t* fs_stat_info_create(void);
/**
* @method fs_stat_info_destroy
* 销毁文件状态信息对象。
* @param {fs_stat_info_t*} fst 文件状态信息对象。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_stat_info_destroy(fs_stat_info_t* fst);
struct _fs_file_t;
typedef struct _fs_file_t fs_file_t;
typedef int32_t (*fs_file_read_t)(fs_file_t* file, void* buffer, uint32_t size);
typedef int32_t (*fs_file_write_t)(fs_file_t* file, const void* buffer, uint32_t size);
typedef int32_t (*fs_printf_t)(fs_file_t* file, const char* const format_str, va_list);
typedef ret_t (*fs_file_seek_t)(fs_file_t* file, int32_t offset);
typedef ret_t (*fs_file_truncate_t)(fs_file_t* file, int32_t offset);
typedef bool_t (*fs_file_eof_t)(fs_file_t* file);
typedef int64_t (*fs_file_tell_t)(fs_file_t* file);
typedef int64_t (*fs_file_size_t)(fs_file_t* file);
typedef ret_t (*fs_file_stat_t)(fs_file_t* file, fs_stat_info_t* fst);
typedef ret_t (*fs_file_sync_t)(fs_file_t* file);
typedef ret_t (*fs_file_close_t)(fs_file_t* file);
typedef struct _fs_file_vtable_t {
fs_file_read_t read;
fs_file_write_t write;
fs_printf_t printf;
fs_file_seek_t seek;
fs_file_truncate_t truncate;
fs_file_eof_t eof;
fs_file_tell_t tell;
fs_file_size_t size;
fs_file_sync_t sync;
fs_file_stat_t stat;
fs_file_close_t close;
} fs_file_vtable_t;
/**
* @class fs_file_t
* 文件接口。
*
* 示例：
*
* ```c
* int32_t ret = 0;
* const char* file_name = "test.txt";
* int32_t len = file_get_size(file_name);
* uint8_t* buff = (uint8_t*)TKMEM_ALLOC(len + 1);
* return_value_if_fail(buff != NULL, NULL);
* fs_file_t* fp = fs_open_file(os_fs(), file_name, "rb");
* if (fp != NULL) {
* ret = fs_file_read(fp, buff, len);
* fs_file_close(fp);
* }
* ```
*
*/
struct _fs_file_t {
const fs_file_vtable_t* vt;
void* data;
};
/**
* @method fs_file_read
*
* 读取文件。
*
* @param {fs_file_t*} file 文件对象。
* @param {void*} buffer 用于返回数据的缓冲区。
* @param {uint32_t} size 缓冲区大小。
*
* @return {int32_t} 返回实际读取的字节数。
*/
int32_t fs_file_read(fs_file_t* file, void* buffer, uint32_t size);
/**
* @method fs_file_read_line
*
* 读取一行文本。
* > 需要用二进制格式打开，否则Windows下，系统会修改换行符。
*
* @param {fs_file_t*} file 文件对象。
* @param {char*} buffer 用于返回数据的缓冲区。
* @param {uint32_t} size 缓冲区大小。
*
* @return {int32_t} 返回实际读取的字节数。
*/
int32_t fs_file_read_line(fs_file_t* file, char* buffer, uint32_t size);
/**
* @method fs_file_write
*
* 写入文件。
*
* @param {fs_file_t*} file 文件对象。
* @param {const void*} buffer 数据缓冲区。
* @param {uint32_t} size 数据长度。
*
* @return {int32_t} 返回实际写入的字节数。
*/
int32_t fs_file_write(fs_file_t* file, const void* buffer, uint32_t size);
/**
* @method fs_file_printf
*
* 写入文件。
*
* @param {fs_file_t*} file 文件对象。
* @param {const char* const} format_str 格式化字符串。
*
* @return {int32_t} 返回实际写入的字节数。
*/
int32_t fs_file_printf(fs_file_t* file, const char* const format_str, ...);
/**
* @method fs_file_seek
*
* 定位读写指针到指定的位置。
*
* @param {fs_file_t*} file 文件对象。
* @param {int32_t} offset 数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_seek(fs_file_t* file, int32_t offset);
/**
* @method fs_file_truncate
*
* 清除文件内容。
*
* @param {fs_file_t*} file 文件对象。
* @param {int32_t} offset 数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_truncate(fs_file_t* file, int32_t offset);
/**
* @method fs_file_close
*
* 关闭文件。
*
* @param {fs_file_t*} file 文件对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_close(fs_file_t* file);
/**
* @method fs_file_sync
*
* 同步文件到磁盘。
*
* @param {fs_file_t*} file 文件对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_sync(fs_file_t* file);
/**
* @method fs_file_stat
*
* 获取文件信息。
*
* @param {fs_file_t*} file 文件对象。
* @param {fs_stat_info_t*} fst 文件状态信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_stat(fs_file_t* file, fs_stat_info_t* fst);
/**
* @method fs_file_eof
*
* 判断文件是否结束。
*
* @param {fs_file_t*} file 文件对象。
*
* @return {bool_t} 返回TRUE表示结束，否则表示没结束。
*/
bool_t fs_file_eof(fs_file_t* file);
/**
* @method fs_file_tell
*
* 获取文件当前读写位置。
*
* @param {fs_file_t*} file 文件对象。
*
* @return {int64_t} 返回文件当前读写位置。
*/
int64_t fs_file_tell(fs_file_t* file);
/**
* @method fs_file_size
*
* 获取文件大小。
*
* @param {fs_file_t*} file 文件对象。
*
* @return {int64_t} 返回文件大小。
*/
int64_t fs_file_size(fs_file_t* file);
/**
* @class fs_item_t
* 代表目录或文件。
*/
typedef struct _fs_item_t {
/**
* @property {bool_t} is_dir
* @annotation ["readable"]
* 是否是目录。
*/
bool_t is_dir;
/**
* @property {bool_t} is_link
* @annotation ["readable"]
* 是否是符号链接。
*/
bool_t is_link;
/**
* @property {bool_t} is_reg_file
* @annotation ["readable"]
* 是否是普通文件。
*/
bool_t is_reg_file;
/**
* @property {char*} name
* @annotation ["readable"]
* 名称。
*/
char name[MAX_PATH + 1];
} fs_item_t;
/**
* @method fs_item_create
*
* 创建文件或目录对象。
*
* @return {fs_item_t*} 返回文件或目录对象。
*/
fs_item_t* fs_item_create(void);
/**
* @method fs_item_destroy
*
* 销毁文件或目录对象。
*
* @param {fs_item_t*} item 文件或目录对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_item_destroy(fs_item_t* item);
struct _fs_dir_t;
typedef struct _fs_dir_t fs_dir_t;
typedef ret_t (*fs_dir_rewind_t)(fs_dir_t* dir);
typedef ret_t (*fs_dir_read_t)(fs_dir_t* dir, fs_item_t* item);
typedef ret_t (*fs_dir_close_t)(fs_dir_t* dir);
typedef struct _fs_dir_vtable_t {
fs_dir_rewind_t rewind;
fs_dir_read_t read;
fs_dir_close_t close;
void* data;
} fs_dir_vtable_t;
/**
* @class fs_dir_t
*
* 文件夹接口。
*
*/
struct _fs_dir_t {
const fs_dir_vtable_t* vt;
void* data;
};
/**
* @method fs_dir_rewind
*
* 重置文件夹读取位置到开始。
*
* @param {fs_dir_t*} dir 文件夹对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_dir_rewind(fs_dir_t* dir);
/**
* @method fs_dir_read
*
* 读取文件夹对象。
*
* @param {fs_dir_t*} dir 文件夹对象。
* @param {fs_item_t*} item 返回一项。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_dir_read(fs_dir_t* dir, fs_item_t* item);
/**
* @method fs_dir_close
*
* 关闭文件夹对象。
*
* @param {fs_dir_t*} dir 文件夹对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_dir_close(fs_dir_t* dir);
struct _fs_t;
typedef struct _fs_t fs_t;
typedef fs_file_t* (*fs_open_file_t)(fs_t* fs, const char* name, const char* mode);
typedef ret_t (*fs_remove_file_t)(fs_t* fs, const char* name);
typedef bool_t (*fs_file_exist_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_file_rename_t)(fs_t* fs, const char* name, const char* new_name);
typedef fs_dir_t* (*fs_open_dir_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_remove_dir_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_create_dir_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_change_dir_t)(fs_t* fs, const char* name);
typedef bool_t (*fs_dir_exist_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_dir_rename_t)(fs_t* fs, const char* name, const char* new_name);
typedef int32_t (*fs_get_file_size_t)(fs_t* fs, const char* name);
typedef ret_t (*fs_get_disk_info_t)(fs_t* fs, const char* volume, int32_t* free_kb,
int32_t* total_kb);
typedef ret_t (*fs_get_exe_t)(fs_t* fs, char path[MAX_PATH + 1]);
typedef ret_t (*fs_get_cwd_t)(fs_t* fs, char path[MAX_PATH + 1]);
typedef ret_t (*fs_stat_t)(fs_t* fs, const char* name, fs_stat_info_t* fst);
typedef ret_t (*fs_get_user_storage_path_t)(fs_t* fs, char path[MAX_PATH + 1]);
typedef ret_t (*fs_get_temp_path_t)(fs_t* fs, char path[MAX_PATH + 1]);
/**
* @class fs_t
*
* 文件系统接口。
*
*/
struct _fs_t {
fs_open_file_t open_file;
fs_remove_file_t remove_file;
fs_file_exist_t file_exist;
fs_file_rename_t file_rename;
fs_open_dir_t open_dir;
fs_create_dir_t create_dir;
fs_change_dir_t change_dir;
fs_remove_dir_t remove_dir;
fs_dir_exist_t dir_exist;
fs_dir_rename_t dir_rename;
fs_get_file_size_t get_file_size;
fs_get_disk_info_t get_disk_info;
fs_get_cwd_t get_cwd;
fs_get_exe_t get_exe;
fs_get_user_storage_path_t get_user_storage_path;
fs_stat_t stat;
fs_get_temp_path_t get_temp_path;
};
/**
* @method fs_open_file
*
* 打开文件。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 文件名。
* @param {const char*} mode 打开方式，取值请参考POSIX的[fopen函数](https://www.runoob.com/cprogramming/c-function-fopen.html)相应的参数。
*
* @return {fs_file_t*} 返回非NULL表示成功，否则表示失败。
*/
fs_file_t* fs_open_file(fs_t* fs, const char* name, const char* mode);
/**
* @method fs_remove_file
*
* 刪除文件。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_remove_file(fs_t* fs, const char* name);
/**
* @method fs_file_exist
*
* 判断文件是否存在。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 文件名。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t fs_file_exist(fs_t* fs, const char* name);
/**
* @method fs_file_rename
*
* 文件重命名。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 旧文件名。
* @param {const char*} new_name 新文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_file_rename(fs_t* fs, const char* name, const char* new_name);
/**
* @method fs_copy_file
*
* 拷贝文件。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} src 源文件名。
* @param {const char*} dst 目标文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_copy_file(fs_t* fs, const char* src, const char* dst);
/**
* @method fs_file_equal
*
* 比较二进制文件。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} src 源文件名。
* @param {const char*} dst 目标文件名。
*
* @return {bool_t} 返回TRUE表示相同，否则表示不同。
*/
bool_t fs_file_equal(fs_t* fs, const char* src, const char* dst);
/**
* @method fs_copy_dir
*
* 拷贝目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} src 源目录。
* @param {const char*} dst 目标目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_copy_dir(fs_t* fs, const char* src, const char* dst);
/**
* @method fs_copy_dir_ex
*
* 拷贝目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} src 源目录。
* @param {const char*} dst 目标目录。
* @param {bool_t} overwrite 是否覆盖。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_copy_dir_ex(fs_t* fs, const char* src, const char* dst, bool_t overwrite);
/**
* @method fs_open_dir
*
* 打开目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {fs_dir_t*} 返回非NULL表示成功，否则表示失败。
*/
fs_dir_t* fs_open_dir(fs_t* fs, const char* name);
/**
* @method fs_change_dir
*
* 修改当前目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_change_dir(fs_t* fs, const char* name);
/**
* @method fs_create_dir
*
* 创建目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_create_dir(fs_t* fs, const char* name);
/**
* @method fs_remove_dir
*
* 刪除目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_remove_dir(fs_t* fs, const char* name);
/**
* @method fs_create_dir_r
*
* 递归创建目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_create_dir_r(fs_t* fs, const char* name);
/**
* @method fs_remove_dir_r
*
* 递归刪除目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_remove_dir_r(fs_t* fs, const char* name);
/**
* @method fs_dir_is_empty
*
* 判断目录是否为空。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {bool_t} 返回TRUE表示目录为空，否则表示目录不为空。
*/
bool_t fs_dir_is_empty(fs_t* fs, const char* name);
/**
* @method fs_dir_exist
*
* 判断目录是否存在。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 目录名称。
*
* @return {bool_t} 返回TRUE表示存在，否则表示不存在。
*/
bool_t fs_dir_exist(fs_t* fs, const char* name);
/**
* @method fs_dir_rename
*
* 目录重命名。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 旧目录名称。
* @param {const char*} new_name 新目录名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_dir_rename(fs_t* fs, const char* name, const char* new_name);
/**
* @method fs_get_file_size
*
* 获取文件大小。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 文件名。
*
* @return {int32_t} 返回不是-1表示成功，否则表示失败。
*/
int32_t fs_get_file_size(fs_t* fs, const char* name);
/**
* @method fs_get_disk_info
*
* 获取文件系统信息。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} volume 卷名。
* @param {int32_t*} free_kb 用于返回空闲空间大小(KB)
* @param {int32_t*} total_kb 用于返回总共空间大小(KB)
*
* @return {ret_t} 返回不是-1表示成功，否则表示失败。
*/
ret_t fs_get_disk_info(fs_t* fs, const char* volume, int32_t* free_kb, int32_t* total_kb);
/**
* @method fs_stat
*
* 获取文件信息。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {const char*} name 文件名。
* @param {fs_stat_info_t*} fst 文件状态信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_stat(fs_t* fs, const char* name, fs_stat_info_t* fst);
/**
* @method fs_get_exe
*
* 获取可执行文件所在目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {char*} path 保存可执行文件的路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_get_exe(fs_t* fs, char path[MAX_PATH + 1]);
/**
* @method fs_get_user_storage_path
*
* 获取home目录或者应用程序可以写入数据的目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {char*} path 保存路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_get_user_storage_path(fs_t* fs, char path[MAX_PATH + 1]);
/**
* @method fs_get_temp_path
*
* 获取临时目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {char*} path 保存路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_get_temp_path(fs_t* fs, char path[MAX_PATH + 1]);
/**
* @method fs_get_cwd
*
* 获取当前所在目录。
*
* @param {fs_t*} fs 文件系统对象，一般赋值为os_fs()。
* @param {char*} path 保存当前所在目录的路径。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_get_cwd(fs_t* fs, char path[MAX_PATH + 1]);
/**
* @method fs_build_user_storage_file_name
*
* 生成一个保存数据文件的完整路径的文件名。
*
* @param {char*} filename 用于返回完整路径的文件名。
* @param {const char*} appname 应用程序的名称。
* @param {const char*} name 文件名(不包括路径)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fs_build_user_storage_file_name(char filename[MAX_PATH + 1], const char* appname,
const char* name);
/**
* @method os_fs
* 获取缺省的文件系统对象。
* @annotation ["constructor"]
* @return {fs_t*} 返回文件系统对象。
*/
fs_t* os_fs(void);
/*wrapper*/
/**
* @method fs_foreach_file
*
* 遍历指定目录下全部常规文件。
* 示例:
* ```c
* static ret_t on_file(void* ctx, const void* data) {
* const char* filename = (const char*)data;
* const char* extname = (const char*)ctx;
*
* if (tk_str_end_with(filename, extname)) {
* log_debug("%s\n", filename);
* }
* return RET_OK;
* }
* ...
* fs_foreach_file("tests/testdata", on_file, (void*)".json");
*```
*
* @param {const char*} path 目录。
* @param {tk_visit_t} on_file 回调函数(完整文件名通过data参数传入)。
* @param {void*} ctx 回调函数上下文。
*
* @return {ret_t} 返回TRUE表示成功，否则表示失败。
*/
ret_t fs_foreach_file(const char* path, tk_visit_t on_file, void* ctx);
/**
* @method file_exist
*
* 判断文件是否存在。
*
* @param {const char*} name 文件名。
*
* @return {bool_t} 返回TRUE表示成功，否则表示失败。
*/
bool_t file_exist(const char* name);
/**
* @method dir_exist
*
* 判断目录是否存在。
*
* @param {const char*} name 目录名。
*
* @return {bool_t} 返回TRUE表示成功，否则表示失败。
*/
bool_t dir_exist(const char* name);
/**
* @method file_remove
*
* 刪除文件。
*
* @param {const char*} name 文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_remove(const char* name);
/**
* @method file_get_size
*
* 获取文件大小。
*
* @param {const char*} name 文件名。
*
* @return {int32_t} 返回非负表示文件大小，否则表示失败。
*/
int32_t file_get_size(const char* name);
/**
* @method file_read
*
* 读取文件的全部内容。
*
* @param {const char*} name 文件名。
* @param {uint32_t*} size 返回实际读取的长度。
*
* @return {void*} 返回读取的数据，需要调用TKMEM_FREE释放。
*/
void* file_read(const char* name, uint32_t* size);
/**
* @method file_read_part
*
* 从某个位置读取文件。
*
* @param {const char*} name 文件名。
* @param {void*} buff 数据缓冲区。
* @param {uint32_t} size 数据长度。
* @param {uint32_t} offset 偏移量。
*
* @return {int32_t} 返回实际读取的字节数。
*/
int32_t file_read_part(const char* name, void* buff, uint32_t size, uint32_t offset);
/**
* @method file_write
*
* 写入文件。
*
* @param {const char*} name 文件名。
* @param {const void*} buff 数据缓冲区。
* @param {uint32_t} size 数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_write(const char* name, const void* buff, uint32_t size);
/*basic function test*/
ret_t fs_test(fs_t* fs);
ret_t fs_test_file(fs_t* fs);
ret_t fs_test_dir(fs_t* fs);
END_C_DECLS
#endif /*TK_FS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/ext_widgets/ext_widgets.h
|
/**
* File: ext_widgets.h
* Author: AWTK Develop Team
* Brief: ext widgets
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-07 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EXT_WIDGETS_H
#define TK_EXT_WIDGETS_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class ext_widgets_t
* 扩展控件。
* @annotation ["scriptable", "fake"]
*
*/
/**
* @method tk_ext_widgets_init
* 初始化AWTK扩展控件。
* @alias ext_widgets_init
* @annotation ["static", "scriptable"]
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_ext_widgets_init(void);
END_C_DECLS
#endif /*TK_EXT_WIDGETS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/ext_widgets/README.md
|
# 扩展控件
### 1.使用注意事项
* 1. 部分控件不适合在低端平台使用。
* 2. 部分控件需要 vgcanvas 支持。
* 3. 部分控件需要 widget 动画效果配合。
### 2.扩展控件在低端平台的使用情况
测试平台为 stm32f103 ，ram 为 64 kb，flash 为 512 kb，采用**片段式显存的方案**来测试（*片段式显存方案不支持 vgcanvas*）并且**开启了 widget 动画效果**，该测试不考虑实际效果，因为如果控件刷新面积很大，会导致刷新次数变多和刷新效率减低，影响实际的效果，所以本测试只确定扩展控件是否正常工作，而且在低端平台使用扩展控件需要注意比较多的问题，最好是先了解该扩张控件的代码原理才使用，否则容易出现奇怪的问题，所以低端平台慎用扩展控件。
| 控件文件夹名字 | 是否正常工作 | 注意事项 |
| --------------- | ------------ | ------------------------------------------------------------ |
| canvas_widget | 是 | 需要注意平台是否支持 vgcanvas ，否则调用 vgcanvas 对应的接口会失效。 |
| color_picker | 是 | 需要注意平台的内存是否足够，color_component 控件需要开辟一块和该控件宽高一样的32位色的图片内存。 |
| combo_box_ex | 是 | |
| features | 是 | |
| file_browser | 否 | 需要文件系统支持。 |
| gif_image | 否 | 因为 imagegen 工具暂时不支持生成 gif 格式的资源。 |
| guage | 否 | 因为需要 vgcanvas 支持。 |
| image_animation | 是 | |
| image_value | 是 | |
| keyboard | 是 | 需要注意内存是否足够，因为软键盘会创建大量的 button 控件。 |
| mledit | 是 | |
| mutable_image | 是 | 但是旋转部分没有了，因为旋转需要支持 vgcanvas 。 |
| progress_circle | 否 | 因为需要 vgcanvas 支持。 |
| rich_text | 是 | 但是需要 widget 动画效果配合。 |
| scroll_label | 是 | 但是需要 widget 动画效果配合。 |
| scroll_view | 是 | 但是需要 widget 动画效果配合。 |
| slide_menu | 是 | 但是需要 widget 动画效果配合。 |
| slide_view | 是 | 但是需要 widget 动画效果配合， slide_indicator 控件只使用 stroke_rect 和 fill_rect 效果，不能使用画圆形的效果，因为画圆需要 vgcanvas 支持。 |
| svg_image | 否 | 因为需要 vgcanvas 支持。 |
| switch | 是 | 但是没有圆角的效果，因为圆角效果需要 vgcanvas 支持。 |
| text_selector | 是 | 但是需要 widget 动画效果配合。 |
| time_clock | 否 | 因为需要 vgcanvas 支持。 |
> 备注：在低端平台中 widget 动画效果和扩展控件一般都会被禁止的，所以需要手动把 WITHOUT_WIDGET_ANIMATORS 和 WITHOUT_EXT_WIDGETS 宏取消定义可以正常使用。
|
0 |
repos/awtk/src
|
repos/awtk/src/ext_widgets/ext_widgets.c
|
/**
* File: ext_widgets.c
* Author: AWTK Develop Team
* Brief: ext widgets
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-07 Li XianJing <[email protected]> created
*
*/
#include "base/widget.h"
#if defined(WITH_SDL) || defined(LINUX)
#ifndef WITH_WIDGET_VPAGE
#define WITH_WIDGET_VPAGE 1
#endif /*WITH_WIDGET_VPAGE*/
#ifndef WITH_WIDGET_TIMER
#define WITH_WIDGET_TIMER 1
#endif /*WITH_WIDGET_TIMER*/
#ifndef WITH_WIDGET_SERIAL
#define WITH_WIDGET_SERIAL 1
#endif /*WITH_WIDGET_SERIAL*/
#endif /*WITH_SDL*/
#include "ext_widgets.h"
#include "vpage/vpage.h"
#include "timer_widget/timer_widget.h"
#include "serial_widget/serial_widget.h"
#include "switch/switch.h"
#include "gauge/gauge.h"
#include "mledit/mledit.h"
#include "features/draggable.h"
#include "mledit/line_number.h"
#include "gauge/gauge_pointer.h"
#include "gif_image/gif_image.h"
#include "svg_image/svg_image.h"
#include "keyboard/keyboard.h"
#include "keyboard/candidates.h"
#include "keyboard/lang_indicator.h"
#include "base/widget_factory.h"
#include "rich_text/rich_text.h"
#include "rich_text/rich_text_view.h"
#include "slide_menu/slide_menu.h"
#include "image_value/image_value.h"
#include "time_clock/time_clock.h"
#include "scroll_view/list_item.h"
#include "scroll_view/list_item_seperator.h"
#include "scroll_view/list_view.h"
#include "slide_view/slide_view.h"
#include "scroll_view/scroll_bar.h"
#include "scroll_view/scroll_view.h"
#include "scroll_view/list_view_h.h"
#include "combo_box_ex/combo_box_ex.h"
#include "color_picker/color_picker.h"
#include "scroll_label/hscroll_label.h"
#include "slide_view/slide_indicator.h"
#include "canvas_widget/canvas_widget.h"
#include "text_selector/text_selector.h"
#include "color_picker/color_component.h"
#include "progress_circle/progress_circle.h"
#include "image_animation/image_animation.h"
#include "mutable_image/mutable_image.h"
#include "base/children_layouter_factory.h"
#include "scroll_view/children_layouter_list_view.h"
#if defined(WITH_FS_RES) || defined(WITH_FS)
#include "file_browser/file_browser_view.h"
#endif /*WITH_FS*/
static ret_t children_layouter_register_ext_builtins(void) {
children_layouter_factory_t* f = children_layouter_factory();
children_layouter_factory_register(f, CHILDREN_LAYOUTER_LIST_VIEW,
children_layouter_list_view_create);
return RET_OK;
}
ret_t tk_ext_widgets_init(void) {
widget_factory_t* f = widget_factory();
FACTORY_TABLE_BEGIN(s_ext_widgets)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_RICH_TEXT, rich_text_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_RICH_TEXT_VIEW, rich_text_view_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_COLOR_PICKER, color_picker_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_COLOR_COMPONENT, color_component_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SCROLL_VIEW, scroll_view_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LIST_VIEW, list_view_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LIST_VIEW_H, list_view_h_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LIST_ITEM, list_item_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LIST_ITEM_SEPERATOR, list_item_seperator_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SCROLL_BAR, scroll_bar_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SCROLL_BAR_DESKTOP, scroll_bar_create_desktop)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SCROLL_BAR_MOBILE, scroll_bar_create_mobile)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SLIDE_VIEW, slide_view_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SLIDE_INDICATOR, slide_indicator_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SLIDE_INDICATOR_ARC, slide_indicator_create_arc)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_KEYBOARD, keyboard_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LANG_INDICATOR, lang_indicator_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_CANDIDATES, candidates_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_TIME_CLOCK, time_clock_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_GAUGE, gauge_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_GAUGE_POINTER, gauge_pointer_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_TEXT_SELECTOR, text_selector_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SWITCH, switch_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_IMAGE_ANIMATION, image_animation_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_PROGRESS_CIRCLE, progress_circle_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SVG_IMAGE, svg_image_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_GIF_IMAGE, gif_image_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_CANVAS_WIDGET, canvas_widget_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_IMAGE_VALUE, image_value_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SLIDE_MENU, slide_menu_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_MUTABLE_IMAGE, mutable_image_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_MLEDIT, mledit_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_LINE_NUMBER, line_number_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_HSCROLL_LABEL, hscroll_label_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_COMBO_BOX_EX, combo_box_ex_create)
FACTORY_TABLE_ENTRY(WIDGET_TYPE_DRAGGABLE, draggable_create)
FACTORY_TABLE_ENTRY("guage", gauge_create)
FACTORY_TABLE_ENTRY("guage_pointer", gauge_pointer_create)
#ifdef WITH_WIDGET_TIMER
FACTORY_TABLE_ENTRY(WIDGET_TYPE_TIMER_WIDGET, timer_widget_create)
#endif /*WITH_WIDGET_TIMER*/
#ifdef WITH_WIDGET_SERIAL
FACTORY_TABLE_ENTRY(WIDGET_TYPE_SERIAL_WIDGET, serial_widget_create)
#endif /*WITH_WIDGET_SERIAL*/
#ifdef WITH_WIDGET_VPAGE
FACTORY_TABLE_ENTRY(WIDGET_TYPE_VPAGE, vpage_create)
#endif /*WITH_WIDGET_VPAGE*/
#ifdef TK_FILE_BROWSER_VIEW_H
FACTORY_TABLE_ENTRY(WIDGET_TYPE_FILE_BROWSER_VIEW, file_browser_view_create)
#endif /*TK_FILE_BROWSER_VIEW_H*/
FACTORY_TABLE_END()
children_layouter_register_ext_builtins();
return widget_factory_register_multi(f, s_ext_widgets);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/image_value/image_value.c
|
/**
* File: image_value.h
* Author: AWTK Develop Team
* Brief: image_value
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-01 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "image_value/image_value.h"
static ret_t image_value_draw_images(widget_t* widget, canvas_t* c,
char bitmap_name[IMAGE_VALUE_MAX_CHAR_NR][TK_NAME_LEN + 1],
uint32_t nr) {
int32_t x = 0;
int32_t y = 0;
int32_t i = 0;
int32_t w = 0;
int32_t h = 0;
float scale_w = 1;
float scale_h = 1;
float_t ratio = c->lcd->ratio;
style_t* style = widget->astyle;
rect_t content_r = widget_get_content_area(widget);
int32_t align_v = style_get_int(style, STYLE_ID_TEXT_ALIGN_V, ALIGN_V_MIDDLE);
int32_t align_h = style_get_int(style, STYLE_ID_TEXT_ALIGN_H, ALIGN_H_CENTER);
image_draw_type_t draw_type =
(image_draw_type_t)style_get_int(style, STYLE_ID_FG_IMAGE_DRAW_TYPE, IMAGE_DRAW_DEFAULT);
for (i = 0; i < nr; i++) {
bitmap_t b;
return_value_if_fail(widget_load_image(widget, bitmap_name[i], &b) == RET_OK, RET_BAD_PARAMS);
w += b.w;
if (h < b.h) {
h = b.h;
}
}
w = w / ratio;
h = h / ratio;
return_value_if_fail(w > 0 && h > 0 && content_r.w > 0 && content_r.h > 0, RET_BAD_PARAMS);
scale_h = (float)(content_r.h) / (float)h;
scale_w = (float)(content_r.w) / (float)w;
switch (draw_type) {
case IMAGE_DRAW_SCALE_AUTO: {
scale_w = tk_min(scale_w, scale_h);
scale_h = scale_w;
break;
}
case IMAGE_DRAW_SCALE_W: {
scale_h = scale_w;
break;
}
case IMAGE_DRAW_SCALE_H: {
scale_w = scale_h;
break;
}
case IMAGE_DRAW_SCALE: {
break;
}
default: {
scale_w = 1;
scale_h = 1;
break;
}
}
w = scale_w * w;
h = scale_h * h;
switch (align_h) {
case ALIGN_H_LEFT: {
x = content_r.x;
break;
}
case ALIGN_H_RIGHT: {
x = content_r.x + content_r.w - w;
break;
}
default: {
x = (widget->w - w) / 2;
break;
}
}
switch (align_v) {
case ALIGN_V_TOP: {
y = content_r.y;
break;
}
case ALIGN_V_BOTTOM: {
y = content_r.y + content_r.h - h;
break;
}
default: {
y = (widget->h - h) / 2;
break;
}
}
for (i = 0; i < nr; i++) {
bitmap_t b;
return_value_if_fail(widget_load_image(widget, bitmap_name[i], &b) == RET_OK, RET_BAD_PARAMS);
rect_t s = rect_init(0, 0, b.w, b.h);
rect_t d = rect_init(x, y, scale_w * b.w / ratio, scale_h * b.h / ratio);
canvas_draw_image(c, &b, &s, &d);
x += d.w;
}
return RET_OK;
}
static ret_t image_value_on_paint_self(widget_t* widget, canvas_t* c) {
uint32_t i = 0;
uint32_t nr = 0;
char sub_name[8];
const char* format = NULL;
char str[IMAGE_VALUE_MAX_CHAR_NR + 1];
char bitmap_name[IMAGE_VALUE_MAX_CHAR_NR][TK_NAME_LEN + 1];
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL && widget != NULL, RET_BAD_PARAMS);
format = image_value->format != NULL ? image_value->format : "%d";
return_value_if_fail(image_value->image != NULL, RET_BAD_PARAMS);
memset(sub_name, 0x0, sizeof(sub_name));
memset(bitmap_name, 0x0, sizeof(bitmap_name));
if (strchr(format, 'd') != NULL || strchr(format, 'x') != NULL || strchr(format, 'X') != NULL) {
tk_snprintf(str, IMAGE_VALUE_MAX_CHAR_NR, format, tk_roundi(image_value->value));
} else {
tk_snprintf(str, IMAGE_VALUE_MAX_CHAR_NR, format, image_value->value);
}
nr = strlen(str);
return_value_if_fail(nr > 0, RET_BAD_PARAMS);
for (i = 0; i < nr; i++) {
if (str[i] == '.') {
strcpy(sub_name, IMAGE_VALUE_MAP_DOT);
} else if (str[i] == '/') {
strcpy(sub_name, IMAGE_VALUE_MAP_SLASH);
} else if (str[i] == '+') {
strcpy(sub_name, IMAGE_VALUE_MAP_PLUS);
} else if (str[i] == '-') {
strcpy(sub_name, IMAGE_VALUE_MAP_MINUS);
} else {
sub_name[0] = str[i];
sub_name[1] = '\0';
}
tk_snprintf(bitmap_name[i], TK_NAME_LEN, "%s%s", image_value->image, sub_name);
}
return image_value_draw_images(widget, c, bitmap_name, nr);
}
static ret_t image_value_get_prop(widget_t* widget, const char* name, value_t* v) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_double(v, image_value->value);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MIN)) {
value_set_double(v, image_value->min);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
value_set_double(v, image_value->max);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
value_set_str(v, image_value->image);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
value_set_str(v, image_value->format);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CLICK_ADD_DELTA)) {
value_set_double(v, image_value->click_add_delta);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t image_value_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
return image_value_set_value(widget, value_double(v));
} else if (tk_str_eq(name, WIDGET_PROP_MIN)) {
return image_value_set_min(widget, value_double(v));
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
return image_value_set_max(widget, value_double(v));
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
return image_value_set_image(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
return image_value_set_format(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_CLICK_ADD_DELTA)) {
return image_value_set_click_add_delta(widget, value_double(v));
}
return RET_NOT_FOUND;
}
static ret_t image_value_on_destroy(widget_t* widget) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
TKMEM_FREE(image_value->image);
TKMEM_FREE(image_value->format);
return RET_OK;
}
ret_t image_value_add_delta(widget_t* widget) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
if (image_value->click_add_delta) {
double value = image_value->value;
double min = tk_min(image_value->min, image_value->max);
double max = tk_max(image_value->min, image_value->max);
return_value_if_fail(min < max, RET_BAD_PARAMS);
value = image_value->value + image_value->click_add_delta;
if (value > max) {
value = min;
} else if (value < min) {
value = max;
}
image_value_set_value(widget, value);
}
return RET_OK;
}
static ret_t image_value_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL && widget != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN: {
image_value->pressed = TRUE;
widget_grab(widget->parent, widget);
break;
}
case EVT_POINTER_DOWN_ABORT: {
image_value->pressed = FALSE;
widget_ungrab(widget->parent, widget);
break;
}
case EVT_CLICK: {
image_value_add_delta(widget);
break;
}
case EVT_POINTER_UP: {
if (image_value->pressed) {
pointer_event_t evt = *((pointer_event_t*)e);
evt.e.type = EVT_CLICK;
ret = widget_dispatch(widget, (event_t*)&evt);
image_value->pressed = FALSE;
}
widget_ungrab(widget->parent, widget);
break;
}
default:
break;
}
return ret;
}
static const char* s_image_value_properties[] = {WIDGET_PROP_VALUE,
WIDGET_PROP_MIN,
WIDGET_PROP_MAX,
WIDGET_PROP_FORMAT,
WIDGET_PROP_IMAGE,
WIDGET_PROP_CLICK_ADD_DELTA,
NULL};
TK_DECL_VTABLE(image_value) = {.size = sizeof(image_value_t),
.type = WIDGET_TYPE_IMAGE_VALUE,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.inputable = TRUE,
.clone_properties = s_image_value_properties,
.persistent_properties = s_image_value_properties,
.create = image_value_create,
.on_destroy = image_value_on_destroy,
.on_event = image_value_on_event,
.get_prop = image_value_get_prop,
.set_prop = image_value_set_prop,
.on_paint_self = image_value_on_paint_self};
widget_t* image_value_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(image_value), x, y, w, h);
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, NULL);
return widget;
}
ret_t image_value_set_image(widget_t* widget, const char* image) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL && image != NULL, RET_BAD_PARAMS);
image_value->image = tk_str_copy(image_value->image, image);
return widget_invalidate(widget, NULL);
}
ret_t image_value_set_format(widget_t* widget, const char* format) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL && format != NULL, RET_BAD_PARAMS);
image_value->format = tk_str_copy(image_value->format, format);
return widget_invalidate(widget, NULL);
}
ret_t image_value_set_value(widget_t* widget, double value) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
if (image_value->value != value) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_double(&(evt.old_value), image_value->value);
value_set_double(&(evt.new_value), value);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
image_value->value = value;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
}
return RET_OK;
}
ret_t image_value_set_click_add_delta(widget_t* widget, double click_add_delta) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
image_value->click_add_delta = click_add_delta;
return RET_OK;
}
ret_t image_value_set_min(widget_t* widget, double min) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
image_value->min = min;
return RET_OK;
}
ret_t image_value_set_max(widget_t* widget, double max) {
image_value_t* image_value = IMAGE_VALUE(widget);
return_value_if_fail(image_value != NULL, RET_BAD_PARAMS);
image_value->max = max;
return RET_OK;
}
widget_t* image_value_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, image_value), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/image_value/image_value.h
|
/**
* File: image_value.h
* Author: AWTK Develop Team
* Brief: image_value
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_IMAGE_VALUE_H
#define TK_IMAGE_VALUE_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class image_value_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 图片值控件。
*
* 可以用图片来表示如电池电量、WIFI信号强度和其它各种数值的值。
*
* 其原理如下：
*
* * 1.把value以format为格式转换成字符串。
* * 2.把每个字符与image(图片文件名前缀)映射成一个图片名。
* * 3.最后把这些图片显示出来。
*
* 如果设置click\_add\_delta为非0，那么点击时自动增加指定的增量，值超过最大值时回到最小值,
* 或者值超过最小值时回到最大值。
*
*image\_value\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于image\_value\_t控件。
*
*在xml中使用"image\_value"标签创建图片值控件。如：
*
* ```xml
* <image_value value="0" image="num_" />
* ```
*
* > 更多用法请参考：
* [image\_value](https://github.com/zlgopen/awtk/blob/master/design/default/ui/image_value.xml)
*
* 在c代码中使用函数image\_value\_create创建图片值控件。如：
*
* ```c
* image_value = image_value_create(win, 10, 10, 200, 200);
* image_value_set_image(image_value, "num_");
* image_value_set_value(image_value, 100);
* ```
*
* > 完整示例请参考：
* [image_value demo](https://github.com/zlgopen/awtk-c-demos/blob/master/demos/image_value.c)
*
* 可用通过style来设置控件的显示风格，如背景颜色和边框等等，不过一般情况并不需要。
*
*/
typedef struct _image_value_t {
widget_t widget;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片名称的前缀。
*/
char* image;
/**
* @property {char*} format
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 数值到字符串转换时的格式，缺省为"%d"。
*/
char* format;
/**
* @property {double} click_add_delta
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 点击时加上一个增量。
*/
double click_add_delta;
/**
* @property {double} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 值。
*/
double value;
/**
* @property {double} min
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最小值(如果设置了click\_add\_delta，到达最小值后回到最大值)。
*/
double min;
/**
* @property {double} max
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最大值(如果设置了click\_add\_delta，到达最大值后回到最小值)。
*/
double max;
/*private*/
bool_t pressed;
} image_value_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值即将改变事件(click_add_delta为非0时，点击触发)。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值改变事件(click_add_delta为非0时，点击触发)。
*/
/**
* @method image_value_create
* 创建image_value对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* image_value_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method image_value_set_image
* 设置图片前缀。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_value对象。
* @param {const char*} image 图片前缀。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_image(widget_t* widget, const char* image);
/**
* @method image_value_set_format
* 设置格式。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_value对象。
* @param {const char*} format 格式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_format(widget_t* widget, const char* format);
/**
* @method image_value_set_click_add_delta
* 设置点击时加上的增量。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_value对象。
* @param {double} click_add_delta 增量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_click_add_delta(widget_t* widget, double click_add_delta);
/**
* @method image_value_set_value
* 设置值。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_value对象。
* @param {double} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_value(widget_t* widget, double value);
/**
* @method image_value_set_min
* 设置最小值。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_min对象。
* @param {double} min 最小值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_min(widget_t* widget, double min);
/**
* @method image_value_set_max
* 设置最大值。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_max对象。
* @param {double} max 最大值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_value_set_max(widget_t* widget, double max);
/**
* @method image_value_cast
* 转换为image_value对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget image_value对象。
*
* @return {widget_t*} image_value对象。
*/
widget_t* image_value_cast(widget_t* widget);
#define WIDGET_TYPE_IMAGE_VALUE "image_value"
/* "."不是有效的文件名，所以把字符"."映射成"dot" */
#define IMAGE_VALUE_MAP_DOT "dot"
/* "/"不是有效的文件名，所以把字符"/"映射成"slash" */
#define IMAGE_VALUE_MAP_SLASH "slash"
/* "+"不是有效的文件名，所以把字符"+"映射成"plus" */
#define IMAGE_VALUE_MAP_PLUS "plus"
/* "-"不是有效的文件名，所以把字符"-"映射成"minus" */
#define IMAGE_VALUE_MAP_MINUS "minus"
#define WIDGET_PROP_CLICK_ADD_DELTA "click_add_delta"
#ifndef IMAGE_VALUE_MAX_CHAR_NR
#define IMAGE_VALUE_MAX_CHAR_NR 8
#endif /*IMAGE_VALUE_MAX_CHAR_NR*/
#define IMAGE_VALUE(widget) ((image_value_t*)(image_value_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(image_value);
/*public for test*/
ret_t image_value_add_delta(widget_t* widget);
END_C_DECLS
#endif /*TK_IMAGE_VALUE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/lang_indicator.h
|
/**
* File: lang_indicator.h
* Author: AWTK Develop Team
* Brief: lang_indicator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-04-20 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LANG_INDICATOR_H
#define TK_LANG_INDICATOR_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class lang_indicator_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
*
* 输入法语言指示器。
*
* 用于显示输入法的输入语言或类型，主要用于T9输入法。
*
* lang_indicator\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于lang_indicator\_t控件。
*
* 在xml中使用"lang_indicator"标签创建lang_indicator。如：
*
* ```xml
* <lang_indicator x="0" y="0" w="100%" h="100%" children_layout="default(c=2,r=2,m=5,s=5)">
* </lang_indicator>
* ```
*
* 可用通过style来设置控件的显示风格，如背景颜色等。如：
*
* ```xml
* <style name="default" border_color="#a0a0a0">
* <normal bg_color="#f0f0f0" />
* </style>
* ```
*/
typedef struct _lang_indicator_t {
widget_t widget;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
*
* 如果希望用图片格式显示，本属性用于指定图片的前缀。
*
*/
char* image;
/*private*/
uint32_t event_id;
} lang_indicator_t;
/**
* @method lang_indicator_create
* 创建lang_indicator对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* lang_indicator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method lang_indicator_set_image
* 设置缺省获得焦点的子控件(可用控件名或类型)。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} image 缺省获得焦点的子控件(可用控件名或类型)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t lang_indicator_set_image(widget_t* widget, const char* image);
/**
* @method lang_indicator_cast
* 转换为lang_indicator对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget lang_indicator对象。
*
* @return {widget_t*} lang_indicator对象。
*/
widget_t* lang_indicator_cast(widget_t* widget);
#define WIDGET_TYPE_LANG_INDICATOR "lang_indicator"
#define LANG_INDICATOR(widget) ((lang_indicator_t*)(lang_indicator_cast(WIDGET(widget))))
END_C_DECLS
#endif /*TK_LANG_INDICATOR_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/lang_indicator.c
|
/**
* File: lang_indicator.h
* Author: AWTK Develop Team
* Brief: lang_indicator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-04-20 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/input_method.h"
#include "keyboard/lang_indicator.h"
static ret_t lang_indicator_on_lang_changed(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
widget_invalidate_force(widget, NULL);
return RET_OK;
}
static ret_t lang_indicator_get_prop(widget_t* widget, const char* name, value_t* v) {
lang_indicator_t* lang_indicator = LANG_INDICATOR(widget);
return_value_if_fail(lang_indicator != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
value_set_str(v, lang_indicator->image);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t lang_indicator_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
return lang_indicator_set_image(widget, value_str(v));
}
return RET_NOT_FOUND;
}
static ret_t lang_indicator_on_destroy(widget_t* widget) {
lang_indicator_t* lang_indicator = LANG_INDICATOR(widget);
return_value_if_fail(lang_indicator != NULL, RET_BAD_PARAMS);
input_method_off(input_method(), lang_indicator->event_id);
lang_indicator->event_id = TK_INVALID_ID;
TKMEM_FREE(lang_indicator->image);
return RET_OK;
}
static ret_t lang_indicator_on_paint_self(widget_t* widget, canvas_t* c) {
wstr_t* str = &(widget->text);
lang_indicator_t* lang_indicator = LANG_INDICATOR(widget);
const char* lang = input_method_get_lang(input_method());
return_value_if_fail(lang_indicator != NULL, RET_BAD_PARAMS);
if (lang_indicator->image != NULL) {
char icon[128];
tk_snprintf(icon, sizeof(icon), "%s%s", lang_indicator->image, lang != NULL ? lang : "none");
widget_paint_helper(widget, c, icon, NULL);
} else {
wstr_set_utf8(str, lang != NULL ? lang : "");
widget_paint_helper(widget, c, NULL, NULL);
}
return RET_OK;
}
static ret_t lang_indicator_init(widget_t* widget) {
lang_indicator_t* lang_indicator = LANG_INDICATOR(widget);
return_value_if_fail(lang_indicator != NULL, RET_BAD_PARAMS);
lang_indicator->event_id =
input_method_on(input_method(), EVT_IM_LANG_CHANGED, lang_indicator_on_lang_changed, widget);
return RET_OK;
}
TK_DECL_VTABLE(lang_indicator) = {.size = sizeof(lang_indicator_t),
.type = WIDGET_TYPE_LANG_INDICATOR,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.set_prop = lang_indicator_set_prop,
.get_prop = lang_indicator_get_prop,
.on_destroy = lang_indicator_on_destroy,
.on_paint_self = lang_indicator_on_paint_self,
.init = lang_indicator_init,
.create = lang_indicator_create};
widget_t* lang_indicator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(lang_indicator), x, y, w, h);
return_value_if_fail(lang_indicator_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* lang_indicator_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, lang_indicator), NULL);
return widget;
}
ret_t lang_indicator_set_image(widget_t* widget, const char* image) {
lang_indicator_t* lang_indicator = LANG_INDICATOR(widget);
return_value_if_fail(lang_indicator != NULL, RET_BAD_PARAMS);
return_value_if_fail(image != NULL, RET_BAD_PARAMS);
lang_indicator->image = tk_str_copy(lang_indicator->image, image);
return RET_OK;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/keyboard.c
|
/**
* File: keyboard.c
* Author: AWTK Develop Team
* Brief: keyboard
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/keys.h"
#include "tkc/utils.h"
#include "base/enums.h"
#include "widgets/pages.h"
#include "base/locale_info.h"
#include "keyboard/keyboard.h"
#include "base/input_method.h"
#include "base/window_manager.h"
#define WIDGET_PROP_IM_LANG "lang"
#define WIDGET_PROP_PREEDIT_INDEX "preedit_index"
static ret_t keyboard_on_load(void* ctx, event_t* e);
static ret_t keyboard_on_action_info(void* ctx, event_t* e);
static const char* s_keyboard_properties[] = {WIDGET_PROP_ANIM_HINT, WIDGET_PROP_OPEN_ANIM_HINT,
WIDGET_PROP_CLOSE_ANIM_HINT, WIDGET_PROP_THEME, NULL};
static ret_t keyboard_on_destroy(widget_t* widget) {
keyboard_t* keyboard = KEYBOARD(widget);
return_value_if_fail(keyboard != NULL, RET_BAD_PARAMS);
input_method_off(input_method(), keyboard->action_info_id);
darray_deinit(&(keyboard->action_buttons));
str_reset(&(keyboard->temp));
return window_base_on_destroy(widget);
}
static ret_t keyboard_on_event(widget_t* widget, event_t* e) {
keyboard_t* keyboard = KEYBOARD(widget);
return_value_if_fail(keyboard != NULL, RET_BAD_PARAMS);
if (e->type == EVT_KEY_DOWN || e->type == EVT_KEY_UP) {
key_event_t* evt = (key_event_t*)e;
/*goto here only when grab_keys=true*/
if (evt->key == TK_KEY_LEFT || evt->key == TK_KEY_RIGHT || evt->key == TK_KEY_DOWN ||
evt->key == TK_KEY_UP) {
/*let window move focus*/
return RET_OK;
}
if (e->type == EVT_KEY_DOWN) {
keyboard->key_down++;
} else {
if (keyboard->key_down > 0) {
input_method_dispatch_key(input_method(), evt->key);
keyboard->key_down--;
}
}
return RET_STOP;
}
return window_base_on_event(widget, e);
}
static ret_t keyboard_init(widget_t* widget) {
keyboard_t* keyboard = KEYBOARD(widget);
return_value_if_fail(keyboard != NULL, RET_BAD_PARAMS);
str_init(&(keyboard->temp), 0);
darray_init(&(keyboard->action_buttons), 0, NULL, NULL);
widget_on(widget, EVT_WINDOW_LOAD, keyboard_on_load, widget);
keyboard->action_info_id =
input_method_on(input_method(), EVT_IM_ACTION_INFO, keyboard_on_action_info, widget);
return RET_OK;
}
TK_DECL_VTABLE(keyboard) = {.size = sizeof(keyboard_t),
.type = WIDGET_TYPE_KEYBOARD,
.is_window = TRUE,
.is_keyboard = TRUE,
.clone_properties = s_keyboard_properties,
.persistent_properties = s_keyboard_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(window_base),
.create = keyboard_create,
.init = keyboard_init,
.on_event = keyboard_on_event,
.on_paint_self = window_base_on_paint_self,
.on_paint_begin = window_base_on_paint_begin,
.on_paint_end = window_base_on_paint_end,
.set_prop = window_base_set_prop,
.get_prop = window_base_get_prop,
.on_destroy = keyboard_on_destroy};
widget_t* keyboard_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = window_base_create(parent, TK_REF_VTABLE(keyboard), x, y, w, h);
return_value_if_fail(keyboard_init(widget) == RET_OK, NULL);
return widget;
}
static ret_t on_visit_widget_to_focus_first(void* ctx, const void* data) {
widget_t* w = WIDGET(data);
return_value_if_fail(w != NULL, RET_BAD_PARAMS);
if (w->focusable) {
widget_set_focused(w, TRUE);
return RET_STOP;
}
return RET_OK;
}
static ret_t keyboard_focus_first(widget_t* page) {
widget_foreach(page, on_visit_widget_to_focus_first, NULL);
return RET_OK;
}
static ret_t keyboard_set_active_page(widget_t* button, const char* name) {
widget_t* iter = button;
while (iter != NULL) {
const char* type = widget_get_type(iter);
if (tk_str_eq(type, WIDGET_TYPE_PAGES)) {
break;
}
iter = iter->parent;
}
return_value_if_fail(iter != NULL, RET_FAIL);
if (pages_set_active_by_name(iter, name) == RET_OK) {
value_t v;
widget_t* active = widget_get_child(iter, widget_get_value(iter));
if (widget_get_prop(active, WIDGET_PROP_IM_LANG, &v) == RET_OK) {
input_method_set_lang(input_method(), value_str(&v));
}
keyboard_focus_first(widget_get_child(iter, PAGES(iter)->active));
}
return RET_OK;
}
#define STR_BACK "back"
#define STR_CLOSE "close"
#define STR_CLEAR "clear"
#define STR_CANCEL "cancel"
#define STR_RETURN "return"
#define STR_ACTION "action"
#define STR_KEY_SPACE "space"
#define STR_BACK_TO_HOME "back_to_home"
#define STR_KEY_OPT "opt:"
#define STR_KEY_TAB "tab"
#define STR_KEY_PREFIX "key:"
#define STR_PAGE_PREFIX "page:"
#define STR_HARD_KEY_PREFIX "hard_key:"
#define STR_KEY_BACKSPACE "backspace"
#define STR_KEY_CONFIRM_PREEDIT "confirm_preedit"
#ifndef PREEDIT_TIMER_DURATION
#define PREEDIT_TIMER_DURATION 800
#endif /*PREEDIT_TIMER_DURATION*/
static ret_t keyboard_preedit_confirm(widget_t* widget) {
input_method_t* im = input_method();
keyboard_t* keyboard = KEYBOARD(widget);
return_value_if_fail(keyboard != NULL, RET_BAD_PARAMS);
input_method_dispatch_preedit_confirm(im);
widget_set_prop_int(widget, WIDGET_PROP_PREEDIT_INDEX, -1);
keyboard->timer_id = TK_INVALID_ID;
return RET_OK;
}
static ret_t keyboard_on_preedit_timeout(const timer_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
keyboard_preedit_confirm(WIDGET(info->ctx));
return RET_REMOVE;
}
static ret_t keyboard_on_button_click(void* ctx, event_t* e) {
input_method_t* im = input_method();
widget_t* button = WIDGET(e->target);
widget_t* win = widget_get_window(button);
keyboard_t* keyboard = KEYBOARD(win);
return_value_if_fail(im != NULL && keyboard != NULL && button != NULL, RET_BAD_PARAMS);
const char* name = button->name;
const char* opt = strstr(name, STR_KEY_OPT);
const char* key = strstr(name, STR_KEY_PREFIX);
const char* hard_key = strstr(name, STR_HARD_KEY_PREFIX);
const char* page_name = strstr(name, STR_PAGE_PREFIX);
if (keyboard->last_click_button != button) {
if (keyboard->timer_id != TK_INVALID_ID) {
timer_remove(keyboard->timer_id);
keyboard_preedit_confirm(win);
}
}
keyboard->last_click_button = button;
if (tk_str_eq(name, STR_CLOSE)) {
input_method_request(im, NULL);
return RET_OK;
}
if (tk_str_eq(name, STR_CLEAR)) {
event_t e = event_init(EVT_IM_CLEAR, NULL);
input_method_dispatch_to_widget(im, &e);
return RET_OK;
}
if (tk_str_eq(name, STR_CANCEL)) {
event_t e = event_init(EVT_IM_CANCEL, NULL);
input_method_dispatch_to_widget(im, &e);
return RET_OK;
}
if (tk_str_eq(name, STR_BACK)) {
window_manager_back(window_manager());
return RET_OK;
}
if (tk_str_eq(name, STR_BACK_TO_HOME)) {
window_manager_back_to_home(window_manager());
return RET_OK;
}
if (page_name != NULL) {
return keyboard_set_active_page(button, page_name + strlen(STR_PAGE_PREFIX));
} else if (hard_key != NULL) {
const key_type_value_t* kv = NULL;
key_event_t evt;
widget_t* wm = window_manager();
hard_key += strlen(STR_HARD_KEY_PREFIX);
kv = keys_type_find(hard_key);
return_value_if_fail(kv != NULL, RET_BAD_PARAMS);
window_manager_dispatch_input_event(wm, key_event_init(&evt, EVT_KEY_DOWN, wm, kv->value));
window_manager_dispatch_input_event(wm, key_event_init(&evt, EVT_KEY_UP, wm, kv->value));
return RET_OK;
} else if (key != NULL) {
const key_type_value_t* kv = NULL;
key += strlen(STR_KEY_PREFIX);
kv = keys_type_find(key);
return_value_if_fail(kv != NULL, RET_BAD_PARAMS);
return input_method_dispatch_key(im, kv->value);
} else if (opt != NULL) {
str_t* str = &(keyboard->temp);
int32_t index = widget_get_prop_int(win, WIDGET_PROP_PREEDIT_INDEX, -1);
if (index < 0) {
index = -1;
input_method_dispatch_preedit(im);
}
if (keyboard->timer_id == TK_INVALID_ID) {
keyboard->timer_id =
widget_add_timer(win, keyboard_on_preedit_timeout, PREEDIT_TIMER_DURATION);
} else {
timer_modify(keyboard->timer_id, PREEDIT_TIMER_DURATION);
}
index = (index + 1) % button->text.size;
str_from_wstr_with_len(str, button->text.str + index, 1);
widget_set_prop_int(win, WIDGET_PROP_PREEDIT_INDEX, index);
return input_method_commit_text(input_method(), str->str);
} else if (tk_str_eq(name, STR_KEY_CONFIRM_PREEDIT)) {
if (keyboard->timer_id != TK_INVALID_ID) {
timer_remove(keyboard->timer_id);
keyboard_preedit_confirm(win);
}
return RET_OK;
} else {
if (tk_str_eq(name, STR_ACTION)) {
return input_method_dispatch_action(im);
} else if (tk_str_eq(name, STR_KEY_SPACE)) {
name = " ";
}
return input_method_commit_text(input_method(), name);
}
}
static ret_t keyboard_update_action_button_info(widget_t* button, const char* text, bool_t enable) {
text = locale_info_tr(locale_info(), (TK_STR_IS_NOT_EMPTY(text) ? text : STR_RETURN));
widget_set_text_utf8(button, text);
widget_set_enable(button, enable);
return RET_OK;
}
static ret_t keyboard_on_action_info(void* ctx, event_t* e) {
uint32_t i = 0;
uint32_t nr = 0;
widget_t** buttons = NULL;
input_method_t* im = input_method();
keyboard_t* keyboard = KEYBOARD(ctx);
return_value_if_fail(keyboard != NULL && im != NULL, RET_BAD_PARAMS);
nr = keyboard->action_buttons.size;
buttons = (widget_t**)keyboard->action_buttons.elms;
for (i = 0; i < nr; i++) {
keyboard_update_action_button_info(buttons[i], im->action_button_text,
im->action_button_enable);
}
return RET_OK;
}
static ret_t keyboard_hook_buttons(void* ctx, const void* iter) {
const char* name = NULL;
const char* type = NULL;
widget_t* widget = WIDGET(iter);
input_method_t* im = input_method();
keyboard_t* keyboard = KEYBOARD(ctx);
return_value_if_fail(keyboard != NULL && im != NULL && widget != NULL, RET_BAD_PARAMS);
name = widget->name;
type = widget_get_type(widget);
if (tk_str_eq(type, WIDGET_TYPE_BUTTON) && name != NULL) {
widget_on(widget, EVT_CLICK, keyboard_on_button_click, keyboard);
if (tk_str_eq(name, STR_ACTION)) {
darray_push(&(keyboard->action_buttons), widget);
keyboard_update_action_button_info(widget, im->action_button_text, im->action_button_enable);
}
}
return RET_OK;
}
static ret_t keyboard_on_load(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
widget_t* pages = widget_lookup_by_type(widget, WIDGET_TYPE_PAGES, TRUE);
pages_t* pages_widget = PAGES(pages);
(void)e;
widget_foreach(widget, keyboard_hook_buttons, widget);
if (pages_widget != NULL) {
keyboard_focus_first(widget_get_child(pages, pages_widget->active));
} else {
keyboard_focus_first(widget);
}
return RET_OK;
}
ret_t keyboard_close(widget_t* widget) {
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
return window_manager_close_window(widget->parent, widget);
}
widget_t* keyboard_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, keyboard), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/keyboard.h
|
/**
* File: keyboard.h
* Author: AWTK Develop Team
* Brief: keyboard
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_KEYBOARD_H
#define TK_KEYBOARD_H
#include "base/window_base.h"
BEGIN_C_DECLS
/**
* @class keyboard_t
* @parent window_base_t
* @annotation ["design","widget","window", "scriptable"]
* 软键盘。
*
* 软键盘是一个特殊的窗口，由编辑器通过输入法自动打开和关闭。
*
* 这里介绍一下定制软键盘的方法：
*
* 编辑器输入类型和软键盘UI资源文件的对应关系:
*
*| 输入类型 | 软键盘UI资源文件|
*|----------------|:---------------:|
*| INPUT\_PHONE | kb\_phone.xml |
*| INPUT\_INT | kb\_int.xml |
*| INPUT\_FLOAT | kb\_float.xml |
*| INPUT\_UINT | kb\_uint.xml |
*| INPUT\_UFLOAT | kb\_ufloat.xml |
*| INPUT\_HEX | kb\_hex.xml |
*| INPUT\_EMAIL | kb\_ascii.xml |
*| INPUT\_PASSWORD | kb\_ascii.xml |
*| INPUT\_ASCII | kb\_ascii.xml |
*| INPUT\_CUSTOM | 使用自定义的键盘 |
*| 其它 | kb\_default.xml |
*
* keyboard中按钮子控件的名称有些特殊要求：
*
*| 名称 | 功能 |
*|----------------|:---------------:|
*| return | 回车键 |
*| action | 定制按钮 |
*| backspace | 删除键 |
*| tab | tab键 |
*| space | 空格键 |
*| close | 关闭软键盘 |
*| clear | 清除编辑器的内容 |
*| cancel | 恢复编辑器的内容 |
*| back | 关闭当前窗口 |
*| back_to_home | 返回home窗口 |
*| 前缀key: | 键值 |
*| 前缀hard_key: | 模拟物理键盘 |
*| 前缀page: | 切换到页面 |
*| 前缀opt: | 多个字符选择一个，点击切换到下一个，超时提交字符(用于实现九宫格输入) |
*
* 示例：
*
* * 按键"a"，提交输入法处理。
*
* ```xml
* <button repeat="300" name="key:a" text="a"/>
* ```
*
* * 字符"a"，直接提交到编辑器。
*
* ```xml
* <button repeat="300" name="a" text="a"/>
* ```
*
* * 模拟物理键盘数字"1"，触发key down/up事件（可以用来选择候选字）。
*
* ```xml
* <button repeat="300" name="hard_key:1" text="1"/>
* ```
* * 九宫格输入
*
* ```xml
* <button repeat="300" name="opt:._@/#" text="._@/#"/>
* <button repeat="300" name="opt:abc" text="abc"/>
* <button repeat="300" name="opt:def" text="def"/>
* ```
*
*
* * 输入语言切换
*
* 有的输入法，同时支持输入多种语言。
* 比如T9，可以同时支持中文和英文输入，配合软键盘随时切换输入的语言。
*
* 可以在pages的页面里指定lang属性，切换到该页面时会设置输入法的语言。如：
*
* ```xml
* <pages x="0" y="bottom" w="100%" h="-28" active="2">
* <view name="lower" lang="en_us"
* x="0" y="0" w="100%" h="100%" children_layout="default(r=4,c=4,s=2,m=2)">
* ...
* </view>
* <view name="chinese" lang="zh_cn"
* x="0" y="0" w="100%" h="100%" children_layout="default(r=4,c=4,s=2,m=2)">
* ...
* </view>
* </pages>
* ```
*
* * 键盘跟随。
* 默认情况下，键盘从底部弹出。如果需要让键盘在编辑器附近弹出，可以指定floating属性为true。如：
*
* ```xml
* <keyboard theme="keyboard" w="200" h="200" floating="true">
* ```
*
* > 更多用法请参考：
* [kb_default](https://github.com/zlgopen/awtk/blob/master/design/default/ui/kb_default.xml)
*
*/
typedef struct _keyboard_t {
window_base_t window;
/*private*/
widget_t* last_click_button;
darray_t action_buttons;
uint32_t action_info_id;
uint32_t timer_id;
str_t temp;
int key_down;
} keyboard_t;
/**
* @method keyboard_create
* 创建keyboard对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* keyboard_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method keyboard_close
* 关闭keyboard窗口。
* @annotation ["deconstructor"]
* @param {widget_t*} parent keyboard对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t keyboard_close(widget_t* parent);
/**
* @method keyboard_cast
* 转换为keyboard对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget keyboard对象。
*
* @return {widget_t*} keyboard对象。
*/
widget_t* keyboard_cast(widget_t* widget);
#define KEYBOARD(widget) ((keyboard_t*)(keyboard_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(keyboard);
END_C_DECLS
#endif /*TK_KEYBOARD_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/candidates.c
|
/**
* File: candidates.c
* Author: AWTK Develop Team
* Brief: candidates
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-23 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/utils.h"
#include "widgets/button.h"
#include "keyboard/candidates.h"
#include "base/input_method.h"
#include "base/system_info.h"
#include "base/widget_vtable.h"
static ret_t candidates_init(widget_t* widget);
static ret_t candidates_on_im_candidates_event(void* ctx, event_t* e);
static ret_t candidates_on_button_focused(void* ctx, event_t* e) {
char str[32];
widget_t* button = WIDGET(e->target);
input_method_t* im = input_method();
wstr_t* text = &(button->text);
candidates_t* candidates = CANDIDATES(ctx);
return_value_if_fail(im != NULL && candidates != NULL && text->size > 0, RET_FAIL);
tk_utf8_from_utf16(text->str, str, sizeof(str) - 1);
if (candidates->pre) {
input_method_dispatch_keys(im, str);
}
return RET_OK;
}
static ret_t candidates_on_button_click(void* ctx, event_t* e) {
char str[32];
widget_t* focus = NULL;
widget_t* widget = WIDGET(ctx);
widget_t* button = WIDGET(e->target);
widget_t* keyboard = widget_get_window(widget);
input_method_t* im = input_method();
wstr_t* text = &(button->text);
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(im != NULL, RET_FAIL);
if (text->size > 0) {
wchar_t c = text->str[text->size - 1];
tk_utf8_from_utf16(text->str, str, sizeof(str) - 1);
if (input_method_commit_text(im, str) == RET_OK) {
if (!candidates->pre) {
suggest_words_t* suggest_words = im->suggest_words;
if (suggest_words && suggest_words_find(suggest_words, c) == RET_OK) {
input_method_dispatch_candidates(im, suggest_words->words, suggest_words->words_nr, -1);
if (suggest_words->words_nr > 0) {
widget_set_focused(widget_get_child(button->parent, 0), TRUE);
candidates->is_suggest = TRUE;
} else {
focus = widget_get_focused_widget(keyboard);
widget_focus_down(focus);
}
log_debug("suggest_words->words:%s\n", suggest_words->words);
} else {
focus = widget_get_focused_widget(keyboard);
widget_focus_down(focus);
}
}
/* After commit text, if candidates is hidden we need to blur it and reset key_target! */
if (!widget->visible && keyboard != NULL) {
widget_set_focused(widget, FALSE);
}
}
}
return RET_OK;
}
static ret_t candidates_create_button(widget_t* widget) {
candidates_t* candidates = CANDIDATES(widget);
widget_t* button = button_create(widget, 0, 0, 0, 0);
return_value_if_fail(button != NULL, RET_BAD_PARAMS);
widget_use_style(button, "candidates");
if (candidates->pre) {
widget_on(button, EVT_FOCUS, candidates_on_button_focused, widget);
widget_on(button, EVT_CLICK, candidates_on_button_click, widget);
} else {
widget_on(button, EVT_CLICK, candidates_on_button_click, widget);
}
if (candidates->button_style != NULL) {
widget_use_style(button, candidates->button_style);
}
widget_set_focusable(button, TRUE);
button_set_enable_preview(button, candidates->enable_preview);
return RET_OK;
}
static ret_t candidates_ensure_children(widget_t* widget, uint32_t nr) {
uint32_t i = 0;
uint32_t size = 0;
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
if (widget->children && nr <= widget->children->size) {
return RET_OK;
}
size = widget->children ? widget->children->size : 0;
for (i = size; i < nr; i++) {
candidates_create_button(widget);
}
return_value_if_fail(widget->children != NULL, RET_OOM);
return_value_if_fail(widget->children->size == nr, RET_OOM);
return RET_OK;
}
static uint32_t candidates_calc_child_width(canvas_t* c, widget_t* widget) {
wstr_t* str = &(widget->text);
return canvas_measure_text(c, str->str, str->size);
}
static ret_t candidates_relayout_children(widget_t* widget) {
uint32_t i = 0;
xy_t margin = 2;
uint32_t nr = 0;
wh_t child_w = 0;
xy_t child_x = margin;
xy_t child_y = margin;
widget_t* iter = NULL;
widget_t* focused = NULL;
wh_t child_h = widget->h - margin * 2;
candidates_t* candidates = CANDIDATES(widget);
widget_t** children = (widget_t**)(widget->children->elms);
style_t* style = children[0]->astyle;
canvas_t* c = widget_get_canvas(widget);
const char* font = system_info_fix_font_name(NULL);
int32_t child_margin = style_get_int(style, STYLE_ID_MARGIN, 2);
uint16_t font_size = style_get_int(style, STYLE_ID_FONT_SIZE, TK_DEFAULT_FONT_SIZE);
nr = candidates->candidates_nr;
canvas_set_font(c, font, font_size);
for (i = 0; i < nr; i++) {
iter = children[i];
child_w = candidates_calc_child_width(c, iter) + child_margin * 2;
if (iter->text.size) {
widget_set_enable(iter, TRUE);
widget_set_visible(iter, TRUE, FALSE);
} else {
child_w = 0;
widget_set_enable(iter, FALSE);
widget_set_visible(iter, FALSE, FALSE);
}
widget_move_resize(iter, child_x, child_y, child_w, child_h);
child_x += child_w + margin;
if (iter->focused) {
focused = iter;
}
}
hscrollable_set_virtual_w(candidates->hscrollable, child_x + 30);
if (focused != NULL && focused->x > widget->w / 2) {
hscrollable_set_xoffset(candidates->hscrollable, focused->x);
} else {
hscrollable_set_xoffset(candidates->hscrollable, 0);
}
return RET_OK;
}
static ret_t candidates_update_candidates(widget_t* widget, const char* strs, uint32_t nr,
int32_t selected) {
uint32_t i = 0;
widget_t* iter = NULL;
const char* text = strs;
widget_t** children = NULL;
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL && strs != NULL, RET_BAD_PARAMS);
return_value_if_fail(candidates_ensure_children(widget, nr + 1) == RET_OK, RET_OOM);
children = (widget_t**)(widget->children->elms);
for (i = 0; i < nr; i++) {
iter = children[i];
widget_set_enable(iter, TRUE);
widget_set_visible(iter, TRUE, FALSE);
widget_set_text_utf8(iter, text);
if (selected == i) {
widget_set_focused(iter, TRUE);
} else {
widget_set_focused(iter, FALSE);
}
text += strlen(text) + 1;
}
for (; i < widget->children->size; i++) {
iter = children[i];
widget_set_visible(iter, FALSE, FALSE);
widget_set_enable(iter, FALSE);
widget_set_text_utf8(iter, "");
}
candidates->candidates_nr = nr;
if (candidates->auto_hide) {
widget_set_visible(widget, nr > 0, FALSE);
} else {
widget_set_visible(widget, TRUE, FALSE);
}
candidates_relayout_children(widget);
widget_invalidate_force(widget, NULL);
return RET_OK;
}
static ret_t candidates_on_destroy_default(widget_t* widget) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(widget != NULL && candidates != NULL, RET_BAD_PARAMS);
TKMEM_FREE(candidates->button_style);
hscrollable_destroy(candidates->hscrollable);
input_method_off(input_method(), candidates->event_id);
return RET_OK;
}
static ret_t candidates_on_paint_self(widget_t* widget, canvas_t* c) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(widget != NULL && candidates != NULL, RET_BAD_PARAMS);
return widget_paint_helper(widget, c, NULL, NULL);
}
static ret_t candidates_on_event(widget_t* widget, event_t* e) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
if (e->type == EVT_WINDOW_OPEN) {
if (candidates->pre) {
candidates->event_id = input_method_on(input_method(), EVT_IM_SHOW_PRE_CANDIDATES,
candidates_on_im_candidates_event, candidates);
} else {
candidates->event_id = input_method_on(input_method(), EVT_IM_SHOW_CANDIDATES,
candidates_on_im_candidates_event, candidates);
}
}
return hscrollable_on_event(candidates->hscrollable, e);
}
static ret_t candidates_on_paint_children(widget_t* widget, canvas_t* c) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
return hscrollable_on_paint_children(candidates->hscrollable, c);
}
static ret_t candidates_get_prop(widget_t* widget, const char* name, value_t* v) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, CANDIDATES_PROP_PRE)) {
value_set_bool(v, candidates->pre);
return RET_OK;
} else if (tk_str_eq(name, CANDIDATES_PROP_SELECT_BY_NUM)) {
value_set_bool(v, candidates->select_by_num);
return RET_OK;
} else if (tk_str_eq(name, CANDIDATES_PROP_AUTO_HIDE)) {
value_set_bool(v, candidates->auto_hide);
return RET_OK;
} else if (tk_str_eq(name, CANDIDATES_PROP_BUTTON_STYLE)) {
value_set_str(v, candidates->button_style);
return RET_OK;
} else if (candidates->hscrollable != NULL) {
return hscrollable_get_prop(candidates->hscrollable, name, v);
} else if (tk_str_eq(name, WIDGET_PROP_ENABLE_PREVIEW)) {
value_set_bool(v, candidates->enable_preview);
return RET_OK;
} else {
return RET_NOT_FOUND;
}
}
static ret_t candidates_set_prop(widget_t* widget, const char* name, const value_t* v) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, CANDIDATES_PROP_PRE)) {
return candidates_set_pre(widget, value_bool(v));
} else if (tk_str_eq(name, CANDIDATES_PROP_SELECT_BY_NUM)) {
return candidates_set_select_by_num(widget, value_bool(v));
} else if (tk_str_eq(name, CANDIDATES_PROP_AUTO_HIDE)) {
return candidates_set_auto_hide(widget, value_bool(v));
} else if (tk_str_eq(name, CANDIDATES_PROP_BUTTON_STYLE)) {
return candidates_set_button_style(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_ENABLE_PREVIEW)) {
candidates->enable_preview = value_bool(v);
return RET_OK;
}
if (candidates->hscrollable != NULL) {
return hscrollable_set_prop(candidates->hscrollable, name, v);
} else {
return RET_NOT_FOUND;
}
}
static ret_t candidates_move_focus(widget_t* widget, bool_t next) {
uint32_t nr = 0;
widget_t* focus = NULL;
int32_t next_focus = 0;
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
nr = candidates->candidates_nr;
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
if (iter->focused) {
if (next) {
next_focus = i + 1;
} else {
if (i > 0) {
next_focus = i - 1;
}
}
}
WIDGET_FOR_EACH_CHILD_END();
next_focus = next_focus % nr;
focus = widget_get_child(widget, next_focus);
widget_set_focused(focus, TRUE);
return RET_OK;
}
static ret_t candidates_on_keyup(widget_t* widget, key_event_t* e) {
uint32_t nr = 0;
ret_t ret = RET_OK;
widget_t* child = NULL;
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(widget != NULL && candidates != NULL, RET_BAD_PARAMS);
nr = candidates->candidates_nr;
if (nr > 1) {
if (e->key >= TK_KEY_1 && e->key <= TK_KEY_9 && candidates->select_by_num) {
int32_t i = e->key - (int32_t)TK_KEY_0 - 1;
if (i >= 0 && i < nr) {
event_t click = event_init(EVT_CLICK, NULL);
child = widget_get_child(widget, i);
if (child->text.size > 0 && child->visible) {
widget_dispatch(child, &click);
ret = RET_STOP;
}
}
} else if (e->key == TK_KEY_LEFT || e->key == TK_KEY_RIGHT) {
keyboard_type_t keyboard_type = system_info()->keyboard_type;
if (nr > 2 && keyboard_type != KEYBOARD_3KEYS && keyboard_type != KEYBOARD_5KEYS) {
candidates_move_focus(widget, e->key == TK_KEY_RIGHT);
ret = RET_STOP;
}
} else if (e->key == TK_KEY_BACKSPACE || e->key == TK_KEY_DELETE) {
if (candidates->is_suggest) {
char words[2] = {0};
input_method_dispatch_candidates(input_method(), words, 0, 0);
ret = RET_STOP;
}
}
}
return ret;
}
static ret_t candidates_get_offset(widget_t* widget, xy_t* out_x, xy_t* out_y) {
return_value_if_fail(widget != NULL && out_x != NULL && out_y != NULL, RET_BAD_PARAMS);
*out_x = widget_get_prop_int(widget, WIDGET_PROP_XOFFSET, 0);
*out_y = widget_get_prop_int(widget, WIDGET_PROP_YOFFSET, 0);
return RET_OK;
}
static const char* const s_candidates_properties[] = {
CANDIDATES_PROP_PRE, CANDIDATES_PROP_SELECT_BY_NUM, CANDIDATES_PROP_BUTTON_STYLE,
CANDIDATES_PROP_AUTO_HIDE, WIDGET_PROP_ENABLE_PREVIEW, NULL};
TK_DECL_VTABLE(candidates) = {.size = sizeof(candidates_t),
.scrollable = TRUE,
.type = WIDGET_TYPE_CANDIDATES,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.clone_properties = s_candidates_properties,
.persistent_properties = s_candidates_properties,
.create = candidates_create,
.init = candidates_init,
.on_event = candidates_on_event,
.on_paint_self = candidates_on_paint_self,
.on_paint_children = candidates_on_paint_children,
.get_prop = candidates_get_prop,
.set_prop = candidates_set_prop,
.on_keyup = candidates_on_keyup,
.get_offset = candidates_get_offset,
.on_destroy = candidates_on_destroy_default};
static ret_t candidates_on_im_candidates_event(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
candidates_t* candidates = CANDIDATES(widget);
im_candidates_event_t* evt = (im_candidates_event_t*)e;
return_value_if_fail(candidates != NULL && evt != NULL, RET_BAD_PARAMS);
candidates->is_suggest = FALSE;
if (candidates->pre) {
if (e->type == EVT_IM_SHOW_PRE_CANDIDATES) {
candidates_update_candidates(widget, evt->candidates, evt->candidates_nr, evt->selected);
}
} else {
if (e->type == EVT_IM_SHOW_CANDIDATES) {
candidates_update_candidates(widget, evt->candidates, evt->candidates_nr, evt->selected);
}
}
return RET_OK;
}
static ret_t candidates_init(widget_t* widget) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
candidates->select_by_num = TRUE;
candidates->hscrollable = hscrollable_create(widget);
hscrollable_set_always_scrollable(candidates->hscrollable, TRUE);
ENSURE(candidates->hscrollable != NULL);
return RET_OK;
}
widget_t* candidates_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(candidates), x, y, w, h);
return_value_if_fail(candidates_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* candidates_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, candidates), NULL);
return widget;
}
ret_t candidates_set_pre(widget_t* widget, bool_t pre) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
candidates->pre = pre;
return RET_OK;
}
ret_t candidates_set_select_by_num(widget_t* widget, bool_t select_by_num) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
candidates->select_by_num = select_by_num;
return RET_OK;
}
ret_t candidates_set_auto_hide(widget_t* widget, bool_t auto_hide) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
candidates->auto_hide = auto_hide;
return RET_OK;
}
ret_t candidates_set_button_style(widget_t* widget, const char* button_style) {
candidates_t* candidates = CANDIDATES(widget);
return_value_if_fail(candidates != NULL, RET_BAD_PARAMS);
candidates->button_style = tk_str_copy(candidates->button_style, button_style);
return RET_OK;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.