Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

  • 博客访问： 944547
  • 博文数量： 116
  • 博客积分： 3923
  • 博客等级： 中校
  • 技术积分： 1337
  • 用 户 组： 普通用户
  • 注册时间： 2009-04-23 01:22
文章分类

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
做个对象管理器来玩下

分类： C/C++

2011-08-11 00:44:53

http://vincent.blog.chinaunix.net
今天基于链表写了个对象管理器，主要是管理各种模块，组件之类的，不过感觉实现得有点那个～～～

file: manager.h
===========================================================================================
  1. /*
  2.  * author: vincent.cws2008@gmail.com
  3.  */
  4. #ifndef _MANAGER_H_
  5. #define _MANAGER_H_

  7. #include "list.h"
  8. #include "listx.h"
  9. #include "stdlib.h"

  11. #define mallocx(n) malloc(n)
  12. #define freex(p)    free(p)
  13. #define lockx()
  14. #define unlockx()

  16. typedef struct manager_s
  17. {
  18.     struct list_s list;
  19.     int (*registerx)(struct manager_s *self_p,
  20.                     char *name_p, void *new_p, bool is_malloc);
  21.     void* (*unregisterx)(struct manager_s *self_p, char *name_p);
  22.     void* (*instancex)(struct manager_s *self_p, char* name_p);
  23.     void (*queryx)(struct manager_s *self_p);
  24.     void (*clear_all)(struct manager_s *self_p);
  25. }MANAGER_T;

  27. void init_manager(MANAGER_T *mgt_p);
  28. void exit_manager(MANAGER_T *mgt_p);

  30. #define member_reg_malloc(type,name_p,mgt) {\
  31.     type *new_p = (type*)mallocx(sizeof(type)); \
  32.     if (-1==mgt.registerx(&(mgt),(name_p),(new_p),1)) freex(new_p);\
  33. }

  35. #define member_unreg_free(type,name_p,mgt) {\
  36.     type *del_p = (type*)(mgt).unregisterx(&(mgt),(name_p)); \
  37.     if (del_p) freex(del_p);\
  38. }

  40. #define member_pt(name_p, mgt) \
  41.         (mgt).instancex(&(mgt),(name_p))

  43. #define member_query(mgt) \
  44.         (mgt).queryx(&(mgt))

  46. #define member_register(name_p,new_p,is_malloc,mgt) \
  47.         (mgt).registerx(&(mgt),(name_p),(new_p),is_malloc)

  49. #define member_unregister(name_p,mgt) \
  50.         (mgt).unregisterx(&(mgt),(name_p))



  54. #endif

