Unofficial Dub Package Documentation 
1 // Written in the D programming language.
2 
3 module sapnwrfc.binding;
4 
5 import etc.c.sapnwrfc;
6 
7 import std.meta;
8 import std.traits;
9 import std.conv : to;
10 import std.algorithm : endsWith, startsWith;
11 static import std.utf;
12 
13 class SAPException : Exception
14 {
15     private immutable RFC_ERROR_INFO errorInfo;
16 
17     @safe pure nothrow this(in RFC_ERROR_INFO errorInfo,
18                             string file = __FILE__,
19                             size_t line = __LINE__)
20     {
21         super(null, file, line);
22         this.errorInfo = errorInfo;
23     }
24 
25     @property RFC_RC code()
26     {
27         return errorInfo.code;
28     }
29 
30     @property wstring codeAsString()
31     {
32         auto rcmsg = RfcGetRcAsString(errorInfo.code);
33         return cast(wstring)rcmsg[0 .. strlenU16(rcmsg)];
34     }
35 
36     @property RFC_ERROR_GROUP group()
37     {
38         return errorInfo.group;
39     }
40 
41     @property wstring key()
42     {
43         return errorInfo.key[0 .. strlenU16(errorInfo.key.ptr)];
44     }
45 
46     @property wstring message()
47     {
48         return cast(wstring)errorInfo.message[0 .. strlenU16(errorInfo.message.ptr)];
49     }
50 
51     @property wstring abapMsgClass()
52     {
53         return cast(wstring)errorInfo.abapMsgClass[0 .. strlenU16(errorInfo.abapMsgClass.ptr)];
54     }
55 
56     @property wstring abapMsgType()
57     {
58         return cast(wstring)errorInfo.abapMsgType[0 .. strlenU16(errorInfo.abapMsgType.ptr)];
59     }
60 
61     // abapMsgNumber ?
62 
63     @property wstring abapMsgV1()
64     {
65         return cast(wstring)errorInfo.abapMsgV1[0 .. strlenU16(errorInfo.abapMsgV1.ptr)];
66     }
67 
68     @property wstring abapMsgV2()
69     {
70         return cast(wstring)errorInfo.abapMsgV2[0 .. strlenU16(errorInfo.abapMsgV2.ptr)];
71     }
72 
73     @property wstring abapMsgV3()
74     {
75         return cast(wstring)errorInfo.abapMsgV3[0 .. strlenU16(errorInfo.abapMsgV3.ptr)];
76     }
77 
78     @property wstring abapMsgV4()
79     {
80         return cast(wstring)errorInfo.abapMsgV4[0 .. strlenU16(errorInfo.abapMsgV4.ptr)];
81     }
82 }
83 
84 private void enforce(in RFC_ERROR_INFO errorInfo,
85                      string file = __FILE__, size_t line = __LINE__)
86 {
87     if (errorInfo.code != RFC_RC.RFC_OK)
88     {
89         throw new SAPException(errorInfo, file, line);
90     }
91 }
92 
93 alias helper(alias T) = T;
94 private string generate()
95 {
96     alias mod = helper!(mixin(moduleName!RFC_RC));
97 
98     alias STC = ParameterStorageClass;
99 
100     string code = "";
101     foreach (memberName; __traits(allMembers, mod))
102     {
103     /*
104         static if (memberName == "RFC_ON_PASSWORD_CHANGE")
105         {
106             pragma(msg, __traits(getMember, mod, memberName));
107             pragma(msg, is(typeof(__traits(getMember, mod, memberName)) == function));
108             pragma(msg, isFunctionPointer!(__traits(getMember, mod, memberName)));
109         }
110      */
111         static if (is(typeof(__traits(getMember, mod, memberName)) == function))
112         {
113             alias member = helper!(__traits(getMember, mod, memberName));
114 
115             bool errorInfoSeen = false;
116             foreach(idx, argName; ParameterIdentifierTuple!member)
117                 static if (is(ParameterTypeTuple!member[idx] == RFC_ERROR_INFO))
118                     errorInfoSeen = true;
119 
120             if (errorInfoSeen)
121             {
122                 bool hasReturn = !is(ReturnType!member == void) && !is(ReturnType!member == RFC_RC);
123                 string head = (hasReturn ? ReturnType!member.stringof : "void") ~ " " ~ memberName ~ "(";
124                 string src = "string file = __FILE__, size_t line = __LINE__) {\n" ~
125                               "    RFC_ERROR_INFO errorInfo;\n" ~
126                               "    " ~ (hasReturn ? "auto ret = " : "") ~ "etc.c.sapnwrfc." ~ memberName ~ "(";
127                 string tail = ");\n    enforce(errorInfo, file, line);\n" ~ (hasReturn ? "    return ret;\n" : "") ~ "}\n";
128 
129                 immutable len = ParameterTypeTuple!member.length;
130                 foreach(idx, argName; ParameterIdentifierTuple!member)
131                 {
132                     static if (is(ParameterTypeTuple!member[idx] == RFC_ERROR_INFO))
133                     {
134                         src ~= "errorInfo";
135                     }
136                     else
137                     {
138                         static if (ParameterStorageClassTuple!member[idx] == STC.ref_)
139                             head ~= "ref ";
140                         else static if (ParameterStorageClassTuple!member[idx] == STC.out_)
141                             head ~= "out ";
142                         version(sapnwrfc_sdk_750)
143                         {
144                         alias Types = AliasSeq!(RFC_SERVER_ERROR_LISTENER, RFC_SERVER_STATE_CHANGE_LISTENER,
145                                                 RFC_SERVER_FUNCTION, RFC_ON_CHECK_TRANSACTION, RFC_ON_COMMIT_TRANSACTION, RFC_ON_ROLLBACK_TRANSACTION,
146                                                 RFC_ON_CONFIRM_TRANSACTION, RFC_FUNC_DESC_CALLBACK, RFC_PM_CALLBACK, RFC_ON_CHECK_UNIT, RFC_ON_COMMIT_UNIT,
147                                                 RFC_ON_ROLLBACK_UNIT, RFC_ON_CONFIRM_UNIT, RFC_ON_GET_UNIT_STATE, RFC_ON_PASSWORD_CHANGE, RFC_ON_AUTHORIZATION_CHECK);
148                         alias Names = AliasSeq!("RFC_SERVER_ERROR_LISTENER", "RFC_SERVER_STATE_CHANGE_LISTENER",
149                                                 "RFC_SERVER_FUNCTION", "RFC_ON_CHECK_TRANSACTION", "RFC_ON_COMMIT_TRANSACTION", "RFC_ON_ROLLBACK_TRANSACTION",
150                                                 "RFC_ON_CONFIRM_TRANSACTION", "RFC_FUNC_DESC_CALLBACK", "RFC_PM_CALLBACK", "RFC_ON_CHECK_UNIT", "RFC_ON_COMMIT_UNIT",
151                                                 "RFC_ON_ROLLBACK_UNIT", "RFC_ON_CONFIRM_UNIT", "RFC_ON_GET_UNIT_STATE", "RFC_ON_PASSWORD_CHANGE", "RFC_ON_AUTHORIZATION_CHECK");
152                         }
153                         else
154                         {
155                         alias Types = AliasSeq!(RFC_SERVER_FUNCTION, RFC_ON_CHECK_TRANSACTION, RFC_ON_COMMIT_TRANSACTION, RFC_ON_ROLLBACK_TRANSACTION,
156                                                 RFC_ON_CONFIRM_TRANSACTION, RFC_FUNC_DESC_CALLBACK, RFC_PM_CALLBACK, RFC_ON_CHECK_UNIT, RFC_ON_COMMIT_UNIT,
157                                                 RFC_ON_ROLLBACK_UNIT, RFC_ON_CONFIRM_UNIT, RFC_ON_GET_UNIT_STATE, RFC_ON_PASSWORD_CHANGE, RFC_ON_AUTHORIZATION_CHECK);
158                         alias Names = AliasSeq!("RFC_SERVER_FUNCTION", "RFC_ON_CHECK_TRANSACTION", "RFC_ON_COMMIT_TRANSACTION", "RFC_ON_ROLLBACK_TRANSACTION",
159                                                 "RFC_ON_CONFIRM_TRANSACTION", "RFC_FUNC_DESC_CALLBACK", "RFC_PM_CALLBACK", "RFC_ON_CHECK_UNIT", "RFC_ON_COMMIT_UNIT",
160                                                 "RFC_ON_ROLLBACK_UNIT", "RFC_ON_CONFIRM_UNIT", "RFC_ON_GET_UNIT_STATE", "RFC_ON_PASSWORD_CHANGE", "RFC_ON_AUTHORIZATION_CHECK");
161                         }
162                         static if (staticIndexOf!(ParameterTypeTuple!member[idx], Types) >= 0)
163                             head ~= Names[staticIndexOf!(ParameterTypeTuple!member[idx], Types)];
164                         else
165                             head ~= ParameterTypeTuple!member[idx].stringof;
166                         head ~= " p" ~ to!string(idx) ~ ", ";
167                         src ~= "p" ~ to!string(idx);
168                     }
169                     if (idx+1 < len) src ~= ", ";
170                 }
171 
172                 if (errorInfoSeen) code ~= head ~ src ~ tail;
173             }
174 
175             // Special bindings for RfcGet*Count functions
176             static if (is(ReturnType!member == RFC_RC) && ParameterTypeTuple!member.length == 3
177                 && memberName.startsWith("RfcGet") && memberName.endsWith("Count")
178                 && is(ParameterTypeTuple!member[1] == uint) && ParameterStorageClassTuple!member[1] == STC.out_
179                 && is(ParameterTypeTuple!member[2] == RFC_ERROR_INFO)
180                 )
181             {
182                 string src = "size_t " ~ memberName ~ "(";
183                 src ~= ParameterTypeTuple!member[0].stringof;
184                 src ~= " handle)\n";
185                 src ~= "{ uint count; " ~ memberName ~ "(handle, count); return count; }\n";
186                 code ~= src;
187             }
188 
189 
190             // Special bindings for RfcGet*ByIndex functions
191             static if (is(ReturnType!member == RFC_RC) && ParameterTypeTuple!member.length == 4
192                 && memberName.startsWith("RfcGet") && memberName.endsWith("ByIndex")
193                 && is(ParameterTypeTuple!member[1] == uint) && ParameterStorageClassTuple!member[2] == STC.out_
194                 && is(ParameterTypeTuple!member[3] == RFC_ERROR_INFO)
195                 )
196             {
197                 string src = "void " ~ memberName ~ "(";
198                 src ~= ParameterTypeTuple!member[0].stringof;
199                 src ~= " handle, size_t idx, out ";
200                 src ~= ParameterTypeTuple!member[2].stringof;
201                 src ~= " value)\n";
202                 src ~= "{ " ~ memberName ~ "(handle, cast(uint) idx, value); }\n";
203                 code ~= src;
204             }
205         }
206     }
207 
208     return code;
209 }
210 
211 mixin(generate());
212 
213 // Some manual bindings.
214 // FIXME: Create via reflection.
215 
216 RFC_CONNECTION_HANDLE RfcOpenConnection(in RFC_CONNECTION_PARAMETER[] connectionParams)
217 {
218     return RfcOpenConnection(connectionParams.ptr, cast(uint)connectionParams.length);
219 }
220 
221 RFC_CONNECTION_HANDLE RfcRegisterServer(in RFC_CONNECTION_PARAMETER[] connectionParams)
222 {
223     return RfcRegisterServer(connectionParams.ptr, cast(uint)connectionParams.length);
224 }
225 
226 RFC_CONNECTION_HANDLE RfcStartServer(int argc, SAP_UC** argv, in RFC_CONNECTION_PARAMETER[] connectionParams)
227 {
228     return RfcStartServer(argc, argv, connectionParams.ptr, cast(uint)connectionParams.length);
229 }
230 
231 RFC_FUNCTION_DESC_HANDLE RfcGetFunctionDesc(RFC_CONNECTION_HANDLE rfcHandle, in wstring name)
232 {
233     return RfcGetFunctionDesc(rfcHandle, std.utf.toUTF16z(name));
234 }
235 
236 RFC_TYPE_DESC_HANDLE RfcGetTypeDesc(RFC_CONNECTION_HANDLE rfcHandle, in wstring name)
237 {
238     return RfcGetTypeDesc(rfcHandle, std.utf.toUTF16z(name));
239 }
240 
241 RFC_EXCEPTION_DESC RfcGetExceptionDescByIndex(RFC_FUNCTION_DESC_HANDLE rfcHandle, size_t idx)
242 {
243     RFC_EXCEPTION_DESC desc;
244     RfcGetExceptionDescByIndex(rfcHandle, cast(uint)idx, desc);
245     return desc;
246 }
247 
248 RFC_EXCEPTION_DESC RfcGetExceptionDescByName(RFC_FUNCTION_DESC_HANDLE rfcHandle, in wstring name)
249 {
250     RFC_EXCEPTION_DESC desc;
251     RfcGetExceptionDescByName(rfcHandle, std.utf.toUTF16z(name), desc);
252     return desc;
253 }
254 
255 RFC_FIELD_DESC RfcGetFieldDescByIndex(RFC_TYPE_DESC_HANDLE rfcHandle, size_t idx)
256 {
257     RFC_FIELD_DESC desc;
258     RfcGetFieldDescByIndex(rfcHandle, cast(uint)idx, desc);
259     return desc;
260 }
261 
262 RFC_FIELD_DESC RfcGetFieldDescByName(RFC_TYPE_DESC_HANDLE rfcHandle, in wstring name)
263 {
264     RFC_FIELD_DESC desc;
265     RfcGetFieldDescByName(rfcHandle, std.utf.toUTF16z(name), desc);
266     return desc;
267 }
268 
269 RFC_PARAMETER_DESC RfcGetParameterDescByIndex(RFC_FUNCTION_DESC_HANDLE rfcHandle, size_t idx)
270 {
271     RFC_PARAMETER_DESC desc;
272     RfcGetParameterDescByIndex(rfcHandle, cast(uint)idx, desc);
273     return desc;
274 }
275 
276 RFC_PARAMETER_DESC RfcGetParameterDescByName(RFC_FUNCTION_DESC_HANDLE rfcHandle, in wstring name)
277 {
278     RFC_PARAMETER_DESC desc;
279     RfcGetParameterDescByName(rfcHandle, std.utf.toUTF16z(name), desc);
280     return desc;
281 }
282 
283 void RfcMoveTo(RFC_TABLE_HANDLE handle, size_t index)
284 {
285 	RfcMoveTo(handle, cast(uint)index);
286 }
287 
288 wstring RfcGetFunctionName(RFC_FUNCTION_DESC_HANDLE handle)
289 {
290     RFC_ABAP_NAME name;
291     RfcGetFunctionName(handle, name);
292     return name[0..strlenU16(name.ptr)].idup;
293 }
294 
295 wstring RfcGetTypeName(RFC_TYPE_DESC_HANDLE handle)
296 {
297     RFC_ABAP_NAME name;
298     RfcGetTypeName(handle, name);
299     return name[0..strlenU16(name.ptr)].idup;
300 }
301 
302 // Data container getter
303 
304 void RfcGetChars(DATA_CONTAINER_HANDLE dataHandle, in wstring name, wchar[] buffer)
305 {
306     RfcGetChars(dataHandle, std.utf.toUTF16z(name), buffer.ptr, cast(uint)buffer.length);
307 }
308 
309 void RfcGetCharsByIndex(DATA_CONTAINER_HANDLE dataHandle, in size_t idx, wchar[] buffer)
310 {
311     RfcGetCharsByIndex(dataHandle, cast(uint)idx, buffer.ptr, cast(uint)buffer.length);
312 }
313 
314 void RfcGetNum(DATA_CONTAINER_HANDLE dataHandle, in wstring name, wchar[] buffer)
315 {
316     RfcGetNum(dataHandle, std.utf.toUTF16z(name), buffer.ptr, cast(uint)buffer.length);
317 }
318 
319 void RfcGetNumByIndex(DATA_CONTAINER_HANDLE dataHandle, in size_t idx, wchar[] buffer)
320 {
321     RfcGetNumByIndex(dataHandle, cast(uint)idx, buffer.ptr, cast(uint)buffer.length);
322 }
323 
324 void RfcGetBytes(DATA_CONTAINER_HANDLE dataHandle, in wstring name, ubyte[] buffer)
325 {
326     RfcGetBytes(dataHandle, std.utf.toUTF16z(name), buffer.ptr, cast(uint)buffer.length);
327 }
328 
329 void RfcGetBytesByIndex(DATA_CONTAINER_HANDLE dataHandle, in size_t idx, ubyte[] buffer)
330 {
331     RfcGetBytesByIndex(dataHandle, cast(uint)idx, buffer.ptr, cast(uint)buffer.length);
332 }
333 
334 void RfcGetString(DATA_CONTAINER_HANDLE dataHandle, in wstring name, wchar[] buffer, out size_t length)
335 {
336     uint len;
337     RfcGetString(dataHandle, std.utf.toUTF16z(name), buffer.ptr, cast(uint)buffer.length, len);
338     length = len;
339 }
340 
341 void RfcGetStringByIndex(DATA_CONTAINER_HANDLE dataHandle, in size_t idx, wchar[] buffer, out size_t length)
342 {
343     uint len;
344     RfcGetStringByIndex(dataHandle, cast(uint) idx, buffer.ptr, cast(uint)buffer.length, len);
345     length = len;
346 }
347 
348 size_t RfcGetStringLength(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
349 {
350     uint len;
351     RfcGetStringLength(dataHandle, std.utf.toUTF16z(name), len);
352     return len;
353 }
354 
355 size_t RfcGetStringLengthByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index)
356 {
357     uint len;
358     RfcGetStringLengthByIndex(dataHandle, cast(uint)index, len);
359     return len;
360 }
361 
362 int RfcGetInt(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
363 {
364 	int value;
365     RfcGetInt(dataHandle, std.utf.toUTF16z(name), value);
366     return value;
367 }
368 
369 ubyte RfcGetInt1(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
370 {
371     ubyte value;
372     RfcGetInt1(dataHandle, std.utf.toUTF16z(name), value);
373     return value;
374 }
375 
376 short RfcGetInt2(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
377 {
378     short value;
379     RfcGetInt2(dataHandle, std.utf.toUTF16z(name), value);
380     return value;
381 }
382 
383 double RfcGetFloat(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
384 {
385     double value;
386     RfcGetFloat(dataHandle, std.utf.toUTF16z(name), value);
387     return value;
388 }
389 
390 RFC_STRUCTURE_HANDLE RfcGetStructure(DATA_CONTAINER_HANDLE dataHandle, in const(wchar)* name)
391 {
392     RFC_STRUCTURE_HANDLE value;
393     RfcGetStructure(dataHandle, name, value);
394     return value;
395 }
396 
397 RFC_STRUCTURE_HANDLE RfcGetStructure(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
398 {
399     return RfcGetStructure(dataHandle, std.utf.toUTF16z(name));
400 }
401 
402 RFC_TABLE_HANDLE RfcGetTable(DATA_CONTAINER_HANDLE dataHandle, in const(wchar)* name)
403 {
404     RFC_TABLE_HANDLE value;
405     RfcGetTable(dataHandle, name, value);
406     return value;
407 }
408 
409 RFC_TABLE_HANDLE RfcGetTable(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
410 {
411     return RfcGetTable(dataHandle, std.utf.toUTF16z(name));
412 }
413 
414 RFC_ABAP_OBJECT_HANDLE RfcGetAbapObject(DATA_CONTAINER_HANDLE dataHandle, in const(wchar)* name)
415 {
416     RFC_ABAP_OBJECT_HANDLE value;
417     RfcGetAbapObject(dataHandle, name, value);
418     return value;
419 }
420 
421 RFC_ABAP_OBJECT_HANDLE RfcGetAbapObject(DATA_CONTAINER_HANDLE dataHandle, in wstring name)
422 {
423     return RfcGetAbapObject(dataHandle, std.utf.toUTF16z(name));
424 }
425 
426 // Data container setter
427 
428 void RfcSetChars(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in wstring value)
429 {
430     RfcSetChars(dataHandle, std.utf.toUTF16z(name), value.ptr, cast(uint)value.length);
431 }
432 
433 void RfcSetCharsByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in wstring value)
434 {
435     RfcSetCharsByIndex(dataHandle, cast(uint)index, value.ptr, cast(uint)value.length);
436 }
437 
438 void RfcSetNum(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in wstring value)
439 {
440     RfcSetNum(dataHandle, std.utf.toUTF16z(name), value.ptr, cast(uint)value.length);
441 }
442 
443 void RfcSetNumByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in wstring value)
444 {
445     RfcSetNumByIndex(dataHandle, cast(uint)index, value.ptr, cast(uint)value.length);
446 }
447 
448 void RfcSetBytes(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in ubyte[] value)
449 {
450     RfcSetBytes(dataHandle, std.utf.toUTF16z(name), value.ptr, cast(uint)value.length);
451 }
452 
453 void RfcSetBytesByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in ubyte[] value)
454 {
455     RfcSetBytesByIndex(dataHandle, cast(uint)index, value.ptr, cast(uint)value.length);
456 }
457 
458 void RfcSetString(DATA_CONTAINER_HANDLE dataHandle, const(SAP_UC)* name, const(SAP_UC)* value, size_t length)
459 {
460 	RfcSetString(dataHandle, name, value, cast(uint) length);
461 }
462 
463 void RfcSetString(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in wstring value)
464 {
465     RfcSetString(dataHandle, std.utf.toUTF16z(name), value.ptr, cast(uint)value.length);
466 }
467 
468 void RfcSetStringByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, const(SAP_UC)* value, size_t length)
469 {
470 	RfcSetStringByIndex(dataHandle, cast(uint)index, value, cast(uint) length);
471 }
472 
473 void RfcSetStringByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in wstring value)
474 {
475     RfcSetStringByIndex(dataHandle, cast(uint)index, value.ptr, cast(uint)value.length);
476 }
477 
478 void RfcSetInt(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in int value)
479 {
480     RfcSetInt(dataHandle, std.utf.toUTF16z(name), value);
481 }
482 
483 void RfcSetIntByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in int value)
484 {
485     RfcSetIntByIndex(dataHandle, cast(uint)index, value);
486 }
487 
488 void RfcSetInt1(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in ubyte value)
489 {
490     RfcSetInt1(dataHandle, std.utf.toUTF16z(name), value);
491 }
492 
493 void RfcSetInt1ByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in ubyte value)
494 {
495     RfcSetInt1ByIndex(dataHandle, cast(uint)index, value);
496 }
497 
498 void RfcSetInt2(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in short value)
499 {
500     RfcSetInt2(dataHandle, std.utf.toUTF16z(name), value);
501 }
502 
503 void RfcSetInt2ByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in short value)
504 {
505     RfcSetInt2ByIndex(dataHandle, cast(uint)index, value);
506 }
507 
508 void RfcSetFloat(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in double value)
509 {
510     RfcSetFloat(dataHandle, std.utf.toUTF16z(name), value);
511 }
512 
513 void RfcSetFloatByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in double value)
514 {
515     RfcSetFloatByIndex(dataHandle, cast(uint)index, value);
516 }
517 
518 void RfcSetStructure(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in RFC_STRUCTURE_HANDLE value)
519 {
520     RfcSetStructure(dataHandle, std.utf.toUTF16z(name), value);
521 }
522 
523 void RfcSetStructureByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in RFC_STRUCTURE_HANDLE value)
524 {
525     RfcSetStructureByIndex(dataHandle, cast(uint)index, value);
526 }
527 
528 void RfcSetTable(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in RFC_TABLE_HANDLE value)
529 {
530     RfcSetTable(dataHandle, std.utf.toUTF16z(name), value);
531 }
532 
533 void RfcSetTableByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in RFC_TABLE_HANDLE value)
534 {
535     RfcSetTableByIndex(dataHandle, cast(uint)index, value);
536 }
537 
538 void RfcSetAbapObject(DATA_CONTAINER_HANDLE dataHandle, in wstring name, in RFC_ABAP_OBJECT_HANDLE value)
539 {
540     RfcSetAbapObject(dataHandle, std.utf.toUTF16z(name), value);
541 }
542 
543 void RfcSetAbapObjectByIndex(DATA_CONTAINER_HANDLE dataHandle, size_t index, in RFC_ABAP_OBJECT_HANDLE value)
544 {
545     RfcSetAbapObjectByIndex(dataHandle, cast(uint)index, value);
546 }

Page generated by adrdox