关于-针对统一的数据对象进行管理

UML关系图

从UML用例图可以看出，rz_sensor_data_manager_t 是一个针对传感器数据的一个统一管理类，包含了一些统一的操作功能，而接口sensor_data_interface_t 是针对 数据对象的实现。
知识点补充：
【实现关系】：是一种类与接口的关系，表示类是接口所有特征和行为的实现
【箭头指向】：带三角箭头的虚线，箭头指向接口是一种类与接口的关系，表示类是接口所有特征和行为的实现。

软件构建思路

建立对象模型，采用统一的接口对相同对象进行访问，这样模块的耦合低最低。
采用链表进行管理，即所有相同属性的对象均挂载在一条链表上。

数据管理类

成员属性和成员函数

#ifndef __RZ_SENSOR_DATA_MANAGER_H__
#define __RZ_SENSOR_DATA_MANAGER_H__ 

#include "lw_oopc.h"
#include <stdbool.h>

/* support sensor data type + */
typedef enum rz_sensor_data_type_def{
		RZ_SENSOR_DATA_TYPE_ANGLE = 0x00,
        RZ_SENSOR_DATA_TYPE_BOLT,
        RZ_SENSOR_DATA_TYPE_MAX,
}rz_sensor_data_type_t, *prz_sensor_data_type_t;


typedef struct rz_sensor_data_manager_t rz_sensor_data_manager_t, *prz_sensor_data_manager_t;

typedef struct sensor_data_interface_def{
        rt_list_t if_list;       /* reload interface list */

        uint16_t data_type;     /* rz_sensor_data_type_t */

        /* reload interface */
        bool (*sensor_data_init)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_stop)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_start)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);

}sensor_data_interface_t, *psensor_data_interface_t;

CLASS(rz_sensor_data_manager_t)
{
        rt_list_t if_list;   /* reload interface list */
                 
        bool (*sensor_data_init)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_stop)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_start)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
       
        bool (*sensor_register)(rz_sensor_data_manager_t *t, psensor_data_interface_t pif);

        void (*init)(rz_sensor_data_manager_t *t);
};


/*---------------------- External function interface call ----------------------------*/
rz_sensor_data_manager_t *rz_sensor_data_manager_obj_get(void);
void sensor_data_manager_init(void);
bool rz_sensor_data_init(rz_sensor_data_type_t type);
bool rz_sensor_data_stop (rz_sensor_data_type_t type);
bool rz_sensor_data_start(rz_sensor_data_type_t type);
#endif 

功能实现接口

#include "rz_sensor_data_manage.h"
#include "rz_sensor_data_wave.h"

const rz_sensor_data_type_t support_sensor_data_type[RZ_SENSOR_DATA_TYPE_MAX] = {
	RZ_SENSOR_DATA_TYPE_BOLT,

};

static rz_sensor_data_manager_t rz_sensor_data_manager_obj;
rz_sensor_data_manager_t *rz_sensor_data_manager_obj_get(void)
{
	return &rz_sensor_data_manager_obj;
}

static bool sensor_data_stop(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type)
{
		rt_list_t *bif_pos = NULL;
        bool iret = false;
         
		rt_list_for_each(bif_pos, &t->if_list) {
			psensor_data_interface_t pif = (psensor_data_interface_t)bif_pos;
			if (type == (pif->data_type)) {
				/* if matched, call the reload interface */
				iret =  pif->sensor_data_stop(t,type);
			}
	}
	return iret;
}



static bool sensor_data_start(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type)
{
		rt_list_t *bif_pos = NULL;
        bool iret = false;

		rt_list_for_each(bif_pos, &t->if_list) {
			psensor_data_interface_t pif = (psensor_data_interface_t)bif_pos;
			if (type == (pif->data_type)) {
				/* if matched, call the reload interface */
				iret =  pif->sensor_data_start(t,type);
			}
	}
	return iret;
}

static bool sensor_data_init(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type)
{
	rt_list_t *bif_pos = NULL;
	bool iret = false;

	rt_list_for_each(bif_pos, &t->if_list) {
		psensor_data_interface_t pif = (psensor_data_interface_t)bif_pos;
			if (type == (pif->data_type)) {
			/* if matched, call the reload interface */
			iret =  pif->sensor_data_init(t,type);
		}
	}
	return iret;
}

/**
 * This function is find interface functions according to data types
 * @param t is sensor manager object 
 * @param type is sensor data type
 * @return Returns interface object on success and NULL on failure
 */
static inline sensor_data_interface_t * _find_interface(rz_sensor_data_manager_t *t, rz_sensor_data_type_t type)
{
	rt_list_t *pos = NULL;
	sensor_data_interface_t *pif = NULL;

	rt_list_for_each(pos, &t->if_list) {
		pif = rt_container_of(pos,sensor_data_interface_t, if_list);
		if (pif->data_type == type) {
			return pif;
		}
	}

	return NULL;
}
/**
 * This function is interface function register
 * @param t is sensor manager object 
 * @param pif is interface functions that need to be registered
 */
static bool sensor_register(rz_sensor_data_manager_t *t, psensor_data_interface_t pif)
{
	rz_sensor_data_type_t type =  (rz_sensor_data_type_t)pif->data_type;
	if (NULL != _find_interface(t,type)) {
		rt_kprintf("don't register sensor data(%d) repeatly\r\n", type);
		return false;
	}
         /* Register the interface function to the data management class */
	rt_list_insert_after(&t->if_list, &pif->if_list);
	return true;
}

/**
 * This function is initialize sensor manager object 
 * @param t is sensor manager object 
 */
