![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to StreamTable.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc|
Return to StreamTable.m CVS log | Up to [Apple Darwin 0.x] / objc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /*
25: StreamTable.m
26: Pickling data structures
27: Copyright 1989, NeXT, Inc.
28: Responsability: Bertrand Serlet
29:
30: */
31:
32: #ifndef KERNEL
33: #ifdef SHLIB
34: #import "shlib.h"
35: #endif SHLIB
36:
37: #import <stdlib.h>
38: #import <stdio.h>
39: #import <string.h>
40: #import "StreamTable.h"
41:
42: typedef struct {
43: id object;
44: char *buffer;
45: int length;
46: } Pickle;
47:
48: @implementation StreamTable
49:
50: + newKeyDesc: (const char *) aKeyDesc {
51: return [super newKeyDesc: aKeyDesc valueDesc: "!"];
52: };
53:
54: + new {
55: return [self newKeyDesc: "@"];
56: };
57:
58: - initKeyDesc: (const char *) aKeyDesc {
59: return [self initKeyDesc: aKeyDesc valueDesc: "!"];
60: };
61:
62: - init {
63: return [self initKeyDesc: "@"];
64: };
65:
66: static void freePickle (void *value) {
67: Pickle *pick;
68: if (! value) return;
69: pick = (Pickle *) value;
70: free (pick->buffer); /* we use free and not NXFreeObjectBuffer because malloc was used for creation */
71: free (pick);
72: };
73:
74: static void freePickleAndObject (void *value) {
75: Pickle *pick;
76: if (! value) return;
77: pick = (Pickle *) value;
78: [pick->object free];
79: free (pick->buffer); /* we use free and not NXFreeObjectBuffer because malloc was used for creation */
80: free (pick);
81: };
82:
83: static id getObject (void *value, NXZone *zone) {
84: Pickle *pick;
85: if (! value) return nil;
86: pick = (Pickle *) value;
87: if (! pick->object)
88: pick->object = NXReadObjectFromBufferWithZone (pick->buffer, pick->length, zone);
89: return pick->object;
90: };
91:
92: static void freeObject (void *item) {
93: [(id) item free];
94: };
95:
96: static void noFree (void *item) {
97: };
98:
99: - free {
100: [self freeKeys: noFree values: freePickle];
101: return [super free];
102: };
103:
104: - freeObjects {
105: return [self freeKeys: (keyDesc[0] == '@') ? freeObject : noFree values: freePickleAndObject];
106: };
107:
108: - (id) valueForStreamKey: (const void *) aKey {
109: void *value = [self valueForKey: aKey];
110: return getObject (value, [self zone]);
111: };
112:
113: - (id) insertStreamKey: (const void *) aKey value: (id) aValue {
114: Pickle *pick;
115: char *vmbuffer;
116: NXZone *zone = [self zone];
117:
118: pick = (Pickle *) NXZoneMalloc (zone, sizeof (Pickle));
119: vmbuffer = NXWriteRootObjectToBuffer ((id) aValue, &pick->length);
120: pick->buffer = NXZoneMalloc (zone, pick->length);
121: bcopy (vmbuffer, pick->buffer, pick->length);
122: NXFreeObjectBuffer (vmbuffer, pick->length);
123: pick->object = (id) aValue;
124: [self insertKey: aKey value: pick];
125: return nil;
126: };
127:
128: - (id) removeStreamKey: (const void *) aKey {
129: freePickle ([self removeKey: aKey]);
130: return nil;
131: };
132:
133: - (NXHashState) initStreamState {
134: return [self initState];
135: };
136:
137: - (BOOL) nextStreamState: (NXHashState *) aState key: (const void **) aKey value: (id *) aValue {
138: void *aux;
139: BOOL result = [self nextState: aState key: aKey value: &aux];
140: *aValue = getObject (aux, [self zone]);
141: return result;
142: };
143:
144: - write:(NXTypedStream *) stream
145: {
146: NXHashState state = [self initState];
147: const void *key;
148: Pickle *pick;
149: [super write: stream];
150: while ([self nextState: &state key: &key value: (void **) &pick]) {
151: NXWriteType (stream, keyDesc, &key);
152: NXWriteType (stream, "i", &pick->length);
153: NXWriteArray (stream, "c", pick->length, pick->buffer);
154: };
155: return self;
156: }
157:
158: - read:(NXTypedStream *) stream
159: {
160: int nb;
161: NXZone *zone = [self zone];
162:
163: [super read: stream];
164: nb = count;
165: while (nb--) {
166: const void *key;
167: Pickle *pick = (Pickle *) NXZoneMalloc (zone, sizeof (Pickle));
168: NXReadType (stream, keyDesc, &key);
169: NXReadType (stream, "i", &pick->length);
170: pick->buffer = (char *) NXZoneMalloc (zone, pick->length);
171: NXReadArray (stream, "c", pick->length, pick->buffer);
172: pick->object = nil;
173: [self insertKey: key value: pick];
174: };
175: return self;
176: }
177:
178:
179: @end
180:
181:
182: #endif /* KERNEL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.