theLink 10.0
Loading...
Searching...
No Matches
MqHigh.cs
Go to the documentation of this file.
1
9/* LABEL-NO */
10
11using System;
12using System.Text;
13using System.Runtime.InteropServices;
14using System.Collections.Generic;
15using csmkkernel;
16//using Mk = csmkkernel.MkKernel;
17//using Mq = csmqmsgque.MqMsgque;
18
19namespace csmqmsgque {
20
21 public partial class MqContextC
22 {
23
24 // ----------------------------------------------------------------------------------------------
25
28
29 static private string getType(MqSendE typ) {
30 switch (typ) {
31 case MqSendE.BOL: return typeof(bool).Name;
32 case MqSendE.I8: return typeof(sbyte).Name;
33 case MqSendE.I16: return typeof(short).Name;
34 case MqSendE.I32: return typeof(int).Name;
35 case MqSendE.I64: return typeof(long).Name;
36 case MqSendE.FLT: return typeof(float).Name;
37 case MqSendE.DBL: return typeof(double).Name;
38 case MqSendE.BUF: return typeof(MkBufferC).Name;
39 case MqSendE.BFL: return typeof(MkBufferListC).Name;
40 case MqSendE.STR: return typeof(string).Name;
41 case MqSendE.BIN: return typeof(byte[]).Name;
42 case MqSendE.HDL: return typeof(int).Name;
43 default: return "unknown";
44 }
45 }
46
47/*
48 static private MkErrorE atomRead(IntPtr hdl, ref IntPtr retP, MqSendE typ) {
49 List<Object> ret;
50 if (retP == IntPtr.Zero) {
51 ret = new List<Object>(1);
52 retP = GCHandle.ToIntPtr(GCHandle.Alloc(ret));
53 } else {
54 ret = (List<Object>)GCHandle.FromIntPtr(retP).Target;
55 }
56 try {
57 switch (typ) {
58 case MqSendE.BOL: {
59 byte outV;
60 if (Mq.MqReadBOL (hdl, out outV) != MkErrorE.OK) break;
61 ret.Add(outV!=1);
62 return MkErrorE.OK;
63 }
64 case MqSendE.I8: {
65 sbyte outV;
66 if (Mq.MqReadI8 (hdl, out outV) != MkErrorE.OK) break;
67 ret.Add(outV);
68 return MkErrorE.OK;
69 }
70 case MqSendE.I16: {
71 short outV;
72 if (Mq.MqReadI16 (hdl, out outV) != MkErrorE.OK) break;
73 ret.Add(outV);
74 return MkErrorE.OK;
75 }
76 case MqSendE.I32: {
77 int outV;
78 if (Mq.MqReadI32 (hdl, out outV) != MkErrorE.OK) break;
79 ret.Add(outV);
80 return MkErrorE.OK;
81 }
82 case MqSendE.I64: {
83 long outV;
84 if (Mq.MqReadI64 (hdl, out outV) != MkErrorE.OK) break;
85 ret.Add(outV);
86 return MkErrorE.OK;
87 }
88 case MqSendE.FLT: {
89 float outV;
90 if (Mq.MqReadFLT (hdl, out outV) != MkErrorE.OK) break;
91 ret.Add(outV);
92 return MkErrorE.OK;
93 }
94 case MqSendE.DBL: {
95 double outV;
96 if (Mq.MqReadDBL (hdl, out outV) != MkErrorE.OK) break;
97 ret.Add(outV);
98 return MkErrorE.OK;
99 }
100 case MqSendE.HDL: {
101 int outV;
102 if (Mq.MqReadHDL (hdl, out outV) != MkErrorE.OK) break;
103 ret.Add(outV);
104 return MkErrorE.OK;
105 }
106 case MqSendE.BUF: {
107 IntPtr outV;
108 if (Mq.MqReadBUF (hdl, out outV) != MkErrorE.OK) break;
109 ret.Add(MkBufferC.ObjNew(outV));
110 return MkErrorE.OK;
111 }
112 case MqSendE.BFL: {
113 IntPtr outV;
114 if (Mq.MqReadBFL (hdl, out outV) != MkErrorE.OK) break;
115 ret.Add(MkBufferListC.ObjNew(outV));
116 return MkErrorE.OK;
117 }
118 case MqSendE.STR: {
119 IntPtr outV;
120 if (Mq.MqReadSTR (hdl, out outV) != MkErrorE.OK) break;
121 ret.Add(Marshal.PtrToStringAnsi(outV));
122 return MkErrorE.OK;
123 }
124 case MqSendE.BIN:
125 Int64 val_out_size;
126 IntPtr val_out_ptr;
127 if (Mq.MqReadBIN (hdl, out val_out_ptr, out val_out_size) != MkErrorE.OK) break;
128 byte[] val_out = new byte[val_out_size];
129 Marshal.Copy(val_out_ptr,val_out,0,(int)val_out_size);
130 ret.Add(val_out);
131 return MkErrorE.OK;
132 default:
133 return Mk.MkErrorSetC(hdl,"INTERNAL ERROR: invalid MqSendE","atomSend",-1);
134 }
135 } catch (Exception ex) {
136 return Mk.MkErrorSetC(hdl, ex.ToString(), "atomSend", -1);
137 }
138
139 return Mk.MkErrorStackP(hdl,"atomRead","high.cs");
140 }
141*/
142
143 static private MkErrorE atomSend(IntPtr mkrt, IntPtr mqrt, IntPtr hdl, IntPtr objvP, Int32 skip, MqSendE typ) {
144 var arg = ((object[])GCHandle.FromIntPtr(objvP).Target)[skip];
145 Object obj = arg;
146 try {
147 // cast string 2 native using libmqmsgque
148 if (arg is string && typ < MqSendE.BUF) {
149 string str = (string)arg;
150 IntPtr cstr = Marshal.StringToHGlobalAnsi(str);
151 switch (typ) {
152 case MqSendE.BOL: {
153 Byte outval;
154 if (Mk.MkString2BOL (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
155 obj = outval == 1 ? true : false;
156 break;
157 }
158 case MqSendE.I8: {
159 Byte outval;
160 if (Mk.MkString2I8 (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
161 obj = outval;
162 break;
163 }
164 case MqSendE.I16: {
165 Int16 outval;
166 if (Mk.MkString2I16 (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
167 obj = outval;
168 break;
169 }
170 case MqSendE.I32: {
171 Int32 outval;
172 if (Mk.MkString2I32 (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
173 obj = outval;
174 break;
175 }
176 case MqSendE.I64: {
177 Int64 outval;
178 if (Mk.MkString2I64 (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
179 obj = outval;
180 break;
181 }
182 case MqSendE.FLT: {
183 Single outval;
184 if (Mk.MkString2FLT (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
185 obj = outval;
186 break;
187 }
188 case MqSendE.DBL: {
189 Double outval;
190 if (Mk.MkString2DBL (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
191 obj = outval;
192 break;
193 }
194 case MqSendE.HDL: {
195 Int32 outval;
196 if (Mk.MkString2HDL (mkrt, cstr, str.Length, out outval) != MkErrorE.OK) goto error;
197 obj = outval;
198 break;
199 }
200 }
201 Marshal.FreeHGlobal(cstr);
202 }
203 switch (typ) {
204 case MqSendE.BOL:
205 if (Mq.MqSendBOL (mkrt, hdl, (byte)(((bool)obj)?1:0)) != MkErrorE.OK) break;
206 return MkErrorE.OK;
207 case MqSendE.I8:
208 if (Mq.MqSendI8 (mkrt, hdl, Convert.ToByte(obj)) != MkErrorE.OK) break;
209 return MkErrorE.OK;
210 case MqSendE.I16:
211 if (Mq.MqSendI16 (mkrt, hdl, (short) obj) != MkErrorE.OK) break;
212 return MkErrorE.OK;
213 case MqSendE.I32:
214 if (Mq.MqSendI32 (mkrt, hdl, (int) obj) != MkErrorE.OK) break;
215 return MkErrorE.OK;
216 case MqSendE.I64:
217 if (Mq.MqSendI64 (mkrt, hdl, (long)obj) != MkErrorE.OK) break;
218 return MkErrorE.OK;
219 case MqSendE.FLT:
220 if (Mq.MqSendFLT (mkrt, hdl, (float)obj) != MkErrorE.OK) break;
221 return MkErrorE.OK;
222 case MqSendE.DBL:
223 if (Mq.MqSendDBL (mkrt, hdl, (double)obj) != MkErrorE.OK) break;
224 return MkErrorE.OK;
225 case MqSendE.HDL:
226 if (Mq.MqSendHDL (mkrt, hdl, (int) obj) != MkErrorE.OK) break;
227 return MkErrorE.OK;
228 case MqSendE.BUF:
229 if (Mq.MqSendBUF (mkrt, hdl, ((MkBufferC)obj).hdl) != MkErrorE.OK) break;
230 return MkErrorE.OK;
231 case MqSendE.BFL:
232 if (Mq.MqSendBFL (mkrt, hdl, ((MkBufferListC)obj).hdl) != MkErrorE.OK) break;
233 return MkErrorE.OK;
234 case MqSendE.STR:
235 IntPtr cstr = Marshal.StringToHGlobalAnsi((string)obj);
236 var ret = Mq.MqSendSTR (mkrt, hdl, cstr);
237 Marshal.FreeHGlobal(cstr);
238 if (ret != MkErrorE.OK) break;
239 return MkErrorE.OK;
240 case MqSendE.BIN: {
241 byte[] val = (byte[]) obj;
242 GCHandle pinnedArray = GCHandle.Alloc(val, GCHandleType.Pinned);
243 IntPtr val_ptr = pinnedArray.AddrOfPinnedObject();
244 MkErrorE err = Mq.MqSendBIN (mkrt, hdl, Mk.MkBinaryCreate(val.Length, val_ptr));
245 pinnedArray.Free();
246 if (err != MkErrorE.OK) break;
247 return MkErrorE.OK;
248 }
249 default:
250 IntPtr cstr2 = Marshal.StringToHGlobalAnsi("invalid MqSendE");
251 IntPtr cstr3 = Marshal.StringToHGlobalAnsi("InternalError");
252 Mk.MkErrorSetC(mkrt, Mk.MkErrorFORMAT(hdl),cstr2,cstr3,-1);
253 Marshal.FreeHGlobal(cstr3);
254 Marshal.FreeHGlobal(cstr2);
255 break;
256 }
257 } catch (Exception ex) {
258//Console.Error.WriteLine($">>>>>\n{ex}\n<<<<<");
259 var err = Mk.MkErrorFORMAT(hdl);
260 IntPtr cstr = Marshal.StringToHGlobalAnsi(
261 string.Format("expect '{0}' argument but got '{1}' of type '{2}' at position '{3}'",
262 getType(typ), obj, obj.GetType().Name, skip)
263 );
264 IntPtr cstr2 = Marshal.StringToHGlobalAnsi("ArgumentTypeError");
265 Mk.MkErrorSetC(mkrt, err, cstr, cstr2, -1);
266 Marshal.FreeHGlobal(cstr2);
267 Marshal.FreeHGlobal(cstr);
268
269 IntPtr cstr3 = Marshal.StringToHGlobalAnsi(" -> " + ex.ToString());
270 Mk.MkErrorAppendC(mkrt, err, cstr3);
271 Marshal.FreeHGlobal(cstr3);
272 }
273error:
274 return MkErrorC.StackFull(mkrt, hdl);
275 }
276
277 static private MkErrorE atomGet(IntPtr mkrt, IntPtr mqrt, IntPtr hdl, IntPtr objvP, Int32 skip, MqSendE typ,
278 IntPtr setP, Int32 size) {
279//MkObjectC.M0();
280//MkObjectC.printObj(typ);
281
282 var gch = GCHandle.FromIntPtr(objvP);
283 var objv = (object[])gch.Target;
284 var obj = objv[skip];
285
286 try {
287 switch (typ) {
288 case MqSendE.TRAN: goto case MqSendE.TOKEN;
289 case MqSendE.TOKEN:
290 UTF8Encoding utf8 = new UTF8Encoding();
291 var str = Convert.ToString(obj);
292 byte[] bytes = utf8.GetBytes(str + "\0");
293 Marshal.Copy(bytes,0,setP,bytes.Length > size ? size : bytes.Length);
294 break;
295 case MqSendE.TIME:
296 Marshal.WriteInt64(setP, Convert.ToInt64(obj));
297 break;
298/* not used
299 case MqSendE.CALL:
300 Marshal.WriteIntPtr(setP, GCHandle.ToIntPtr(GCHandle.Alloc(new ProcData(obj))));
301 break;
302*/
303 default:
304 IntPtr cstr = Marshal.StringToHGlobalAnsi("INTERNAL ERROR: invalid MqSendE");
305 IntPtr cstr2 = Marshal.StringToHGlobalAnsi("atomGet");
306 Mk.MkErrorSetC(mkrt, Mk.MkErrorFORMAT(hdl),cstr,cstr2,-1);
307 Marshal.FreeHGlobal(cstr2);
308 Marshal.FreeHGlobal(cstr);
309 return MkErrorE.ERROR;
310 }
311 } catch (Exception ex) {
312 IntPtr cstr = Marshal.StringToHGlobalAnsi(ex.ToString());
313 IntPtr cstr2 = Marshal.StringToHGlobalAnsi("atomSend");
314 Mk.MkErrorSetC(mkrt,Mk.MkErrorFORMAT(hdl), cstr, cstr2, -1);
315 Marshal.FreeHGlobal(cstr2);
316 Marshal.FreeHGlobal(cstr);
317 return MkErrorE.ERROR;
318 //MkErrorC.StackFull(hdl);
319 }
320
321 return MkErrorE.OK;
322 }
323
324 //static private MqAtomReadFLT atr = new MqAtomReadFLT(atomRead);
325 static private MqAtomSendF ats = new MqAtomSendF(atomSend);
326 static private MqAtomGetF atg = new MqAtomGetF(atomGet);
327
329 private Object SendHigh(string callSig, IntPtr fCall, object[] objv, int skipSHIFT) {
330 MkBufferListC ret = null;
331 IntPtr bfl_out = IntPtr.Zero;
332 char highLastReturnListType;
333 var objvH = GCHandle.Alloc(objv);
334 IntPtr callSig_cstr = Marshal.StringToHGlobalAnsi(callSig);
335 IntPtr cstr = Marshal.StringToHGlobalAnsi("Send");
336 var errVal = Mq.MqCsSendHigh ( mkrt,
337 hdl, callSig_cstr, fCall, GCHandle.ToIntPtr(objvH), objv.Length,
338 skipSHIFT, out bfl_out, out highLastReturnListType, /* atr,*/ ats, atg,
339 ServiceCall, ServiceFree, cstr
340 );
341 Marshal.FreeHGlobal(cstr);
342 Marshal.FreeHGlobal(callSig_cstr);
343 objvH.Free();
344 if (bfl_out != IntPtr.Zero) {
345 ret = MkBufferListC.MkBufferListC_ObjNew(bfl_out);
346 }
347 ErrorCheck(errVal);
348
349 if (ret == null || (ret.Size() == 0 && highLastReturnListType != '*')) {
350 return null;
351 } else if (ret.Size() == 1 && highLastReturnListType != '*' ) {
352 if (highLastReturnListType == 'U') {
353 return ret.IndexGet(0);
354 } else if (highLastReturnListType == 'L') {
355 return ret.IndexGet(0).GetBFL();
356 } else {
357 return ret.IndexGet(0).ToObject();
358 }
359 } else {
360 return ret;
361 }
362 }
363
364 public Object Send(string callSig, MqServiceICB data, params object[] objv) {
365 IntPtr data_ptr = (IntPtr)GCHandle.Alloc(new MqCall(mkrt,data));
366 return SendHigh(callSig, data_ptr, objv, 3);
367 }
368
369 public Object Send(string callSig, MqServiceCCB data, params object[] objv) {
370 IntPtr data_ptr = (IntPtr)GCHandle.Alloc(new MqCall(mkrt,data));
371 return SendHigh(callSig, data_ptr, objv, 3);
372 }
373
374 public Object Send(string callSig, MqServiceIF data, params object[] objv) {
375 IntPtr data_ptr = (IntPtr)GCHandle.Alloc(new MqCall(mkrt,data));
376 return SendHigh(callSig, data_ptr, objv, 3);
377 }
378
379 public Object Send(string callSig, params object[] objv) {
380 return SendHigh(callSig, IntPtr.Zero, objv, 2);
381 }
382
384 }
385
386} // END - namespace "csmqmsgque"
csmkkernel::MkBufferListC::MkBufferListC_ObjNew
static MkBufferListC MkBufferListC_ObjNew(IntPtr hdl)
csmkkernel::MkErrorC::StackFull
static MkErrorE StackFull(IntPtr mkrt, IntPtr hdl)
csmkkernel::Mk::MkBinaryCreate
static Mk.MkBinaryR MkBinaryCreate(long size, IntPtr data)
csmkkernel::Mk::MkString2I16
static MkErrorE MkString2I16(IntPtr mkrt, IntPtr str, Int32 length, out Int16 val_out)
csmkkernel::Mk::MkString2I8
static MkErrorE MkString2I8(IntPtr mkrt, IntPtr str, Int32 length, out Byte val_out)
csmkkernel::Mk::MkString2FLT
static MkErrorE MkString2FLT(IntPtr mkrt, IntPtr str, Int32 length, out Single val_out)
csmkkernel::Mk::MkString2HDL
static MkErrorE MkString2HDL(IntPtr mkrt, IntPtr str, Int32 length, out Int32 val_out)
csmkkernel::Mk::MkErrorFORMAT
static IntPtr MkErrorFORMAT(IntPtr fmtobj)
csmkkernel::Mk::MkString2DBL
static MkErrorE MkString2DBL(IntPtr mkrt, IntPtr str, Int32 length, out Double val_out)
csmkkernel::Mk::MkString2I32
static MkErrorE MkString2I32(IntPtr mkrt, IntPtr str, Int32 length, out Int32 val_out)
csmkkernel::Mk::MkString2BOL
static MkErrorE MkString2BOL(IntPtr mkrt, IntPtr str, Int32 length, out Byte val_out)
csmkkernel::Mk::MkString2I64
static MkErrorE MkString2I64(IntPtr mkrt, IntPtr str, Int32 length, out Int64 val_out)
csmkkernel::Mk::MkErrorSetC
static MkErrorE MkErrorSetC(IntPtr mkrt, IntPtr err, IntPtr message, IntPtr callfunc, Int32 errnum)
csmkkernel::Mk::MkErrorAppendC
static void MkErrorAppendC(IntPtr mkrt, IntPtr err, IntPtr message)
csmqmsgque.MqContextC
MqContextC - the class known as ctx or context is the application-handle of the application-server an...
Definition MqHigh.cs:22
csmqmsgque.MqContextC.Send
Object Send(string callSig, params object[] objv)
Definition MqHigh.cs:379
csmqmsgque.MqContextC.MqServiceICB
delegate void MqServiceICB()
implements the csmqmsgque API object: public version from MqTokenF as method
csmqmsgque.MqContextC.Send
Object Send(string callSig, MqServiceCCB data, params object[] objv)
Definition MqHigh.cs:369
csmqmsgque.MqContextC.Send
Object Send(string callSig, MqServiceIF data, params object[] objv)
Definition MqHigh.cs:374
csmqmsgque.MqContextC.Send
Object Send(string callSig, MqServiceICB data, params object[] objv)
Definition MqHigh.cs:364
csmqmsgque.MqContextC.MqServiceCCB
delegate void MqServiceCCB(MqContextC ctx)
implements the csmqmsgque API object: public version from MqTokenF as static
csmkkernel::MkBufferC::ToObject
object ToObject()
csmkkernel::MkBufferC::GetBFL
MkBufferListC GetBFL(MkBufferListC val_inout=null)
csmkkernel::MkBufferListC::IndexGet
MkBufferC IndexGet(int index)
csmkkernel::MkBufferListC::Size
int Size()
csmkkernel::MkObjectC::ErrorCheck
void ErrorCheck(MkErrorE err)
MkErrorE
MkErrorE
csmqmsgque.MqServiceIF
create a link between a service-token and a service-callback … → C-API: ServiceCreate
Definition MqCall.cs:45
Generated on Thu May 29 2025 13:13:57 for theLink by doxygen 1.12.0