file: manager.c
===========================================================================================
  1. /*
  2.  * author: vincent.cws2008@gmail.com
  3.  */

  5. #include "list.h"
  6. #include "listx.h"
  7. #include "manager.h"

  9. #define max(a,b) (((a) > (b)) ? (a) : (b))
  10. #define min(a,b) (((a) < (b)) ? (a) : (b))

  12. static int member_register__(struct manager_s *self_p,
  13.                              char *name_p, void *new_p, bool is_malloc)
  14. {
  15.     NODE_T *node_p;
  16.     int len;
  17.     assert(self_p && name_p && new_p);
  18.     lockx();
  19.     if (listx_lookup(self_p->list, name_p))
  20.     {
  21.         unlockx();
  22.         return -1;
  23.     }
  24.     unlockx();
  25.     node_p = (NODE_T*)mallocx(sizeof(NODE_T));
  26.     assert(node_p);
  27.     node_p->new_p = new_p;
  28.     len = min(strlen(name_p),MAX_NODE_NAME-1);
  29.     strncpy(node_p->name, name_p, len);
  30.     node_p->name[len]='\0';
  31.     node_p->is_malloc=is_malloc;
  32.     lockx();
  33.     listx_append(self_p->list, node_p);
  34.     unlockx();
  35.     return 0;    
  36. }

  38. static void* member_unregister__(struct manager_s *self_p, char *name_p)
  39. {
  40.     NODE_T *node_p;
  41.     void *sgt_p;
  42.     assert(self_p && name_p);
  43.     lockx();
  44.     if (!(node_p=listx_lookup(self_p->list, name_p)))
  45.     {
  46.         unlockx();
  47.         return NULL;
  48.     }
  49.     sgt_p = node_p->new_p;
  50.     listx_delete(self_p->list, node_p);
  51.     unlockx();
  52.     freex(node_p);
  53.     return sgt_p;
  54. }

  56. static void* member_instance__(struct manager_s *self_p, char* name_p)
  57. {
  58.     NODE_T *node_p;
  59.     assert(self_p && name_p);
  60.     lockx();
  61.     if (!(node_p=listx_lookup(self_p->list, name_p)))
  62.     {
  63.         unlockx();
  64.         return NULL;
  65.     }
  66.     unlockx();
  67.     return node_p->new_p;
  68. }

  70. static void member_query__(struct manager_s *self_p)
  71. {
  72.     assert(self_p);
  73.     lockx();
  74.     listx_print(self_p->list);
  75.     unlockx();
  76. }

  78. static void member_clear_all__(struct manager_s *self_p)
  79. {
  80.     struct list_head *list_p;
  81.     NODE_T *node_p;
  82.     NODE_T *temp_p;
  83.     assert(self_p);
  84.     lockx();
  85.     list_for_each_safe(list_p, temp_p, &((self_p->list).head))
  86.     {
  87.         node_p = list_entry(list_p, NODE_T, list);
  88.         if (node_p->new_p && node_p->is_malloc)
  89.         {
  90.             freex(node_p->new_p);
  91.             //list_p = list_p->next
  92.             listx_delete(self_p->list, node_p);
  93.             member_query__(self_p);
  94.         }
  95.     }
  96.     unlockx();    
  97. }


  100. extern void init_manager(MANAGER_T *mgt_p)
  101. {
  102.     assert(mgt_p);
  103.     listx_init(&mgt_p->list);
  104.     *(mgt_p->registerx) = member_register__;
  105.     *(mgt_p->unregisterx) = member_unregister__;
  106.     *(mgt_p->instancex) = member_instance__;
  107.     *(mgt_p->queryx) = member_query__;
  108.     *(mgt_p->clear_all) = member_clear_all__;
  109. }

  111. extern void exit_manager(MANAGER_T *mgt_p)
  112. {
  113.     assert(mgt_p);

  115.     mgt_p->clear_all(mgt_p);
  116. }

file: listx.h
===========================================================================================
  1. /*
  2.  * author: vincent.cws2008@gmail.com
  3.  */

  5. #ifndef _LIST_X_H_
  6. #define _LIST_X_H_

  8. #define assert(x)

  10. extern struct list_head;

  12. #define MAX_NODE_NAME 32

  14. #define bool int

  16. typedef struct node_s{
  17.     struct list_head list;
  18.     void *new_p;
  19.     char name[MAX_NODE_NAME];
  20.     bool is_malloc;
  21. }NODE_T;

  23. typedef struct list_s{
  24.     struct list_head head;
  25.     void (*prepend)(struct list_s *self_p, NODE_T *new_p);
  26.     void (*append)(struct list_s *self_p, NODE_T *new_p);
  27.     void (*delete)(struct list_s *self_p, NODE_T *node_p);
  28.     void (*replace)(struct list_s *self_p, NODE_T *old_p, NODE_T *new_p);
  29.     NODE_T* (*lookup)(struct list_s *self_p, char *name_p);
  30.     void (*print)(struct list_s *self_p);    
  31. }LIST_T;

  33. void listx_init(LIST_T *list_p);

  35. #define listx_prepend(list,node_p) ((list).prepend(&(list), node_p))
  36. #define listx_append(list,node_p) ((list).append(&(list), node_p))
  37. #define listx_print(list) ((list).print(&(list)))
  38. #define listx_replace(list,old_p,new_p) ((list).replace(&(list), old_p, new_p))
  39. #define listx_lookup(list,x) ((list).lookup(&(list), x))
  40. #define listx_delete(list,node_p) ((list).delete(&(list), node_p))

  42. #endif


