![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to replay.idl CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / rpc / dict|
Return to replay.idl CVS log | Up to [WindowsNT SDKs] / mstools / samples / rpc / dict |
1.1 root 1: /*************************************************************/
2: /** **/
3: /** Microsoft RPC Examples **/
4: /** Dictionary Application **/
1.1.1.2 root 5: /** Copyright(c) Microsoft Corp. 1992 **/
1.1 root 6: /** **/
7: /*************************************************************/
8:
1.1.1.3 ! root 9: [ uuid (12345678-1234-ABCD-EF00-0123456789AB),
! 10: version(1.0),
! 11: // endpoint("msc_np:[\\pipe\\splay]"),
! 12: pointer_default(unique)
1.1 root 13: ]
1.1.1.3 ! root 14: interface dict
! 15: {
1.1 root 16:
17: /*************************************************************************/
18: /*** Strongly typed tree nodes and dictionaries ***/
19: /*************************************************************************/
20:
21: /*
22: ************************************************************************
23: * Record type - previously imported from util1.idl
24: * This is the type of items stored in the remote dictionary.
25: ************************************************************************
26: */
27:
28: typedef struct _Record {
29: short key; // RPC "generation"
30: [string] char* name; // contributor
31: } Record;
32:
1.1.1.2 root 33: typedef Record * PRecord;
34:
1.1 root 35: /*
36: ************************************************************************
37: * The following definitions (RDict, RecordTreeNode) are required
38: * for marshalling a complete dictionary, binary tree, respectively.
39: * All pointers are based on RPC-able types, replacing "void*"
40: * pointers in the local dictionary (dict0) which are non-transmissible.
41: ************************************************************************
42: */
43:
44: typedef struct _RecordTreeNode {
45: struct _RecordTreeNode *left; // left child pointer
46: struct _RecordTreeNode *right; // right child pointer
47: Record *item; // pointer to a Record structure
48: } RecordTreeNode;
49:
50: typedef struct _DictState {
51: short ref_count; // for shared dictionaries
52: Record * curr_record; // for global iterators
53: } DictState;
54:
55: typedef struct _RDict {
56: RecordTreeNode *root; // pointer to the root of a SAT
57: long size; // number of records in dictionary
58: DictState * state; // pointer to state info
59: } RDict;
60:
61: /*
62: * VDict is a "virtual dictionary" object. It is used in the client
63: * application as a handle on a dictionary maintained by a server
64: */
65: typedef [context_handle] void * VDict;
66:
67: typedef enum {
68: DICT_SUCCESS,
69: DICT_ITEM_ALREADY_PRESENT,
70: DICT_ITEM_NOT_FOUND,
71: DICT_FIRST_ITEM,
72: DICT_LAST_ITEM,
73: DICT_EMPTY_DICTIONARY,
74: DICT_NULL_ITEM
1.1.1.3 ! root 75: } VDict_Status;
1.1 root 76:
77: /*************************************************************************/
78: /*** Generic Dictionary Operations: (From dict0.h) ***/
79: /*** ***/
80: /*** Dictionary *Dict_New(Cmp_rec*, Splay*, print_rec*) ***/
81: /*** ***/
82: /*** Dict_Status Dict_Find(Dictionary*, Item*) ***/
83: /*** Dict_Status Dict_Next(Dictionary*, Item*) ***/
84: /*** Dict_Status Dict_Prev(Dictionary*, Item*) ***/
85: /*** Dict_Status Dict_Insert(Dictionary*, Item*) ***/
86: /*** Dict_Status Dict_Delete(Dictionary*, Item**) ***/
87: /*** ***/
88: /*** Item* DICT_CURR_ITEM(Dict*) ***/
89: /*************************************************************************/
90:
91: /*************************************************************************/
92: /*** Virtual Dictionary Operations (on remote dictionaries) ***/
93: /*** ***/
94: /*** VDict_Status VDict_New(OUT VDict *) ***/
95: /*** ***/
96: /*** VDict_Status VDict_Find(IN VDict, IN OUT Record**) ***/
97: /*** VDict_Status VDict_Next(IN VDict, IN OUT Record**) ***/
98: /*** VDict_Status VDict_Prev(IN VDict, IN OUT Record**) ***/
99: /*** VDict_Status VDict_Insert(IN VDict, IN Record*) ***/
100: /*** VDict_Status VDict_Delete(IN VDict, IN OUT Record**) ***/
101: /*** ***/
102: /*** VDict_Status VDict_Get_Dict(IN VDict, OUT RDict**) ***/
103: /*** VDict_Status VDict_Curr_Item(IN VDict, OUT Record**); ***/
104: /*** VDict_Status VDict_Delete_Curr(IN VDict, OUT Record**); ***/
105: /*** VDict_Status VDict_Curr_Next(IN VDict, OUT Record**); ***/
106: /*** VDict_Status VDict_Curr_Prev(IN VDict, OUT Record**); ***/
107: /*** ***/
108: /*************************************************************************/
109:
110: /*
111: ************************************************************************
112: * Most of the remote operations interfacing to a remote dictionary
113: * are very close to operations on local dictionaries, with the
114: * following noted exceptions. To compansate for the fact that it is
115: * possible to "peek" and get the current item of a local dictionary,
116: * some interfaces had to be added, and others have to be changed to
117: * closely match the capabilities of a local dictionaries by a remote
118: * dictionary. In particular the item (Record) argument became an OUT
119: * or an IN OUT argument, returning the value of the "current_item"
120: * following an operation (VDict_Find, VDict_Next, VDict_Prev).
121: * The operations VDict_Curr_Item, VDict_Delete_Curr, VDict_Curr_Next,
122: * and VDict_Curr_Prev were added to get functionality obtained in
123: * local dictionaries by the DICT_CURR_ITEM macro, and by passing the
124: * current item as an IN argument to Dict_Delete, Dict_Next
125: * and Dict_Prev. The basic return [IN] OUT parameter was changed
126: * from (Item*) to (Record**), partly to further test the pointer
127: * handling capabilities of the MIDL compiler.
128: *************************************************************************
129: */
130:
131: /*
132: *************************************************************************
133: * In non-shared mode: Creates and initializes a new (private copy of
134: * the) dictionary.
135: *
136: * In shared mode: If there is an existing shared dictionary, return
137: * it, otherwise Creates and initializes a new (shared copy of
138: * the) dictionary.
139: *************************************************************************
140: */
141:
142: VDict_Status
143: VDict_New(
144: [in] short shared_dict,
145: [out] VDict * v_dict
146: );
147:
148: /*
149: *************************************************************************
150: * Find *item in the dictionary. If *item was not present a "neighbor"
151: * of *item will be returned instead
152: *************************************************************************
153: */
154:
155: VDict_Status
156: VDict_Find(
157: [in] VDict v_dict,
1.1.1.2 root 158: [in, out] Record ** item
1.1 root 159: );
160:
161: /*
162: *************************************************************************
163: * Get successor / predecessor of *item, and update *item to point to it
164: *************************************************************************
165: */
166:
167: VDict_Status
168: VDict_Next(
169: [in] VDict v_dict,
1.1.1.2 root 170: [in, out] Record ** item
1.1 root 171: );
172:
173: VDict_Status
174: VDict_Prev(
175: [in] VDict v_dict,
1.1.1.2 root 176: [in, out] Record ** item
1.1 root 177: );
178:
179: /*
180: *************************************************************************
181: * Get successor / predecessor of RDICT_CURR_RECORD(v_dict),
182: * and update *item to point to it (global iterator prev)
183: *************************************************************************
184: */
185:
186: VDict_Status
187: VDict_Curr_Next(
188: [in] VDict v_dict,
1.1.1.2 root 189: [out] Record ** item
1.1 root 190: );
191:
192: VDict_Status
193: VDict_Curr_Prev(
194: [in] VDict v_dict,
1.1.1.2 root 195: [out] Record ** item
1.1 root 196: );
197:
198: /*
199: *************************************************************************
200: * Insert *item into the dictionary
201: *************************************************************************
202: */
203:
204: VDict_Status
205: VDict_Insert(
206: [in] VDict v_dict,
1.1.1.2 root 207: [in] Record * item
1.1 root 208: );
209:
210: /*
211: *************************************************************************
212: * Delete *item from the dictionary. (It is the callers responsibility
213: * to free the storage allocated for the returned record)
214: *************************************************************************
215: */
216:
217: VDict_Status
218: VDict_Delete(
219: [in] VDict v_dict,
1.1.1.2 root 220: [in, out] Record ** item
1.1 root 221: );
222:
223: /*
224: *************************************************************************
225: * Return a local copy of the whole dictionary
226: *************************************************************************
227: */
228:
229: VDict_Status
230: VDict_Get_Dict(
231: [in] VDict v_dict,
1.1.1.2 root 232: [out] RDict ** r_dict
1.1 root 233: );
234:
235: /*
236: *************************************************************************
237: * Return DICT_CURR_ITEM(v_dict)
238: *************************************************************************
239: */
240:
241: VDict_Status
242: VDict_Curr_Item(
243: [in] VDict v_dict,
1.1.1.2 root 244: [out] Record ** item
1.1 root 245: );
246:
247: /*
248: *************************************************************************
249: * Delete RDICT_CURR_RECORD(v_dict) from the dictionary.
250: * (It is the callers responsibility to free the storage
251: * allocated for the returned record)
252: *************************************************************************
253: */
254:
255: VDict_Status
256: VDict_Curr_Delete(
257: [in] VDict v_dict,
1.1.1.2 root 258: [out] Record ** item
1.1 root 259: );
260:
261: /*************************************************************************/
262: /*** Play oriented Functions ... ***/
263: /*************************************************************************/
264:
265: VDict_Status
266: VDict_X_Dict(
267: [in] VDict v_dict
268: );
269:
270: VDict_Status
271: VDict_I_Dict(
272: [in] VDict v_dict,
273: [in] short size
274: );
275:
276: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.