![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to TableDataSource.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / EnterpriseObjects / FlatFileDataSource|
Return to TableDataSource.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / EnterpriseObjects / FlatFileDataSource |
1.1 root 1: /* TableDataSource.m
2: *
3: * This data source reads a flat file table (such as Product.table or Item.table)
4: * and generates EOGeneric records that can be passed to an EOController.
5: *
6: * You may freely copy, distribute, and reuse the code in this example.
7: * NeXT disclaims any warranty of any kind, expressed or implied, as to its
8: * fitness for any particular use.
9: *
10: *
11: *
12: */
13:
14: #import <appkit/appkit.h>
15: #import <eoaccess/eoaccess.h>
16: #import "TableDataSource.h"
17: #import "TableDataSourcePrivate.h"
18: #import "DetailTableDataSource.h"
19: #include <sys/file.h>
20:
21:
22: #define @QUALIFIER_ALL @"*"
23: #define @QPROPERTY @"PROPERTY"
24: #define @QVALUE @"VALUE"
25:
26: @implementation TableDataSource
27:
28: // init a new TableDataSource with an array of EOGeneric records and the path to
29: // the table file (the flat file database!). The entity name will be found from a
30: // record in the array.
31: // Use this initialization method when you have existing records (possibly from
32: // a real database) and you want to save them to a file
33: - initWithEOGenericRecords:(NSArray *)records tablePath:(NSString *)tablePath {
34: NSString *tableFile;
35: NSMutableArray *dictArray = [NSMutableArray array];
36: NSDictionary *dict;
37: int i;
38:
39: // We need at least a record to get the entity
40: if (![records count]) {
41: NSLog(@"<initWithEOGenericRecords:tablePath:> No records");
42: return nil;
43: }
44: entity = [[records objectAtIndex:0] entity];
45: tableFile=[NSString stringWithFormat:@"%@/%@.table", tablePath, [entity name]];
46: for (i=0; i<[records count]; i++) {
47: dict = [[records objectAtIndex:i] valuesForKeys:[entity classPropertyNames]];
48: [dictArray addObject:dict];
49: }
50:
51: // Save the records to a file as a property-list string
52: if (![[[dictArray description] dataUsingEncoding:NSASCIIStringEncoding]
53: writeToFile:tableFile atomically:NO]) {
54: NSLog(@"<initWithEOGenericRecords:tablePath:> DataSource %@ failed to save", [entity name]);
55: return nil;
56: }
57: // Call the designated initialization method
58: else return [self initWithEntity:entity tablePath:tablePath];
59:
60: }
61:
62: // The designated initialization method for TableDataSource
63: // Pick an entity in the model, then initialize the source from a flat file that
64: // contains a string representation of an array of dictionaries.
65: // Note that unlike the EODatabaseSataSource, this dataSource has a "state".
66: // It cashes the eos (dictionaries) that it read from the file and also maintains
67: // a few hash tables to speed up fetch operations...
68: // Although the state of the TableDataSource is an array of dictionaries (I call it
69: // the snapshot) the TabledataSource will copy these dictionaries into an array of
70: // EOGeneric records before handing them to a controller...
71: - initWithEntity:(EOEntity *)anEntity tablePath:(NSString *)tablePath {
72: NSString *primaryKey;
73: NSArray *relations;
74: NSMutableArray *qualifiers = [NSMutableArray array];
75:
76: [super init];
77: entity = [anEntity retain];
78: primaryKey = [(EOAttribute *)[[entity primaryKeyAttributes] objectAtIndex:0] name];
79: relations = [entity relationships];
80: detailSources = [[NSMutableArray array] retain];
81: return [self initWithTable:tablePath primaryKey:primaryKey qualifierKeys:qualifiers];
82: }
83:
84: // The new NSObject world, I guess
85: - (void)dealloc {
86: [table autorelease];
87: [eos autorelease];
88: [lookupTables autorelease];
89: [qualifier autorelease];
90: [uniqueKey autorelease];
91: [detailSources autorelease];
92: [entity autorelease];
93: [orderByKey autorelease];
94: [super dealloc];
95: }
96:
97: // The path to persistent storage, here to the "table" file...
98: - (NSString *)tablePath {
99: return table;
100: }
101:
102: // The other one...
103: - setTablePath:(NSString *)aPath {
104: [table autorelease];
105: table = [aPath retain];
106: return self;
107: }
108:
109: // The supported entity, we got it from the EOmodel at initialization time
110: - (EOEntity *)entity {
111: return entity;
112: }
113:
114: // A custom way (meaning different from the EOF way) to qualify the source for a given property name and value
115: // The equivalent SQL is: WHERE( key = value)
116: - qualifyForProperty:(NSString *)key andValue:value {
117: NSMutableDictionary *qual = [NSMutableDictionary dictionary];
118:
119: if (![[self keys] containsObject:key]) {
120: NSLog(@"%@ is not a valid property of entity %@", key, [entity name]);
121: qual=nil;
122: }
123: else {
124: [qual setObject:key forKey:@QPROPERTY];
125: [qual setObject:value forKey:@QVALUE];
126: }
127: return [self setQualifier:qual];
128: }
129:
130: // Qualify for all records
131: - setEntityQualifier {
132: NSMutableDictionary *qual =[NSMutableDictionary dictionary];
133: [qual setObject:uniqueKey forKey:@QPROPERTY];
134: [qual setObject:@QUALIFIER_ALL forKey:@QVALUE];
135: return [self setQualifier:qual];
136: }
137:
138: // Set the qualifier before the fetch
139: - setQualifier:(NSMutableDictionary *)newQualifier {
140: [qualifier autorelease];
141: if (newQualifier) qualifier = [newQualifier retain];
142: else qualifier=nil;
143: //NSLog(@"New qualifier %@", [(NSMutableDictionary *)qualifier description]);
144: return self;
145: }
146:
147: - setEmptySetQualifier {
148: [qualifier autorelease];
149: qualifier=nil;
150: return self;
151: }
152:
153: - (BOOL)orderBy:(NSString *)key {
154: if (![[self keys] containsObject:key]) return NO;
155: else {
156: [orderByKey autorelease];
157: orderByKey = [key retain];
158: [eos sortUsingFunction:eoSort context:orderByKey];
159: return YES;
160: }
161: }
162:
163: - setOrderDescendantSources:(BOOL)aFlag {
164: orderDescendantSources=aFlag;
165: return self;
166: }
167:
168: // ************************************* DATASOURCE PROTOCOL ****************/
169: // The class property names (keys for the dictionary or EOGenericRecord)
170: - (NSArray *)keys {
171: NSArray *attrs = [entity attributes];
172: NSMutableArray *keys = [NSMutableArray array];
173: int i;
174:
175: for (i=0; i<[attrs count]; i++) {
176: EOAttribute *at = [attrs objectAtIndex:i];
177: [keys addObject:[at name]];
178: }
179: return keys;
180: }
181:
182: - createObject{
183: NSNumber *newId=[self findNextPrimaryKey];
184: NSMutableDictionary *newObject=[[NSMutableDictionary alloc] init];
185:
186: if (!newId) return nil;
187: else {
188: NSArray *allKeys = [self keys];
189: NSArray *relations = [entity relationships];
190: int i, count;
191:
192: for (i=0, count=[allKeys count]; i<count; i++) {
193: id key = [allKeys objectAtIndex:i];
194: [newObject setObject:@"" forKey:key];
195: }
196: for (i=0, count=[relations count]; i<count; i++) {
197: EORelationship *rel = [relations objectAtIndex:i];
198: if ([rel isToMany]) [newObject setObject:[newId description] forKey:[rel name]];
199: }
200: [newObject setObject:[newId description] forKey:uniqueKey];
201: return newObject;
202: }
203: }
204:
205: - (BOOL)insertObject:object {
206: NSNumber *objectId=[object objectForKey:uniqueKey];
207: NSArray *allKeys;
208: int i;
209: NSMutableDictionary *newObject;
210:
211: if (![self isValidNewPrimaryKey:objectId]) {
212: NSLog(@"DataSource cannot insert; primary key is invalid: %@", [(NSString *)objectId description]);
213: return NO;
214: }
215:
216: newObject=[NSMutableDictionary dictionary];
217: allKeys = [self keys];
218: for (i=0; i<[allKeys count]; i++) {
219: id key = [allKeys objectAtIndex:i];
220: id value = [object objectForKey:key];
221: if ([value isEqual:[EONull null]]) value=@"";
222: [newObject setObject:value forKey:key];
223: }
224:
225: [eos addObject:newObject];
226: if (orderByKey) [eos sortUsingFunction:eoSort context:orderByKey];
227: [self modifyLookupTables];
228: return YES;
229: }
230:
231: - (BOOL)deleteAllObjects {
232: int i;
233: for (i=[eos count]-1; i>=0; i--) {
234: [eos removeObject:[eos objectAtIndex:i]];
235: }
236: [self modifyLookupTables];
237: return YES;
238: }
239:
240: - (BOOL)deleteObject:object {
241: id primaryKeyValue = [object objectForKey:uniqueKey];
242: NSMutableArray *deletes=[[lookupTables objectForKey:uniqueKey] objectForKey:primaryKeyValue];
243: int i;
244:
245: if ( !deletes || ![deletes count]) return NO;
246: for (i=0; i<[deletes count]; i++) {
247: [eos removeObject:[deletes objectAtIndex:i]];
248: }
249: [self modifyLookupTables];
250: return YES;
251: }
252:
253: - (BOOL)updateObject:object {
254: id primaryKeyValue = [object objectForKey:uniqueKey];
255: NSMutableArray *update=[[lookupTables objectForKey:uniqueKey] objectForKey:primaryKeyValue];
256: NSArray *allKeys;
257: NSMutableDictionary *eo;
258: int i;
259: NSString *key;
260: id value;
261:
262: if (!update || [update count]!=1) return NO;
263: allKeys = [self keys];
264: eo = [update objectAtIndex:0];
265: for (i=0; i<[allKeys count]; i++) {
266: key = [allKeys objectAtIndex:i];
267: value = [object objectForKey:key];
268: if (!value || [value isEqual:[EONull null]] ) value=@"";
269: [eo setObject:value forKey:key];
270: }
271: if (orderByKey) [eos sortUsingFunction:eoSort context:orderByKey];
272: [self modifyLookupTables];
273: return YES;
274: }
275:
276: - (NSArray *)fetchObjects {
277: NSArray *records;
278: NSString *qualifierPropertyKey = [qualifier objectForKey:@QPROPERTY];
279: NSString *qualifierPropertyValue = [qualifier objectForKey:@QVALUE];
280:
281: if (qualifierPropertyKey && qualifierPropertyValue) {
282:
283: if ( [qualifierPropertyValue isEqual:@QUALIFIER_ALL] ) {
284: records =[self eosArrayToGenericRecordsArray:eos];
285: }
286: else {
287: NSMutableDictionary *hash = [lookupTables objectForKey:qualifierPropertyKey];
288: if (!hash) {
289: NSLog(@"No lookup table for qualifier key %@", qualifierPropertyKey);
290: records =nil;
291: }
292: else {
293: NSArray *qualifiedEos=[hash objectForKey:qualifierPropertyValue];
294: if (!qualifiedEos || ![qualifiedEos count]) {
295: //NSLog(@"No qualified eos where %@=%@", qualifierPropertyKey, [(NSString *)qualifierPropertyValue description]);
296: records =nil;
297: }
298: records =[self eosArrayToGenericRecordsArray:qualifiedEos];
299: }
300:
301: }
302: }
303: else {
304: //NSLog(@"nil or uncomplete qualifier %@", [(NSMutableDictionary *)qualifier description]);
305: records = [NSArray array];
306: }
307: //NSLog(@"TABLE %@ - FETCHED OBJECTS: %d", [entity name], [records count]);
308: return records;
309: }
310:
311: // This is where we save the eos to persistent storage (COMMIT in SQL)
312: - (BOOL)saveObjects{
313: NSString *tableFile=[NSString stringWithFormat:@"%@/%@.table", table, [entity name]];
314: if (![[[eos description] dataUsingEncoding:NSASCIIStringEncoding]
315: writeToFile:tableFile atomically:NO]) {
316: NSString *emess;
317:
318: if ( (!access([tableFile cString], F_OK)) && (access([tableFile cString], W_OK)) ) {
319: int ans;
320: emess = [NSString stringWithFormat:@"\'%@\' data source cannot save changes. You do not have write permission on \'%@\'. Do you want to overwrite?", [entity name], tableFile];
321: ans=NXRunAlertPanel("ERROR", [emess cString], "Overwrite", "Cancel", NULL);
322: if (ans==NX_ALERTDEFAULT) return [self forceSaveObjects];
323: else return NO;
324: }
325: else return NO;
326: }
327: else return YES;
328: }
329:
330: - (BOOL)canDelete {
331: return YES;
332: }
333:
334: // Not implemented yet...
335: // Coerce a value to the appropriate type.
336: // This method should convert to either an NSNumber, NSString, NSData,
337: // a custom type, or nil. The value return by this method may be safely
338: // passed to an EO via takeValuesFromDictionary:. This method is used
339: // by controllers to coerce values supplied from associations before
340: // those values are passed on to the EOs.
341: - coerceValue: value forKey: (NSString *)key {
342: // sorry, another day , maybe...
343: return value;
344: }
345:
346: // ****************************** MASTER DATASOURCE PROTOCOL ****************/
347: // What we are doing here is closer to a master-peer than a master-detail setup.
348: // We are creating the detail dataSource and handing it to the association.
349: // This new detail dataSource will be attached to the detail controller automatically
350: // From there, the detail controller and its DetailTableDataSource will be on their own
351: // Also notice than in an EOF master-detail setup, a master eo (meaning an eo
352: // produced by the master source) "carries" its detail eos. In other word if one
353: // writes [masterEo objectForKey:masterDetailRelationshipKey], the master eo will
354: // return an array full of detail eos (assuming that the master detail relationship
355: // was set as a class property name in EOModeler). Although it could, the TableDataSource
356: // does not support that feature...
357: - (id <EOQualifiableDataSources>)dataSourceQualifiedByKey:(NSString *)key {
358: EORelationship *rel = [entity relationshipNamed:key];
359: EOEntity *detailEntity=[rel destinationEntity];
360: DetailTableDataSource *detailSource;
361:
362: if (!rel) return nil;
363: if (!detailEntity) return nil;
364: detailSource = [[(DetailTableDataSource *)[DetailTableDataSource alloc] initWithMasterDataSource:self entity:detailEntity] autorelease];
365: if (orderByKey && orderDescendantSources) [detailSource orderBy:orderByKey];
366:
367: // We cash it (I had some grandiose plane, unused today!!)
368: [detailSources addObject:detailSource];
369: return detailSource;
370: }
371:
372: // ***************************************************************************/
373:
374: // a convenience method to fetch all the objects in the entity
375: - (NSArray *)fetchAllObjects {
376: NSMutableDictionary *qual =[NSMutableDictionary dictionary];
377: [qual setObject:uniqueKey forKey:@QPROPERTY];
378: [qual setObject:@QUALIFIER_ALL forKey:@QVALUE];
379: [self setQualifier:qual];
380: return [self fetchObjects];
381: }
382:
383: // a convenience fetch method
384: - objectForPrimaryKey:value {
385: id hash = [lookupTables objectForKey:uniqueKey];
386: NSArray *objects = [hash objectForKey:value];
387: id object;
388: EOGenericRecord *record;
389: NSMutableDictionary *primaryKeyDictionary;
390: NSString *key;
391: id copy;
392: int count, j;
393: NSArray *allKeys = [self keys];
394:
395: if ([objects count]!=1) return nil;
396: object = [objects objectAtIndex:0];
397: primaryKeyDictionary=[NSMutableDictionary dictionary];
398: [primaryKeyDictionary setObject:value forKey:uniqueKey];
399: record = [[EOGenericRecord alloc] initWithPrimaryKey:primaryKeyDictionary
400: entity:entity];
401: for (j=0, count=[allKeys count]; j<count; j++) {
402: key = [allKeys objectAtIndex:j];
403: copy = [[object objectForKey:key] copy];
404: [record setObject:[copy autorelease] forKey:key];
405: }
406: return [record autorelease];
407: }
408:
409: - addLookupTableForKey:(NSString *)key {
410: NSMutableDictionary *hash;
411:
412: hash = [self createLookupTableForQualifierKey:key];
413: [lookupTables setObject:hash forKey:key];
414: return self;
415: }
416:
417:
418:
419: @end
420:
421: // ************************************* Private Category ****************/
422: @implementation TableDataSource (Private)
423:
424: // This initialization method is called by initWithEntity:tablePath:
425: // It sets the key for the primary key and creates a key->array of objects hash
426: // tables for each element of the qualifiers array.
427: - initWithTable:(NSString *)tablePath primaryKey:(NSString *)primaryKey qualifierKeys:(NSArray *)qualifiers {
428:
429: // Create snapshot from table (eos)
430: table = [tablePath retain];
431: if (![self createSnapshot]) return nil;
432:
433: // Create a dictionary of hash tables for query (key is like @"ID", value is a lookup table)
434: uniqueKey = [primaryKey retain];
435: if ( !([self createLookupTables:qualifiers]) ) return nil;
436:
437: // set qualifier to select everything
438: // To be clean, we should have a qualifier Class, oh well...it is a rush job
439: // after all
440: orderByKey=nil;
441: orderDescendantSources = NO;
442: qualifier = [[NSMutableDictionary alloc] init];
443: [qualifier setObject:uniqueKey forKey:@QPROPERTY];
444: [qualifier setObject:@QUALIFIER_ALL forKey:@QVALUE];
445:
446: return self;
447: }
448:
449: // The flat file is read here and the objects that have been retrieved are cashed
450: // in an instance variable (of class NSMutableArray) called eos
451: - createSnapshot {
452: NSString *tableFile=[NSString stringWithFormat:@"%@/%@", table, [entity externalName]];
453: NSString *tableString;
454: NSArray *nonMutableEos;
455:
456: // read the table file that should be in a property list format
457: // Isn't foundation great or what?!!!
458: if ( !(tableString=[[NSString alloc] initWithContentsOfFile:tableFile]) ||
459: !(nonMutableEos = [tableString propertyList]) ) {
460: NSLog(@"<createSnapshot> Cannot init from table %@", tableFile);
461: return nil;
462: }
463: // Make deep mutable copy
464: else {
465: NSEnumerator *eoEnumerator = [nonMutableEos objectEnumerator];
466: NSDictionary *nonMutableEo;
467:
468: eos = [[NSMutableArray alloc] init];
469: while ( nonMutableEo = [eoEnumerator nextObject] ) {
470: [eos addObject: [[nonMutableEo mutableCopy] autorelease]];
471: }
472: }
473: return self;
474: }
475:
476: // Create the lookup tables (to speed up fetch operations)
477: // The qualifiers array contains the property names that we should hash on
478: // a lookup table is in the form key = "a property key" --> value = an array of
479: // dictionaries...
480: - createLookupTables:(NSArray *)qualifiers {
481: int i, count;
482: NSMutableDictionary *hash;
483: NSString *qualifierKey;
484:
485: lookupTables = [[NSMutableDictionary alloc] init];
486: hash = [self createLookupTableForQualifierKey:uniqueKey];
487: [lookupTables setObject:hash forKey:uniqueKey];
488:
489: for (i=0, count=[qualifiers count]; i<count; i++) {
490:
491: qualifierKey = [qualifiers objectAtIndex:i];
492: if ( ![lookupTables objectForKey:qualifierKey] ) {
493: //NSLog(@"Creating lookup table for qualifierKey %@", qualifierKey);
494: if ( !(hash = [self createLookupTableForQualifierKey:qualifierKey]) ) return nil;
495: [lookupTables setObject:hash forKey:qualifierKey];
496: }
497: }
498: return self;
499: }
500:
501: // Create a lookup table for a given property name (the key)
502: - createLookupTableForQualifierKey:(NSString *)key {
503:
504: NSMutableDictionary *hash;
505: int i, count;
506: NSDictionary *eo;
507: NSMutableArray *values;
508: id value;
509:
510: hash=[NSMutableDictionary dictionary];
511:
512: for (i=0, count=[eos count]; i<count; i++) {
513:
514: eo = [eos objectAtIndex:i];
515:
516: // get the property value for the qualifier key
517: if ( !(value = [eo objectForKey:key]) ) {
518: NSLog(@"<createLookupTableForQualifierKey:> eos dictionary does not respond to qualifier key %@", key);
519: return nil;
520: }
521:
522: // It is the first time that we encounter an eo such that propertyValue(key) = value
523: if ( !(values = [hash objectForKey:value]) ) {
524: values = [NSMutableArray array];
525: [values addObject:eo];
526: [hash setObject:values forKey:[(NSObject *)value description]];
527: }
528: // We have already found an eo such that propertyValue(key) = value
529: else {
530: [values addObject:eo];
531: }
532: }
533: //NSLog(@"HASH FOR KEY %@\n%@", key, [(NSDictionary *)hash description]);
534: return hash;
535: }
536:
537: // After insert, delete or update opeations, the lookup tables must be refreshed
538: - modifyLookupTables {
539: NSArray *allKeys=[lookupTables allKeys];
540: int i, count;
541: NSString *key;
542: NSMutableDictionary *hash;
543:
544: for (i=0, count=[allKeys count]; i<count; i++) {
545: key = [allKeys objectAtIndex:i];
546: [lookupTables removeObjectForKey:key];
547: hash = [self createLookupTableForQualifierKey:key];
548: [lookupTables setObject:hash forKey:key];
549: }
550: return self;
551: }
552:
553: // a method to transform an array of eos (state of the TableDataSource) into
554: // an array of EOGeneric records that we can hand to the outside worls...
555: - (NSMutableArray *)eosArrayToGenericRecordsArray:(NSArray *)eoArray {
556: NSMutableArray *records = [NSMutableArray array];
557: int i, eoCount;
558:
559: for (i=0, eoCount=[eoArray count]; i<eoCount; i++) {
560: NSMutableDictionary *eo;
561: NSMutableDictionary *primaryKey=[NSMutableDictionary dictionary];
562: EOGenericRecord *record;
563: NSArray *allKeys;
564: NSArray *relations;
565: int j, count;
566:
567: eo = [eoArray objectAtIndex:i];
568: allKeys = [self keys];
569: [primaryKey setObject:[eo objectForKey:uniqueKey] forKey:uniqueKey];
570: record = [[[EOGenericRecord alloc] initWithPrimaryKey:primaryKey entity:entity] autorelease];
571: for (j=0, count=[allKeys count]; j<count; j++) {
572: NSString *key = [allKeys objectAtIndex:j];
573: id copy;
574:
575: copy = [[eo objectForKey:key] copy];
576: [record setObject:[copy autorelease] forKey:key];
577: }
578: relations = [entity relationships];
579:
580: // We support master-details but not flattened attribute for now!!!
581: for (j=0, count=[relations count]; j<count; j++) {
582: EORelationship *rel = [relations objectAtIndex:j];
583: id copy;
584:
585: if ([rel isToMany]) {
586: copy = [[eo objectForKey:uniqueKey] copy];
587: [record setObject:[copy autorelease] forKey:[rel name]];
588: }
589:
590: }
591: [records addObject:record];
592: }
593: return records;
594: }
595:
596: // Unlike the EODatabaseDataSource, when a TableDataSource creates a new object
597: // It sets the primary key value for the created object.
598: // This method computes the next available primary key (the next in the sequence)
599: - (NSNumber *)findNextPrimaryKey {
600: int i, max=-1;
601:
602: for (i=0; i<[eos count]; i++) {
603: id eo;
604: int current;
605:
606: eo = [eos objectAtIndex:i];
607: current = [[eo objectForKey:uniqueKey] intValue];
608: if (current > max) max=current;
609: }
610: return [NSNumber numberWithInt:max+1];
611: }
612:
613: // make sure the the primary key of a new object handed for insertion has a valid primary key
614: // (in this case, valid means not used by a record stored in the table)
615: - (BOOL)isValidNewPrimaryKey:(NSNumber *)number {
616: int i;
617:
618: for (i=0; i<[eos count]; i++) {
619: id eo;
620:
621: eo = [eos objectAtIndex:i];
622: if ([number isEqual:[eo objectForKey:uniqueKey]]) return NO;
623: }
624: return YES;
625: }
626:
627: - (BOOL)forceSaveObjects {
628: NSString *tableFile=[NSString stringWithFormat:@"%@/%@.table", table, [entity name]];
629: NSString *emess=@"Cannot overwrite; changes will not be saved...";
630: NSString *cmd;
631:
632: cmd = [NSString stringWithFormat:@"mv %@ %@.otto", tableFile, tableFile];
633: if (system([cmd cString])) {
634: NXRunAlertPanel("ERROR", [emess cString], "OK", NULL, NULL);
635: return NO;
636: }
637: cmd = [NSString stringWithFormat:@"cp %@.otto %@; ", tableFile, tableFile];
638: if (system([cmd cString])) {
639: NXRunAlertPanel("ERROR", [emess cString], "OK", NULL, NULL);
640: return NO;
641: }
642: cmd = [NSString stringWithFormat:@"rm -f %@.otto; chmod u+w %@", tableFile, tableFile];
643: system([cmd cString]);
644:
645: if (![[[eos description] dataUsingEncoding:NSASCIIStringEncoding]
646: writeToFile:tableFile atomically:NO]) return NO;
647: else return YES;
648:
649: }
650:
651: int eoSort(id eo1, id eo2, void *context) {
652: NSString *key=(NSString *)context;
653: NSString *val1, *val2;
654:
655: if (!key) return NSOrderedSame;
656: val1 = [eo1 objectForKey:key];
657: val2 = [eo2 objectForKey:key];
658: if (!val1 || !val2) return NSOrderedSame;
659: else return [val1 compare:val2];
660: }
661:
662:
663: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.