static void sensor_init(rz_sensor_data_manager_t *t)
{
	rt_list_init(&t->if_list);
}

CTOR(rz_sensor_data_manager_t)
FUNCTION_SETTING(sensor_data_init, sensor_data_init);
FUNCTION_SETTING(sensor_data_stop, sensor_data_stop);
FUNCTION_SETTING(sensor_data_start, sensor_data_start);
FUNCTION_SETTING(sensor_register, sensor_register);
FUNCTION_SETTING(init, sensor_init);
END_CTOR


void sensor_data_manager_init(void)
{
	rz_sensor_data_manager_t *t = rz_sensor_data_manager_obj_get();
	rz_sensor_data_manager_t_ctor(t);
	t->init(t);     /* sensor_init */

	sensor_wave_obj_init();
}

bool rz_sensor_data_init(rz_sensor_data_type_t type)
{
	bool iret = false;
	rz_sensor_data_manager_t *t = rz_sensor_data_manager_obj_get();

	if(t != RT_NULL) {
		iret = t->sensor_data_init(t,type);     /* sensor_data_init() */
	}

	return iret;
}
bool rz_sensor_data_stop(rz_sensor_data_type_t type)
{
	bool iret = false;
	rz_sensor_data_manager_t *t = rz_sensor_data_manager_obj_get();

	if(t != RT_NULL) {
		iret = t->sensor_data_stop(t,type);     /* sensor_data_stop() */
	}
	return iret;
}
bool rz_sensor_data_start(rz_sensor_data_type_t type)
{
	bool iret = false;
	rz_sensor_data_manager_t *t = rz_sensor_data_manager_obj_get();

	if(t != RT_NULL) {
		iret = t->sensor_data_stop(t,type);     /* sensor_data_stop() */
	}
	return iret;
}

数据对象实例操作

内部声明和属性

#ifndef __RZ_SENSOR_DATA_WAVE_H__
#define __RZ_SENSOR_DATA_WAVE_H__ 

#include "rz_sensor_data_manage.h"



typedef struct sensor_data_split_interface_def{
		uint16_t data_type;     /* rz_upload_data_type_t */
        /* reload interface */
        bool (*sensor_data_init)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_stop)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
        bool (*sensor_data_start)(rz_sensor_data_manager_t *t,rz_sensor_data_type_t type);
}sensor_data_split_interface_t, *psensor_data_split_interface_t;

typedef struct rz_sensor_wave_t rz_sensor_wave_t;


CLASS(rz_sensor_wave_t)
{
    sensor_data_interface_t sensor_wave_if;
    rz_sensor_data_manager_t *sensor_data_manager;

    bool (*sensor_wave_init)(rz_sensor_wave_t *t, rz_sensor_data_type_t data_type);
};
bool sensor_wave_obj_init(void);


#endif 

功能实现

#include "rz_sensor_data_wave.h"


const rz_sensor_data_type_t sensor_support_data_type_split[] = {
	RZ_SENSOR_DATA_TYPE_BOLT,
};


static const sensor_data_split_interface_t sensor_data_split_interface[] = {
	{RZ_SENSOR_DATA_TYPE_BOLT,  NULL, NULL},
};

uint32_t sensor_support_data_type_num(void)
{
	return sizeof(sensor_support_data_type_split)/sizeof(rz_sensor_data_type_t);
}


/**
 * This function is Initialize the data waveform interface
 * @param t is sensor wave object 
 * @param data_type is sensor data type
 */
static bool sensor_wave_init(rz_sensor_wave_t *t, rz_sensor_data_type_t data_type)
{
	psensor_data_interface_t pif = &t->sensor_wave_if;
	prz_sensor_data_manager_t ppsensor_manager_data = rz_sensor_data_manager_obj_get();
	uint32_t support_pl_type_num = sensor_support_data_type_num();

	/* related to prz_offline_data_manager_t object */
	t->sensor_data_manager = ppsensor_manager_data;


	for(uint8_t i = 0; i < support_pl_type_num; i ++) {
		if(sensor_data_split_interface[i].data_type == data_type) {
			rt_list_init(&pif->if_list);
			pif->data_type = data_type;
			/* register function interface */
			pif->sensor_data_init = sensor_data_split_interface[i].sensor_data_init;
			pif->sensor_data_stop = sensor_data_split_interface[i].sensor_data_stop;
			pif->sensor_data_start = sensor_data_split_interface[i].sensor_data_start;
                       
			return true;
		}
	}

	return false;
}




bool sensor_wave_obj_init(void)
{
	//rz_offline_wave_t * t = rz_offline_wave_obj_get();
	bool iret = true;
	uint32_t support_data_type_num = sensor_support_data_type_num();

	/* Each data type is registered once */
	for (uint8_t i = 0; i < support_data_type_num; i++) {
		rz_sensor_wave_t * t = rz_sensor_wave_t_new();
		if(NULL == t) {
			iret = false;
			continue;
		}
		/* sensor_wave_init()，Data management class association */
		if(true != t->sensor_wave_init(t, sensor_support_data_type_split[i])) {
			rz_sensor_wave_t_dtor(t);
			iret = false;
			continue;
		}
		/* register to rz_sensor_data_manager_t */
		if(true != t->sensor_data_manager->sensor_register(t->sensor_data_manager, &t->sensor_wave_if)) {
			rz_sensor_wave_t_dtor(t);
			iret = false;
			continue;
		}
	}
	return iret;
}

CTOR(rz_sensor_wave_t)
FUNCTION_SETTING(sensor_wave_init, sensor_wave_init);
END_CTOR

DTOR(rz_sensor_wave_t)
return lw_oopc_true;
END_DTOR