file: listx.c
===========================================================================================
  1. /*
  2.  * author: vincent.cws2008@gmail.com
  3.  */

  5. #include "list.h"
  6. #include "listx.h"

  8. static void node_prepend(struct list_s *self_p, NODE_T *new_p);
  9. static void node_append(struct list_s *self_p, NODE_T *new_p);
  10. static void node_delete(struct list_s *self_p, NODE_T *node_p);
  11. static void node_replace(struct list_s *self_p, NODE_T *old_p, NODE_T *new_p);
  12. static NODE_T* node_lookup(struct list_s *self_p, char *name_p);
  13. static void node_print(struct list_s *self_p);

  15. static void node_prepend(struct list_s *self_p, NODE_T *new_p)
  16. {
  17.     assert(self_p && new_p);
  18.     list_add(&new_p->list, &(self_p->head));
  19. }

  21. static void node_append(struct list_s *self_p, NODE_T *new_p)
  22. {
  23.     assert(self_p && new_p);
  24.     list_add_tail(&new_p->list, &(self_p->head));
  25. }

  27. static void node_delete(struct list_s *self_p, NODE_T *node_p)
  28. {
  29.     assert(self_p && node_p);
  30.     list_del(&node_p->list);
  31. }

  33. static void node_replace(struct list_s *self_p, NODE_T *old_p, NODE_T *new_p)
  34. {
  35.     assert(self_p && old_p && new_p);
  36.     list_replace(&old_p->list, &new_p->list);
  37. }

  39. static NODE_T* node_lookup(struct list_s *self_p, char *name_p)
  40. {
  41.     struct list_head *list_p;
  42.     NODE_T *node_p;    
  43.     assert(self_p && name_p);
  44.     list_for_each(list_p, &(self_p->head))
  45.     {
  46.         node_p = list_entry(list_p, NODE_T, list);
  47.         if (!strcmp(node_p->name, name_p))
  48.             return node_p;
  49.     }
  50.     return NULL;
  51. }

  53. static void node_print(struct list_s *self_p)
  54. {
  55.     struct list_head *list_p;
  56.     NODE_T *node_p;
  57.     list_for_each(list_p, &(self_p->head))
  58.     {
  59.         node_p = list_entry(list_p, NODE_T, list);
  60.         printf("node name=%s --> ", node_p->name);
  61.     }
  62.     printf("\r\n");
  63. }

  65. extern void listx_init(LIST_T *list_p)
  66. {
  67.     assert(list_p);
  68.     INIT_LIST_HEAD(&list_p->head);
  69.     *(list_p->prepend) = node_prepend;
  70.     *(list_p->append) = node_append;
  71.     *(list_p->delete) = node_delete;
  72.     *(list_p->replace) = node_replace;
  73.     *(list_p->lookup) = node_lookup;
  74.     *(list_p->print) = node_print;
  75. }

