Return to FoundationExtensionsPrivate.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / EnterpriseObjects / DistributedEO / DEOClient.subproj / DOExtensions.subproj

Annotation of Examples/EnterpriseObjects/DistributedEO/DEOClient.subproj/DOExtensions.subproj/FoundationExtensionsPrivate.m, revision 1.1

1.1     ! root        1: /*
        !             2:    FoundationExtensionsPrivate.m modified by enoyau on Fri 13-Jan-1995
        !             3: 
        !             4:    You may freely copy, distribute, and reuse the code in this example.
        !             5:    NeXT disclaims any warranty of any kind, expressed or implied, as to its
        !             6:    fitness for any particular use.
        !             7: */
        !             8: /*
        !             9:  *  Private classes for the compatibility routines between the old DO
        !            10:  *  mechanisms and the new Foundation objects.
        !            11:  *
        !            12:  *  No guarantee is made for the fitness of this code for any particular
        !            13:  *  use.  No warranty expressed or implied.  Use at your own risk!
        !            14:  *
        !            15:  *  Randy Tidd
        !            16:  *  NeXT Premium Developer Support
        !            17:  */
        !            18: #import "FoundationExtensionsPrivate.h"
        !            19: #import <remote/transport.h>
        !            20: #import <foundation/NSUtilities.h>
        !            21: #import <foundation/NSException.h>
        !            22: 
        !            23: @implementation _NSArrayPlaceHolder
        !            24: - initWithArray:(NSArray *)anArray
        !            25: {
        !            26:     [super init];
        !            27:     array = [anArray copy];
        !            28:     return self;
        !            29: }
        !            30: 
        !            31: - free
        !            32: {
        !            33:     [array release];
        !            34:     return [super free];
        !            35: }
        !            36: 
        !            37: - encodeUsing:(id <NXEncoding>)portal
        !            38: {
        !            39:     unsigned count, i;
        !            40: 
        !            41:     // First encode the count
        !            42:     count = [array count];
        !            43:     [portal encodeData:&count ofType:"i"];
        !            44: 
        !            45:     // Then encode the objects one by one
        !            46:     for(i=0; i<[array count]; i++) {
        !            47:         [portal encodeObject:[array objectAtIndex:i]];
        !            48:     }
        !            49:     return self;
        !            50: }
        !            51: 
        !            52: - decodeUsing:(id <NXDecoding>)portal
        !            53: {
        !            54:     NSMutableArray *newArray = nil;
        !            55:     unsigned count, i;
        !            56: 
        !            57:     // We encoded the count first, and here it is
        !            58:     [portal decodeData:&count ofType:"i"];
        !            59:     newArray = [NSMutableArray arrayWithCapacity:count];
        !            60: 
        !            61:     // Decode the objects one by one and add them to the array
        !            62:     for(i=0; i<count; i++) {
        !            63:         [newArray addObject:[portal decodeObject]];
        !            64:     }
        !            65: 
        !            66:     /*
        !            67:      *  We return our mutable array instance here even though we might
        !            68:      *  be the placeholder for a regular NSArray.  There is usually no
        !            69:      *  harm in returning a mutable array in place of an immutable one.
        !            70:      *  If there is, you need to implement some smarts here to return an
        !            71:      *  instance of the appropriate class.
        !            72:      */
        !            73:     return newArray;
        !            74: }
        !            75: @end
        !            76: 
        !            77: @implementation _NSDictionaryPlaceHolder
        !            78: - initWithDictionary:(NSDictionary *)aDictionary
        !            79: {
        !            80:     [super init];
        !            81:     dictionary = [aDictionary copy];
        !            82:     return self;
        !            83: }
        !            84: 
        !            85: - free
        !            86: {
        !            87:     [dictionary release];
        !            88:     return [super free];
        !            89: }
        !            90: 
        !            91: - encodeUsing:(id <NXEncoding>)portal
        !            92: {
        !            93:     unsigned count;
        !            94:     NSEnumerator *enumerator = [dictionary keyEnumerator];
        !            95:     NSString *key;
        !            96: 
        !            97:     // First encode the count
        !            98:     count = [dictionary count];
        !            99:     [portal encodeData:&count ofType:"i"];
        !           100: 
        !           101:     // Then encode the objects one by one
        !           102:     while(key = [enumerator nextObject]) {
        !           103:         [portal encodeObject:key];
        !           104:         [portal encodeObject:[dictionary objectForKey:key]];
        !           105:     }
        !           106:     return self;
        !           107: }
        !           108: 
        !           109: - decodeUsing:(id <NXDecoding>)portal
        !           110: {
        !           111:     NSMutableDictionary *newDictionary = nil;
        !           112:     unsigned count, i;
        !           113: 
        !           114:     // We encoded the count first, and here it is
        !           115:     [portal decodeData:&count ofType:"i"];
        !           116:     newDictionary = [NSMutableDictionary dictionaryWithCapacity:count];
        !           117: 
        !           118:     // Decode the objects one by one and add them to the array
        !           119:     for(i=0; i<count; i++) {
        !           120:         id newKey, newObject;
        !           121:         newKey = [portal decodeObject];
        !           122:         newObject = [portal decodeObject];
        !           123:         if(!newKey || !newObject) {
        !           124:             // This should never happen, or we're in trouble.
        !           125:             [NSException raise:NSInternalInconsistencyException format:@"%s: %s: can't decode key or object",
        !           126:                 isa->name, sel_getName(_cmd)];
        !           127:         } else {
        !           128:            [newDictionary setObject:newObject forKey:newKey];
        !           129:        }
        !           130:     }
        !           131:     /*
        !           132:      *  We return our mutable dictionary instance here even though we might
        !           133:      *  be the placeholder for a regular NSDictionary.  There is usually no
        !           134:      *  harm in returning a mutable dictionary in place of an immutable one.
        !           135:      *  If there is, you need to implement some smarts here to return an
        !           136:      *  instance of the appropriate class.
        !           137:      */
        !           138:     return newDictionary;
        !           139: }
        !           140: @end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.