开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 信息检索与抽取 > 查看源码
archiver.m
资源名称：swarm-2.2.tar.gz　[点击查看]
上传用户：shenzhenrh
上传日期：2013-05-12
资源大小：2904k
文件大小：12k
源码类别：

信息检索与抽取

开发平台：

Unix_Linux

archiver.m：源码内容
  1. #import <simtools.h>
  2. #import <defobj.h>
  3. #import <defobj/Create.h>
  4. #import <defobj/Zone.h> // getZone
  5. #include <swarmconfig.h>
  6. #include <misc.h> // xmalloc, sprintf, sscanf
  8. #define OBJNAME "myObj"
  9. #define COLLNAME "collection"
  11. #define STRVAL "str"
  12. #define INTVAL -100
  13. #define UNSIGNEDVAL 100
  14. #define SHORTVAL -10
  15. #define USHORTVAL 10
  16. #define LONGVAL -10000
  17. #define ULONGVAL 10000
  18. #define FLOATVAL 500.0
  19. #define DOUBLEVAL 500000.0
  21. #define COUNT 10
  23. #define COMPONENT_STRVAL "Foo Bar"
  25. @interface Key: CreateDrop
  26. {
  27.   unsigned offset;
  28.   const char *key;
  29. }
  30. - setOffset: (unsigned)offset;
  31. - (int)getOffset;
  32. - createEnd;
  33. @end
  35. @implementation Key
  36. - setOffset: (unsigned)theOffset
  37. {
  38.   offset = theOffset;
  39.   return self;
  40. }
  42. - createEnd
  43. {
  44.   char buf[3 + DSIZE(int) + 1];
  45.   
  46.   sprintf (buf, "key%d", offset);
  47.   key = strdup (buf);
  48.   return self;
  49. }
  51. - (int)getOffset
  52. {
  53.   return offset;
  54. }
  55. @end
  57. @interface MyObj: CreateDrop
  58. {
  59.   const char *name;
  60. }
  61. + createBegin: aZone;
  62. - (const char *)getName;
  63. @end
  65. @implementation MyObj
  66. + createBegin: aZone
  67. {
  68.   MyObj *obj = [super createBegin: aZone];
  70.   obj->name = COMPONENT_STRVAL;
  71.   return obj;
  72. }
  74. - (const char *)getName
  75. {
  76.   return name;
  77. }
  78. @end
  80. @interface MyClass: CreateDrop
  81. {
  82.   const char *strVal;
  83.   int intVal;
  84.   unsigned unsignedVal;
  85.   short shortVal;
  86.   unsigned short ushortVal;
  87.   long longVal;
  88.   unsigned long ulongVal;
  89.   float floatVal;
  90.   double doubleVal;
  91.   BOOL deepFlag;
  92.   BOOL updateFlag;
  94.   unsigned offset;
  95. }
  96. - setDeepFlag: (BOOL)deepFlag;
  97. - setUpdateFlag: (BOOL)updateFlag;
  98. - setOffset: (unsigned)offset;
  99. - adjustToOffset;
  100. - updateArchiver: archiver;
  101. - (int)getOffset;
  102. - (BOOL)checkObject;
  103. - (void)describe: stream;
  104. @end
  106. @implementation MyClass
  107. + createBegin: aZone
  108. {
  109.   MyClass *obj = [super createBegin: aZone];
  111.   obj->strVal = STRVAL;
  112.   obj->intVal = INTVAL;
  113.   obj->unsignedVal = UNSIGNEDVAL;
  114.   obj->shortVal = SHORTVAL;
  115.   obj->ushortVal = USHORTVAL;
  116.   obj->longVal = LONGVAL;
  117.   obj->ulongVal = ULONGVAL;
  118.   obj->floatVal = FLOATVAL;
  119.   obj->doubleVal = DOUBLEVAL;
  120.   return obj;
  121. }
  123. - setDeepFlag: (BOOL)theDeepFlag
  124. {
  125.   deepFlag = theDeepFlag;
  126.   return self;
  127. }
  129. - setUpdateFlag: (BOOL)theUpdateFlag
  130. {
  131.   updateFlag = theUpdateFlag;
  132.   return self;
  133. }
  135. - setOffset: (unsigned)theOffset
  136. {
  137.   offset = theOffset;
  138.   return self;
  139. }
  141. - adjustToOffset
  142. {
  143.   {
  144.     char *newStr = xmalloc (strlen (strVal) + 1 + DSIZE (unsigned) + 1);
  146.     sprintf (newStr, "%s %d", strVal, offset);
  147.     strVal = newStr;
  148.   }
  149.   intVal += offset;
  150.   unsignedVal += offset;
  151.   shortVal += offset;
  152.   ushortVal += offset;
  153.   longVal += offset;
  154.   ulongVal += offset;
  155.   floatVal += offset;
  156.   doubleVal += offset;
  157.   return self;
  158. }
  160. - updateArchiver: archiver
  161. {
  162.   if (updateFlag)
  163.     {
  164.       if (deepFlag)
  165.         [archiver putDeep: OBJNAME object: self];
  166.       else
  167.         [archiver putShallow: OBJNAME object: self];
  168.     }
  169.   return self;
  170. }
  172. - (int)getOffset
  173. {
  174.   return offset;
  175. }
  177. - (BOOL)checkObject
  178. {
  179.   {
  180.     char *buf = strdup (strVal);
  181.     char *pos = strchr (buf, ' ');
  182.     int strNum = atoi (pos + 1);
  183.   
  184.     *pos = '';
  185.     if (strcmp (buf, STRVAL) != 0)
  186.       return NO;
  187.     if (strNum != offset)
  188.       return NO;
  189.   }
  190.   if (intVal - offset != INTVAL)
  191.     return NO;
  192.   if (unsignedVal - offset != UNSIGNEDVAL)
  193.     return NO;
  194.   if (shortVal - offset != SHORTVAL)
  195.     return NO;
  196.   if (ushortVal - offset != USHORTVAL)
  197.     return NO;
  198.   if (longVal - offset != LONGVAL)
  199.     return NO;
  200.   if (ulongVal - offset != ULONGVAL)
  201.     return NO;
  202.   if (floatVal - offset != FLOATVAL)
  203.     return NO;
  204.   if (doubleVal - offset != DOUBLEVAL)
  205.     return NO;
  206.   return YES;
  207. }
  208. - (void)describe: stream
  209. {
  210.   [stream catC: strVal];
  211.   [stream catC: " "];
  212.   [stream catInt: intVal];
  213.   [stream catC: " "];
  214.   [stream catUnsigned: unsignedVal];
  215.   [stream catC: " "];
  216.   [stream catUnsignedShort: ushortVal];
  217.   [stream catC: " "];
  218.   [stream catLong: longVal];
  219.   [stream catC: " "];
  220.   [stream catUnsignedLong: ulongVal];
  221.   [stream catC: " "];
  222.   [stream catFloat: floatVal];
  223.   [stream catC: " "];
  224.   [stream catDouble: doubleVal];
  225.   [stream catC: " "];
  226.   [stream catBoolean: deepFlag];
  227.   [stream catC: " "];
  228.   [stream catBoolean: updateFlag];
  229.   [stream catC: " "];
  230.   [stream catUnsigned: offset];
  231.   [stream catC: "n"];
  232. }
  233. @end
  235. @interface MyClassDeep: MyClass
  236. {
  237.   id objVal;
  238. }
  239. + createBegin: aZone;
  240. - (BOOL)checkObject;
  241. @end
  243. @implementation MyClassDeep
  244. + createBegin: aZone
  245. {
  246.   MyClassDeep *obj = [super createBegin: aZone];
  248.   obj->objVal = [MyObj create: aZone];
  249.   return obj;
  250. }
  252. - (BOOL)checkObject
  253. {
  254.   if (![super checkObject])
  255.     return NO;
  256.   
  257.   return strcmp ([objVal getName], COMPONENT_STRVAL) == 0;
  259. }
  260. @end
  262. @interface Controller: CreateDrop
  263. {
  264.   BOOL hdf5Flag;
  265.   BOOL inhibitLoadFlag;
  266.   BOOL deepFlag;
  267.   BOOL mapFlag;
  268.   BOOL updateFlag;
  269.   id myArchiver;
  270.   id coll;
  271. }
  272. - createEnd;
  273. - updateArchiver: archiver;
  274. - setHDF5Flag: (BOOL)hdf5Flag;
  275. - setDeepFlag: (BOOL)deepFlag;
  276. - setUpdateFlag: (BOOL)updateFlag;
  277. - setInhibitLoadFlag: (BOOL)inhibitLoadFlag;
  278. - setMapFlag: (BOOL)mapFlag;
  279. - (BOOL)loadAndCheckCollection;
  280. - createCollectionAndSave;
  281. - updateArchiver: archiver;
  282. @end
  284. @implementation Controller
  285. - setHDF5Flag: (BOOL)theHDF5Flag
  286. {
  287.   hdf5Flag = theHDF5Flag;
  288.   return self;
  289. }
  291. - setInhibitLoadFlag: (BOOL)theInhibitLoadFlag
  292. {
  293.   inhibitLoadFlag = theInhibitLoadFlag;
  294.   return self;
  295. }
  297. - setDeepFlag: (BOOL)theDeepFlag
  298. {
  299.   deepFlag = theDeepFlag;
  300.   return self;
  301. }
  303. - setUpdateFlag: (BOOL)theUpdateFlag
  304. {
  305.   updateFlag = theUpdateFlag;
  306.   return self;
  307. }
  309. - setMapFlag: (BOOL)theMapFlag
  310. {
  311.   mapFlag = theMapFlag;
  312.   return self;
  313. }
  315. - createEnd
  316. {
  317.   id aZone = getZone (self);
  319.   if (hdf5Flag)
  320.     myArchiver = [[[[HDF5Archiver createBegin: aZone]
  321.                      setPath:
  322.                        (mapFlag
  323.                         ? (deepFlag ? "deepMap.hdf" : "shallowMap.hdf")
  324.                         : (deepFlag ? "deepList.hdf" : "shallowList.hdf"))]
  325.                     setInhibitLoadFlag: inhibitLoadFlag]
  326.                    createEnd];
  327.   else
  328.     myArchiver = [[[[LispArchiver createBegin: aZone]
  329.                      setPath:
  330.                        (mapFlag
  331.                         ? (deepFlag ? "deepMap.scm" : "shallowMap.scm")
  332.                         : (deepFlag ? "deepList.scm" : "shallowList.scm"))]
  333.                     setInhibitLoadFlag: inhibitLoadFlag]
  334.                    createEnd];
  335.   if (mapFlag)
  336.     coll = (deepFlag
  337.             ? [Map create: aZone]
  338.             : [[[Map createBegin: aZone] setCompareCStrings] createEnd]);
  339.   else
  340.     coll = [List create: aZone];
  341.   [myArchiver registerClient: self];
  342.   return self;
  343. }
  345. - updateArchiver: archiver
  346. {
  347.   if (updateFlag)
  348.     {
  349.       if (deepFlag)
  350.         [archiver putDeep: COLLNAME object: coll];
  351.       else
  352.         [archiver putShallow: COLLNAME object: coll];
  353.     }
  354.   return self;
  355. }
  357. - createCollectionAndSave
  358. {
  359.   unsigned i;
  360.   id aZone = getZone (self);
  362.   for (i = 0; i < COUNT; i++)
  363.     {
  364.       id obj;
  365.       
  366.       if (deepFlag)
  367.         obj = [[[[[MyClassDeep createBegin: aZone]
  368.                   setDeepFlag: YES]
  369.                   setUpdateFlag: updateFlag]
  370.                  setOffset: i]
  371.                 createEnd];
  372.       else
  373.         obj = [[[[[MyClass createBegin: aZone]
  374.                    setDeepFlag: NO]
  375.                   setUpdateFlag: updateFlag]
  376.                  setOffset: i]
  377.                 createEnd];
  378.       [obj adjustToOffset];
  379.       if (mapFlag)
  380.         {
  381.           if (deepFlag)
  382.             {
  383.               id key = [[[Key createBegin: aZone] setOffset: i] createEnd];
  385.               [coll at: key insert: obj];
  386.             }
  387.           else
  388.             {
  389.               char buf[3 + DSIZE(unsigned) + 1];
  391.               sprintf (buf, "key%d", i);
  392.               [coll at: (id) strdup (buf) insert: obj];
  393.             }
  394.         }
  395.       else
  396.         [coll addLast: obj];
  397.     }
  398.   [myArchiver sync];
  399.   return self;
  400. }
  402. - (BOOL)loadAndCheckCollection
  403. {
  404.   id aZone = getZone (self);
  405.   id obj;
  406.   BOOL ret = YES;
  408.   coll = [myArchiver getObject: COLLNAME];
  410.   if ([coll getCount] != COUNT)
  411.     {
  412.       raiseEvent (WarningMessage,
  413.                   "collection not right size: %u vs %un",
  414.                   [coll getCount], COUNT);
  415.       return NO;
  416.     }
  418.   if (mapFlag)
  419.     {
  420.       if (deepFlag)
  421.         {
  422.           id key;
  423.           id <MapIndex> mi = [coll begin: aZone];
  425.           while ((obj = [mi next: &key]))
  426.             {
  427.               if (![obj checkObject])
  428.                 {
  429.                   ret = NO;
  430.                   break;
  431.                 }
  432.               if ([key getOffset] != [obj getOffset])
  433.                 {
  434.                   ret = NO;
  435.                   break;
  436.                 }
  437.             }
  438.           [mi drop];
  439.         }
  440.       else
  441.         {
  442.           const char *key;
  443.           id <MapIndex> mi = [coll begin: aZone];
  445.           while ((obj = [mi next: (id *) &key]))
  446.             {
  447.               if (![obj checkObject])
  448.                 {
  449.                   ret = NO;
  450.                   break;
  451.                 }
  452.               {
  453.                 char buf[3 + DSIZE(int) + 1];
  455.                 sprintf (buf, "key%d", [obj getOffset]);
  457.                 if (strcmp (key, buf) != 0)
  458.                   {
  459.                     ret = NO;
  460.                     break;
  461.                   }
  462.               }
  463.             }
  464.           [mi drop];
  465.         }
  466.     }
  467.   else
  468.     {
  469.       id <Index> li = [coll begin: aZone];
  471.       while ((obj = [li next]))
  472.         {
  473.           if (![obj checkObject])
  474.             {
  475.               ret = NO;
  476.               break;
  477.             }
  478.         }
  479.       [li drop];
  480.     }
  481.   return ret;
  482. }
  484. - (void)drop
  485. {
  486.   [myArchiver unregisterClient: self];
  487.   [coll deleteAll];
  488.   [coll drop];
  489.   [myArchiver drop];
  490.   [super drop];
  491. }
  493. @end
  495.  
  496. static BOOL
  497. checkArchiver (id aZone, BOOL hdf5Flag, BOOL deepFlag, BOOL mapFlag, 
  498.                BOOL updateFlag)
  499. {
  500.   id controller;
  501.   BOOL ret;
  502.   
  503.   controller = [[[[[[[Controller createBegin: aZone]
  504.                       setHDF5Flag: hdf5Flag]
  505.                      setMapFlag: mapFlag]
  506.                     setDeepFlag: deepFlag]
  507.                    setUpdateFlag: updateFlag]
  508.                   setInhibitLoadFlag: (updateFlag ? YES: NO)]
  509.                  createEnd];
  510.   
  511.   [controller createCollectionAndSave];
  512.   [controller drop];
  514.   controller = [[[[[[[Controller createBegin: aZone]
  515.                       setHDF5Flag: hdf5Flag]
  516.                      setMapFlag: mapFlag]
  517.                     setDeepFlag: deepFlag]
  518.                    setUpdateFlag: updateFlag]
  519.                   setInhibitLoadFlag: NO]
  520.                  createEnd];
  521.   ret = [controller loadAndCheckCollection];
  522.   [controller drop];
  523.   
  524.   return ret;
  525. }
  527. int
  528. main (int argc, const char **argv)
  529. {
  530.   initSwarmBatch (argc, argv);
  532.   if (checkArchiver (globalZone, NO, NO, NO, YES) == NO)
  533.     raiseEvent (InternalError, 
  534.                 "Shallow Lisp List serialization with update failed");
  535.   if (checkArchiver (globalZone, NO, NO, NO, NO) == NO)
  536.     raiseEvent (InternalError, 
  537.                 "Shallow Lisp List serialization without update failed");
  539.   if (checkArchiver (globalZone, NO, YES, NO, YES) == NO)
  540.     raiseEvent (InternalError, 
  541.                 "Deep Lisp List serialization with update failed");
  542.   if (checkArchiver (globalZone, NO, YES, NO, NO) == NO)
  543.     raiseEvent (InternalError, 
  544.                 "Deep Lisp List serialization without update failed");
  546.   if (checkArchiver (globalZone, NO, NO, YES, YES) == NO)
  547.     raiseEvent (InternalError, 
  548.                 "Shallow Lisp Map serialization with update failed");
  549.   if (checkArchiver (globalZone, NO, NO, YES, NO) == NO)
  550.     raiseEvent (InternalError, 
  551.                 "Shallow Lisp Map serialization without update failed");
  553.   if (checkArchiver (globalZone, NO, YES, YES, YES) == NO)
  554.     raiseEvent (InternalError, 
  555.                 "Deep Lisp Map serialization with update failed");
  556.   if (checkArchiver (globalZone, NO, YES, YES, NO) == NO)
  557.     raiseEvent (InternalError, 
  558.                 "Deep Lisp Map serialization without update failed");
  559. #ifdef HAVE_HDF5
  560.   if (checkArchiver (globalZone, YES, NO, NO, YES) == NO)
  561.     raiseEvent (InternalError, "Shallow HDF5 List serialization failed");
  562.   if (checkArchiver (globalZone, YES, YES, NO, YES) == NO)
  563.     raiseEvent (InternalError, "Deep HDF5 List serialization failed");
  564.   if (checkArchiver (globalZone, YES, NO, YES, YES) == NO)
  565.     raiseEvent (InternalError, "Shallow HDF5 Map serialization failed");
  566.   if (checkArchiver (globalZone, YES, YES, YES, YES) == NO)
  567.     raiseEvent (InternalError, "Deep HDF5 Map serialization failed");
  568. #endif
  570.   return 0;
  571. }