file: main.c
===========================================================================================
  1. /*
  2.  * author: vincent.cws2008@gmail.com
  3.  */

  5. #include "stdio.h"
  6. #include "manager.h"

  8. #ifndef MAX_PATH
  9. #define MAX_PATH 260
  10. #endif

  12. static int read()
  13. {
  14.     printf("read ok!\r\n");
  15.     return 0;
  16. }
  17. static int write()
  18. {
  19.     printf("write ok!\r\n");
  20.     return 0;
  21. }
  22. static int open()
  23. {
  24.     printf("open ok!\r\n");
  25.     return 0;
  26. }
  27. static int close()
  28. {
  29.     printf("close ok!\r\n");
  30.     return 0;
  31. }

  33. typedef struct common_opt_s {
  34.     int (*read)();
  35.     int (*write)();
  36.     int (*open)();
  37.     int (*close)();
  38. }COMMON_OPT_T;

  40. typedef struct printer_s{
  41.     char name[MAX_PATH];
  42.     COMMON_OPT_T common_opt;
  43.     void *other_p;
  44. }PRINTER_T;

  46. typedef struct smartcard_s{
  47.     char name[MAX_PATH];
  48.     COMMON_OPT_T common_opt;
  49.     void *other_p;
  50. }SMARTCART_T;

  52. typedef struct pinpad_s{
  53.     char name[MAX_PATH];
  54.     COMMON_OPT_T common_opt;
  55.     void *other_p;
  56. }PINPAD_T;

  58. typedef struct screen_s{
  59.     char name[MAX_PATH];
  60.     COMMON_OPT_T common_opt;
  61.     void *other_p;
  62. }SCREEN_T;

  64. typedef struct communicate_s{
  65.     char name[MAX_PATH];
  66.     COMMON_OPT_T common_opt;
  67.     void *other_p;
  68. }COMMUNICATE_T;


  71. MANAGER_T g_mgt;

  73. #define mbr_reg_malloc(type,name_p) \
  74.         member_reg_malloc(type,name_p,g_mgt,)
  75. #define mbr_unreg_free(type,name_p) \
  76.         member_unreg_free(type,name_p,g_mgt)
  77. #define mbr_pt(name_p) \
  78.         member_pt(name_p, g_mgt)
  79. #define mbr_query() \
  80.         member_query(g_mgt)
  81. #define mbr_reg(name_p,new_p,is_malloc) \
  82.         member_register(name_p,new_p,is_malloc,g_mgt)
  83. #define mbr_unreg(name_p) \
  84.         member_unregister(name_p,g_mgt)


  87. void opt_print(const char* prompt_p, COMMON_OPT_T *comom_opt_p)
  88. {
  89.     assert(comom_opt_p && prompt_p);
  90.     printf("===%s===\r\n", prompt_p);
  91.     comom_opt_p->open();
  92.     comom_opt_p->read();
  93.     comom_opt_p->write();
  94.     comom_opt_p->close();
  95. }

  97. #define ID_PRINTER "printer"
  98. #define ID_SMARTCARD "smartcard"
  99. #define ID_PINPAD "pinpad"
  100. #define ID_SCREEN "screen"
  101. #define ID_COMMUNICATE "communicate"

  103. #define OPTS_INIT {read,write,open,close}

  105. void main()
  106. {
  107.     PRINTER_T* printer_p;
  108.     SMARTCART_T* smartcard_p;
  109.     PINPAD_T* pinpad_p;
  110.     SCREEN_T* screen_p;
  111.     COMMUNICATE_T* communicate_p;

  113.     static PRINTER_T s_printer={ID_PRINTER, OPTS_INIT, 0};
  114.     static SMARTCART_T s_smartcard={ID_SMARTCARD, OPTS_INIT, 0};
  115.     static PINPAD_T s_pinpad={ID_PINPAD, OPTS_INIT, 0};
  116.     static SCREEN_T s_screen={ID_SCREEN, OPTS_INIT, 0};
  117.     static COMMUNICATE_T s_communicate={ID_COMMUNICATE, OPTS_INIT, 0};

  119.     /* init manager */
  120.     init_manager(&g_mgt);
  121.     
  122.     /* register all devices (static) */
  123.     mbr_reg(s_printer.name, &s_printer, 0);
  124.     printer_p = mbr_pt(ID_PRINTER);
  125.     if (printer_p) opt_print(ID_PRINTER, &printer_p->common_opt);
  126.     mbr_query();

  128.     mbr_reg(s_smartcard.name, &s_smartcard, 0);
  129.     smartcard_p = mbr_pt(ID_SMARTCARD);
  130.     if (smartcard_p) opt_print(ID_SMARTCARD, &smartcard_p->common_opt);
  131.     mbr_query();

  133.     mbr_reg(s_pinpad.name, &s_pinpad, 0);
  134.     pinpad_p = mbr_pt(ID_PINPAD);
  135.     if (pinpad_p) opt_print(ID_PINPAD, &pinpad_p->common_opt);
  136.     mbr_query();

  138.     mbr_reg(s_screen.name, &s_screen, 0);
  139.     screen_p = mbr_pt(ID_SCREEN);
  140.     if (screen_p) opt_print(ID_SCREEN, &screen_p->common_opt);
  141.     mbr_query();

  143.     mbr_reg(s_communicate.name, &s_communicate, 0);
  144.     communicate_p = mbr_pt(ID_COMMUNICATE);
  145.     if (communicate_p) opt_print(ID_COMMUNICATE, &communicate_p->common_opt);
  146.     mbr_query();

  148.     /* unregister all devices */
  149.     printf("===unregister all devices!===\r\n");
  150.     mbr_unreg(ID_PRINTER);
  151.     mbr_query();
  152.     
  153.     mbr_unreg(ID_SMARTCARD);
  154.     mbr_query();
  155.     
  156.     mbr_unreg(ID_PINPAD);
  157.     mbr_query();

  159.     mbr_unreg(ID_PINPAD);
  160.     mbr_query();

  162.     mbr_unreg(ID_SCREEN);
  163.     mbr_query();

  165.     mbr_unreg(ID_COMMUNICATE);
  166.     mbr_query();

  168.     /* register all devices (malloc and free) */
  169.     printf("===register all devices (malloc and free)===\r\n");
  170.     
  171.     mbr_reg_malloc(PRINTER_T, ID_PRINTER);
  172.     printer_p = mbr_pt(ID_PRINTER);
  173.     if (printer_p) *printer_p=s_printer;
  174.     if (printer_p) opt_print(ID_PRINTER, &printer_p->common_opt);
  175.     mbr_query();
  176.     
  177.     mbr_reg_malloc(SMARTCART_T, ID_SMARTCARD);
  178.     smartcard_p = mbr_pt(ID_SMARTCARD);
  179.     if (smartcard_p) *smartcard_p=s_smartcard;
  180.     if (smartcard_p) opt_print(ID_SMARTCARD, &smartcard_p->common_opt);
  181.     mbr_query();    
  182.     
  183.     mbr_reg_malloc(PINPAD_T, ID_PINPAD);
  184.     pinpad_p = mbr_pt(ID_PINPAD);
  185.     if (pinpad_p) *pinpad_p=s_pinpad;
  186.     if (pinpad_p) opt_print(ID_PINPAD, &pinpad_p->common_opt);
  187.     mbr_query();
  188.     
  189.     mbr_reg_malloc(SCREEN_T, ID_SCREEN);
  190.     screen_p = mbr_pt(ID_SCREEN);
  191.     if (screen_p) *screen_p=s_screen;
  192.     if (screen_p) opt_print(ID_SCREEN, &screen_p->common_opt);
  193.     mbr_query();
  194.     
  195.     mbr_reg_malloc(COMMUNICATE_T, ID_COMMUNICATE);
  196.     communicate_p = mbr_pt(ID_COMMUNICATE);
  197.     if (communicate_p) *communicate_p=s_communicate;
  198.     if (communicate_p) opt_print(ID_COMMUNICATE, &communicate_p->common_opt);
  199.     mbr_query();
  200.     
  201.     mbr_unreg_free(PRINTER_T, ID_PRINTER);
  202.     mbr_unreg_free(SMARTCART_T, ID_SMARTCARD);
  203.     mbr_unreg_free(PINPAD_T, ID_PINPAD);
  204.     mbr_unreg_free(SCREEN_T, ID_SCREEN);
  205.     mbr_unreg_free(COMMUNICATE_T, ID_COMMUNICATE);
  206.     mbr_query();

  208.     exit_manager(&g_mgt);
  209. }

附件： manager.rar  
===========================================================================================
阅读(698) | 评论(0) | 转发(1) |
0

上一篇：封装一个通用的C函数链表

下一篇：简单的实现内存池管理器

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6