theKernel 10.0
Loading...
Searching...
No Matches
MkBufferStreamC.cs
Go to the documentation of this file.
1
9/* LABEL-START */
10
11using System;
12using System.Reflection;
13using System.Runtime.InteropServices;
14using System.Runtime.CompilerServices;
15using System.Collections.Generic;
16using System.Threading;
17
18namespace csmkkernel {
19
23#if META_IS_OBJECT
24 public partial class MkBufferStreamC
25#else
26 public partial class MkBufferStreamC : MkObjectC
27#endif
28 {
29 private readonly static ConstructorInfo ctor = getCtor(typeof(MkBufferStreamC));
30 private readonly static ThreadLocal<MkBufferStreamC> MK_NULL = new ThreadLocal<MkBufferStreamC>(() => {
31 return (MkBufferStreamC) atomSelfNull(ctor);
32 });
33
35 return hdl != IntPtr.Zero ? (MkBufferStreamC) atomObjNew(typeof(MkBufferStreamC), ctor, hdl) : MK_NULL.Value;
36 }
37
38 private static MkBufferStreamC MkBufferStreamC_ObjCreate (IntPtr hdl) {
39 return hdl != IntPtr.Zero ? (MkBufferStreamC) atomObjCreate(typeof(MkBufferStreamC), ctor, hdl) : MK_NULL.Value;
40 }
41
42 private static IntPtr MkBufferStreamC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
43 return atomSelfCreate(ctor, obj, env);
44 }
45
46 private static void MkBufferStreamC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
47 atomSelfUnlink(self, env);
48 }
49
50 internal static void SetupThreadBUS (IntPtr mkrt) {
51 Mk.MkCsTypeUpdate(mkrt, MkCsTypeLookupE.BUS, MkBufferStreamC_SelfCreate, MkBufferStreamC_SelfUnlink);
52 }
53
54 #if !META_STATIC_OVERWRITE
55
56 static MkBufferStreamC() {
57 // M0("MkBufferStreamC");
58 MkKernel.Setup();
59 SetupThreadBUS(IntPtr.Zero);
60 }
61
62 #endif
63/* LABEL-END */
64
65 internal MkBufferStreamC (IntPtr bufP) : base(bufP) {
66 // a "reference" is part of the context and is freed on context delete.
67 //if (MqS.MkBufferStreamIsLocal(bufP)) GC.SuppressFinalize(this);
68 }
69
70 } // END - class "MkBufferStreamC"
71
72 // BEGIN-MkBufferStreamC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
73
74 public partial class MkBufferStreamC {
75
79
80 // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,sc_
81
83 new public static MkBufferStreamC HandleResolve (Int32 netHdl) {
84 IntPtr __retVal__L = Mk.MkBufferStreamHandleResolve(IntPtr.Zero, netHdl);
85 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
86 }
87
88 // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,om_
89
90 // skip class-overload: HandleGet = MkBufferStreamHandleGet → MkObjectHandleGet
91
93 // MkBufferStreamC_Class_CS_API
94 }
95
96 public partial class MkBufferStreamC {
97
101
102 // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,oc_
103
105 new public MkBufferStreamC Next () {
106 IntPtr __retVal__L = Mk.MkBufferStreamNext(hdl);
107 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
108 }
109
111 new public MkBufferStreamC Prev () {
112 IntPtr __retVal__L = Mk.MkBufferStreamPrev(hdl);
113 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
114 }
115
116 // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,sc_
117
119 new public static MkBufferStreamC Instances () {
120 IntPtr __retVal__L = Mk.MkBufferStreamInstances(IntPtr.Zero);
121 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
122 }
123
125 // MkBufferStreamC_Class_CS_API
126 }
127
128 public partial class MkBufferStreamC {
129
133
134 // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Misc,sc_
135
137 new public static MkBufferStreamC GetNull () {
138 IntPtr __retVal__L = Mk.MkBufferStreamGetNull();
139 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
140 }
141
143 // MkBufferStreamC_Class_CS_API
144 }
145
146 public partial class MkBufferStreamC {
147
151
152 // doc-key: MkBufferStreamC,MkBufferStreamC-Misc,oc_
153
156 IntPtr src_hdl = MkBufferStreamC.getOBJ("MkBufferStreamC",src);
157 IntPtr __retVal__L = Mk.MkBufferStreamCopy(mkrt, hdl, src_hdl);
158 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
159 }
160
163 IntPtr __retVal__L = Mk.MkBufferStreamReset(mkrt, hdl);
164 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
165 }
166
169 IntPtr __retVal__L = Mk.MkBufferStreamToBFL(mkrt, hdl);
170 return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
171 }
172
173 // doc-key: MkBufferStreamC,MkBufferStreamC-Misc,om_
174
175 // skip class-overload: Log = MkBufferStreamLog → MkObjectLog
176
178 public void PosToStart () {
179 Mk.MkBufferStreamPosToStart(mkrt, hdl);
180 }
181
183 public void ResetFull () {
184 Mk.MkBufferStreamResetFull(mkrt, hdl);
185 }
186
187 // skip class-overload: ToString = MkBufferStreamToString → MkObjectToString
188
190 // MkBufferStreamC_Misc_CS_API
191 }
192
193 public partial class MkBufferStreamC {
194
198
199 // doc-key: MkBufferStreamC,MkBufferStreamC-Read,oci
200
202 public MkBufferListC ReadALL (MkBufferListC val_inout = null) {
203 IntPtr val_inout_hdl = MkBufferListC.getOBJ_null_allow(val_inout);
204 MkErrorE errVal = Mk.MkBufferStreamReadALL(mkrt, hdl, ref val_inout_hdl);
205 MkErrorC.Check(hdl, errVal);
206 return MkBufferListC.MkBufferListC_ObjNew(val_inout_hdl);
207 }
208
209 // doc-key: MkBufferStreamC,MkBufferStreamC-Read,oco
210
213 IntPtr val_out;
214 MkErrorE errVal = Mk.MkBufferStreamReadBFL(mkrt, hdl, out val_out);
215 MkErrorC.Check(hdl, errVal);
216 return MkBufferListC.MkBufferListC_ObjNew(val_out);
217 }
218
220 public MkBufferC ReadBUF () {
221 IntPtr val_out;
222 MkErrorE errVal = Mk.MkBufferStreamReadBUF(mkrt, hdl, out val_out);
223 MkErrorC.Check(hdl, errVal);
224 return MkBufferC.MkBufferC_ObjNew(val_out);
225 }
226
227 // doc-key: MkBufferStreamC,MkBufferStreamC-Read,om_
228
231 MkTypeE __retVal__L = Mk.MkBufferStreamReadGetNextType(mkrt, hdl);
232 return __retVal__L;
233 }
234
236 public int ReadGetNumItems () {
237 Int32 __retVal__L = Mk.MkBufferStreamReadGetNumItems(mkrt, hdl);
238 return __retVal__L;
239 }
240
242 public bool ReadItemExists () {
243 bool __retVal__L = Mk.MkBufferStreamReadItemExists(mkrt, hdl);
244 return __retVal__L;
245 }
246
248 public void ReadL_END () {
249 MkErrorE errVal = Mk.MkBufferStreamReadL_END(mkrt, hdl);
250 MkErrorC.Check(hdl, errVal);
251 }
252
254 public void ReadL_START (MkBufferC buf = null) {
255 IntPtr buf_hdl = MkBufferC.getOBJ_null_allow(buf);
256 MkErrorE errVal = Mk.MkBufferStreamReadL_START(mkrt, hdl, buf_hdl);
257 MkErrorC.Check(hdl, errVal);
258 }
259
261 public void ReadUndo () {
262 MkErrorE errVal = Mk.MkBufferStreamReadUndo(mkrt, hdl);
263 MkErrorC.Check(hdl, errVal);
264 }
265
266 // doc-key: MkBufferStreamC,MkBufferStreamC-Read,omo
267
269 public byte[] ReadBIN () {
270 Mk.MkBinaryR val_out_ref;
271 MkErrorE errVal = Mk.MkBufferStreamReadBIN(mkrt, hdl, out val_out_ref);
272 if (errVal > MkErrorE.CONTINUE) ErrorCheck(errVal);
273 byte[] val_out = new byte[(int)val_out_ref.size];
274 Marshal.Copy(val_out_ref.data,val_out,0,(int)val_out_ref.size);
275 return val_out;
276 }
277
279 public bool ReadBOL () {
280 Byte val_out;
281 MkErrorE errVal = Mk.MkBufferStreamReadBOL(mkrt, hdl, out val_out);
282 MkErrorC.Check(hdl, errVal);
283 return val_out != 0;
284 }
285
287 public double ReadDBL () {
288 Double val_out;
289 MkErrorE errVal = Mk.MkBufferStreamReadDBL(mkrt, hdl, out val_out);
290 MkErrorC.Check(hdl, errVal);
291 return val_out;
292 }
293
295 public float ReadFLT () {
296 Single val_out;
297 MkErrorE errVal = Mk.MkBufferStreamReadFLT(mkrt, hdl, out val_out);
298 MkErrorC.Check(hdl, errVal);
299 return val_out;
300 }
301
303 public int ReadI32 () {
304 Int32 val_out;
305 MkErrorE errVal = Mk.MkBufferStreamReadI32(mkrt, hdl, out val_out);
306 MkErrorC.Check(hdl, errVal);
307 return val_out;
308 }
309
311 public long ReadI64 () {
312 Int64 val_out;
313 MkErrorE errVal = Mk.MkBufferStreamReadI64(mkrt, hdl, out val_out);
314 MkErrorC.Check(hdl, errVal);
315 return val_out;
316 }
317
319 public byte ReadI8 () {
320 Byte val_out;
321 MkErrorE errVal = Mk.MkBufferStreamReadI8(mkrt, hdl, out val_out);
322 MkErrorC.Check(hdl, errVal);
323 return (byte)val_out;
324 }
325
327 public long ReadLONG () {
328 long val_out;
329 MkErrorE errVal = Mk.MkBufferStreamReadLONG(mkrt, hdl, out val_out);
330 MkErrorC.Check(hdl, errVal);
331 return val_out;
332 }
333
335 public string ReadSTR () {
336 IntPtr val_out;
337 MkErrorE errVal = Mk.MkBufferStreamReadSTR(mkrt, hdl, out val_out);
338 MkErrorC.Check(hdl, errVal);
339 return Marshal.PtrToStringAnsi(val_out);
340 }
341
343 // MkBufferStreamC_Read_CS_API
344 }
345
346 public partial class MkBufferStreamC {
347
351
352 // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oC_
353
356 IntPtr __retVal__L = Mk.MkBufferStreamMerge(mkrt, hdl);
357 if (__retVal__L == IntPtr.Zero) {
358 throw new MkInitError("MkBufferStreamC.Merge");
359 }
360 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
361 }
362
363 // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oCx
364
367 IntPtr __retVal__L = Mk.MkBufferStreamDup(mkrt, hdl);
368 if (__retVal__L == IntPtr.Zero) {
369 throw new MkInitError("MkBufferStreamC.Dup");
370 }
371 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
372 }
373
374 // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sCc
375
377 protected static IntPtr CTOR (int size = 0) {
378 IntPtr __retVal__L = Mk.MkBufferStreamCreate(IntPtr.Zero, IntPtr.Zero, size);
379 if (__retVal__L == IntPtr.Zero) {
380 throw new MkInitError("MkBufferStreamC.CTOR");
381 }
382 return (IntPtr)__retVal__L;
383 }
384
386 public MkBufferStreamC(int size = 0) : this(CTOR(size)) {}
387
389 public static MkBufferStreamC Create (int size = 0) {
390 IntPtr __retVal__L = Mk.MkBufferStreamCreate(IntPtr.Zero, IntPtr.Zero, size);
391 if (__retVal__L == IntPtr.Zero) {
392 throw new MkInitError("MkBufferStreamC.Create");
393 }
394 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
395 }
396
398 public static MkBufferStreamC Create1024 (int size = 0) {
399 IntPtr __retVal__L = Mk.MkBufferStreamCreate1024(IntPtr.Zero, size);
400 if (__retVal__L == IntPtr.Zero) {
401 throw new MkInitError("MkBufferStreamC.Create1024");
402 }
403 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
404 }
405
407 public static MkBufferStreamC Create16384 (int size = 0) {
408 IntPtr __retVal__L = Mk.MkBufferStreamCreate16384(IntPtr.Zero, size);
409 if (__retVal__L == IntPtr.Zero) {
410 throw new MkInitError("MkBufferStreamC.Create16384");
411 }
412 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
413 }
414
416 public static MkBufferStreamC Create256 (int size = 0) {
417 IntPtr __retVal__L = Mk.MkBufferStreamCreate256(IntPtr.Zero, size);
418 if (__retVal__L == IntPtr.Zero) {
419 throw new MkInitError("MkBufferStreamC.Create256");
420 }
421 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
422 }
423
425 public static MkBufferStreamC Create64 (int size = 0) {
426 IntPtr __retVal__L = Mk.MkBufferStreamCreate64(IntPtr.Zero, size);
427 if (__retVal__L == IntPtr.Zero) {
428 throw new MkInitError("MkBufferStreamC.Create64");
429 }
430 return MkBufferStreamC.MkBufferStreamC_ObjCreate(__retVal__L);
431 }
432
433 // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sc_
434
436 public static MkBufferStreamC CreateTLS (string tlsName, bool resetB = true) {
437 IntPtr tlsName_cstr = Marshal.StringToHGlobalAnsi(tlsName);
438 IntPtr __retVal__L = Mk.MkBufferStreamCreateTLS(IntPtr.Zero, tlsName_cstr, resetB);
439 Marshal.FreeHGlobal(tlsName_cstr);
440 return MkBufferStreamC.MkBufferStreamC_ObjNew(__retVal__L);
441 }
442
444 // MkBufferStreamC_TOR_CS_API
445 }
446
447 public partial class MkBufferStreamC {
448
452
453 // doc-key: MkBufferStreamC,MkBufferStreamC-Write,om_
454
456 public void WriteBFL (MkBufferListC bfl) {
457 IntPtr bfl_hdl = MkBufferListC.getOBJ("MkBufferListC",bfl);
458 MkErrorE errVal = Mk.MkBufferStreamWriteBFL(mkrt, hdl, bfl_hdl);
459 MkErrorC.Check(hdl, errVal);
460 }
461
463 public void WriteBIN (byte[] val) {
464 var val_size = Marshal.SizeOf(val[0]) * val.Length;
465 var val_data = Marshal.AllocHGlobal(val_size);
466 Marshal.Copy(val,0,val_data,val_size);
467 Mk.MkBinaryR val_ref = Mk.MkBinaryCreate(val_size,val_data);
468 MkErrorE errVal = Mk.MkBufferStreamWriteBIN(mkrt, hdl, val_ref);
469 MkErrorC.Check(hdl, errVal);
470 }
471
473 public void WriteBOL (bool val) {
474 MkErrorE errVal = Mk.MkBufferStreamWriteBOL(mkrt, hdl, (Byte)(val?1:0));
475 MkErrorC.Check(hdl, errVal);
476 }
477
479 public void WriteBUF (MkBufferC val) {
480 IntPtr val_hdl = MkBufferC.getOBJ("MkBufferC",val);
481 MkErrorE errVal = Mk.MkBufferStreamWriteBUF(mkrt, hdl, val_hdl);
482 MkErrorC.Check(hdl, errVal);
483 }
484
486 public void WriteBUS_FLAT (MkBufferStreamC add) {
487 IntPtr add_hdl = MkBufferStreamC.getOBJ("MkBufferStreamC",add);
488 MkErrorE errVal = Mk.MkBufferStreamWriteBUS_FLAT(mkrt, hdl, add_hdl);
489 MkErrorC.Check(hdl, errVal);
490 }
491
493 public void WriteDBL (double val) {
494 MkErrorE errVal = Mk.MkBufferStreamWriteDBL(mkrt, hdl, val);
495 MkErrorC.Check(hdl, errVal);
496 }
497
499 public void WriteFLT (float val) {
500 MkErrorE errVal = Mk.MkBufferStreamWriteFLT(mkrt, hdl, val);
501 MkErrorC.Check(hdl, errVal);
502 }
503
505 public void WriteHDL (int val) {
506 MkErrorE errVal = Mk.MkBufferStreamWriteHDL(mkrt, hdl, val);
507 MkErrorC.Check(hdl, errVal);
508 }
509
511 public void WriteI32 (int val) {
512 MkErrorE errVal = Mk.MkBufferStreamWriteI32(mkrt, hdl, val);
513 MkErrorC.Check(hdl, errVal);
514 }
515
517 public void WriteI64 (long val) {
518 MkErrorE errVal = Mk.MkBufferStreamWriteI64(mkrt, hdl, val);
519 MkErrorC.Check(hdl, errVal);
520 }
521
523 public void WriteI8 (byte val) {
524 MkErrorE errVal = Mk.MkBufferStreamWriteI8(mkrt, hdl, (Byte)(val));
525 MkErrorC.Check(hdl, errVal);
526 }
527
529 public void WriteLONG (long val) {
530 MkErrorE errVal = Mk.MkBufferStreamWriteLONG(mkrt, hdl, val);
531 MkErrorC.Check(hdl, errVal);
532 }
533
535 public void WriteL_END () {
536 MkErrorE errVal = Mk.MkBufferStreamWriteL_END(mkrt, hdl);
537 MkErrorC.Check(hdl, errVal);
538 }
539
541 public void WriteL_FLAT (MkBufferListC bfl) {
542 IntPtr bfl_hdl = MkBufferListC.getOBJ("MkBufferListC",bfl);
543 MkErrorE errVal = Mk.MkBufferStreamWriteL_FLAT(mkrt, hdl, bfl_hdl);
544 MkErrorC.Check(hdl, errVal);
545 }
546
548 public void WriteL_START () {
549 MkErrorE errVal = Mk.MkBufferStreamWriteL_START(mkrt, hdl);
550 MkErrorC.Check(hdl, errVal);
551 }
552
554 public void WriteSTR (string val, int len = -1) {
555 IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
556 MkErrorE errVal = Mk.MkBufferStreamWriteSTR(mkrt, hdl, val_cstr, len);
557 Marshal.FreeHGlobal(val_cstr);
558 MkErrorC.Check(hdl, errVal);
559 }
560
562 // MkBufferStreamC_Write_CS_API
563 }
564
565 // END-MkBufferStreamC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
566
567// #################################################################################
568
569 public partial class MkBufferStreamC {
570 }
571
572} // END - namespace "csmkkernel"
csmkkernel.MkKernel Mk
MkBufferC - the abstract class known as buf or buffer is used to create and manage dynamic,...
Definition MkBufferC.cs:716
static MkBufferC MkBufferC_ObjNew(IntPtr hdl)
Definition MkBufferC.cs:34
MkBufferListC - the class known as bfl or buffer-list is used to create and manage a list of MkBuffer...
static MkBufferListC MkBufferListC_ObjNew(IntPtr hdl)
MkBufferStreamC - the abstract class known as bus or stream is a subclass of MkBufferC and is used fo...
static MkBufferStreamC MkBufferStreamC_ObjNew(IntPtr hdl)
MkErrorC - the class known as err or error is used to create and manage an error message …
Definition MkErrorC.cs:498
static void Check(IntPtr ctx, MkErrorE err)
Definition MkErrorC.cs:74
static object atomObjNew(Type type, ConstructorInfo ctor, IntPtr obj)
Definition MkObjectC.cs:189
static IntPtr getOBJ_null_allow(MkObjectC obj)
Definition MkObjectC.cs:116
static object atomObjCreate(Type type, ConstructorInfo ctor, IntPtr obj)
Definition MkObjectC.cs:202
static void atomSelfUnlink(IntPtr self, IntPtr env)
Definition MkObjectC.cs:222
static object atomSelfNull(ConstructorInfo ctor)
Definition MkObjectC.cs:217
static IntPtr getOBJ(string cls, MkObjectC obj)
Definition MkObjectC.cs:109
static ConstructorInfo getCtor(Type type)
Definition MkObjectC.cs:244
static IntPtr atomSelfCreate(ConstructorInfo ctor, IntPtr obj, IntPtr env)
Definition MkObjectC.cs:207
static Mk.MkBinaryR MkBinaryCreate(long size, IntPtr data)
new static MkBufferStreamC Instances()
C#: [static] MkBufferStreamC MkBufferStreamC.Instances() → C-API get head-instance from linked-l...
new static MkBufferStreamC GetNull()
C#: [static] MkBufferStreamC MkBufferStreamC.GetNull() → C-API Null-Slot - return a MkBufferStre...
new MkBufferStreamC Prev()
C#: MkBufferStreamC bus.Prev() → C-API get previous instance from linked-list of MkBufferStream...
new static MkBufferStreamC HandleResolve(Int32 netHdl)
C#: [static] MkBufferStreamC MkBufferStreamC.HandleResolve(Int32 netHdl) → C-API Handle-Resolve-...
new MkBufferStreamC Next()
C#: MkBufferStreamC bus.Next() → C-API get next instance from linked-list of MkBufferStreamS ty...
MkBufferListC ToBFL()
C#: MkBufferListC bus.ToBFL() → C-API convert the bus into a MkBufferListC …
MkBufferStreamC Copy(MkBufferStreamC src)
C#: MkBufferStreamC bus.Copy(MkBufferStreamC src) → C-API copy the MkBufferStreamC from src to ...
void PosToStart()
C#: bus.PosToStart() → C-API set the current-access-position to the start of MkBufferStreamC …
void ResetFull()
C#: bus.ResetFull() → C-API reset a MkBufferStreamC to the length zero and free allocated stora...
MkBufferStreamC Reset()
C#: MkBufferStreamC bus.Reset() → C-API reset a MkBufferStreamC to the length zero …
bool ReadItemExists()
C#: bool bus.ReadItemExists() → C-API check if an item exists in the read-data-package …
MkBufferListC ReadALL(MkBufferListC val_inout=null)
C#: MkBufferListC bus.ReadALL(MkBufferListC val_inout = null) → C-API get a temporary MkBufferL...
byte[] ReadBIN()
C#: doc_mk_cs_BufferStreamReadBIN → C-API read a val_out from the MkBufferStreamC …
void ReadL_END()
C#: bus.ReadL_END() → C-API END read a list-item-type from the MkBufferStreamC …
int ReadI32()
C#: doc_mk_cs_BufferStreamReadI32 → C-API read a val_out from the MkBufferStreamC …
MkBufferC ReadBUF()
C#: MkBufferC bus.ReadBUF() → C-API read a val_out from the MkBufferStreamC …
long ReadLONG()
C#: long bus.ReadLONG() → C-API read the long native object from the MkBufferStreamC …
string ReadSTR()
C#: doc_mk_cs_BufferStreamReadSTR → C-API read a val_out from the MkBufferStreamC …
long ReadI64()
C#: doc_mk_cs_BufferStreamReadI64 → C-API read a val_out from the MkBufferStreamC …
MkBufferListC ReadBFL()
C#: MkBufferListC bus.ReadBFL() → C-API read a MkBufferListC from the MkBufferStreamC …
bool ReadBOL()
C#: doc_mk_cs_BufferStreamReadBOL → C-API read a val_out from the MkBufferStreamC …
double ReadDBL()
C#: doc_mk_cs_BufferStreamReadDBL → C-API read a val_out from the MkBufferStreamC …
MkTypeE ReadGetNextType()
C#: MkTypeE bus.ReadGetNextType() → C-API get the type (MkTypeE) of the next Item in the MkBuff...
void ReadL_START(MkBufferC buf=null)
C#: bus.ReadL_START(MkBufferC buf = null) → C-API START read a list-item-type from the MkBuffer...
int ReadGetNumItems()
C#: int bus.ReadGetNumItems() → C-API get the number of items left in the MkBufferStreamC …
float ReadFLT()
C#: doc_mk_cs_BufferStreamReadFLT → C-API read a val_out from the MkBufferStreamC …
void ReadUndo()
C#: bus.ReadUndo() → C-API undo the last MkBufferStreamC READ function call …
byte ReadI8()
C#: doc_mk_cs_BufferStreamReadI8 → C-API read a val_out from the MkBufferStreamC …
MkBufferStreamC(int size=0)
CONSTRUCTOR.
static MkBufferStreamC CreateTLS(string tlsName, bool resetB=true)
C#: [static] MkBufferStreamC MkBufferStreamC.CreateTLS(string tlsName, bool resetB = true) → C-API ...
MkBufferStreamC Dup()
C#: [constructor] MkBufferStreamC src.Dup() → C-API Dup-Constructor - create a new MkBufferStrea...
static MkBufferStreamC Create(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create(int size = 0) → C-API create and...
static MkBufferStreamC Create256(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create256(int size = 0) → C-API call th...
static MkBufferStreamC Create64(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create64(int size = 0) → C-API call the...
static IntPtr CTOR(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create(int size = 0) → C-API create and...
MkBufferStreamC Merge()
C#: [constructor] MkBufferStreamC bus.Merge() → C-API Merge-Constructor - create a new MkBufferS...
static MkBufferStreamC Create1024(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create1024(int size = 0) → C-API call t...
static MkBufferStreamC Create16384(int size=0)
C#: [constructor,static] MkBufferStreamC MkBufferStreamC.Create16384(int size = 0) → C-API call ...
void WriteDBL(double val)
C#: doc_mk_cs_BufferStreamWriteDBL → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteBIN(byte[] val)
C#: doc_mk_cs_BufferStreamWriteBIN → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteHDL(int val)
C#: bus.WriteHDL(int val) → C-API write the handle into the MkBufferStreamC …
void WriteI64(long val)
C#: doc_mk_cs_BufferStreamWriteI64 → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteI32(int val)
C#: doc_mk_cs_BufferStreamWriteI32 → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteLONG(long val)
C#: bus.WriteLONG(long val) → C-API write the long native object into the MkBufferStreamC …
void WriteL_FLAT(MkBufferListC bfl)
C#: bus.WriteL_FLAT(MkBufferListC bfl) → C-API write a MkBufferListC FLAT into the MkBufferStre...
void WriteBFL(MkBufferListC bfl)
C#: bus.WriteBFL(MkBufferListC bfl) → C-API write a MkBufferListC into the MkBufferStreamC …
void WriteBUS_FLAT(MkBufferStreamC add)
C#: bus.WriteBUS_FLAT(MkBufferStreamC add) → C-API write a MkBufferStreamC into the MkBufferStr...
void WriteSTR(string val, int len=-1)
C#: doc_mk_cs_BufferStreamWriteSTR → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteFLT(float val)
C#: doc_mk_cs_BufferStreamWriteFLT → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteBUF(MkBufferC val)
C#: bus.WriteBUF(MkBufferC val) → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteBOL(bool val)
C#: doc_mk_cs_BufferStreamWriteBOL → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteL_END()
C#: bus.WriteL_END() → C-API END write a list-item-type into the MkBufferStreamC …
void WriteI8(byte val)
C#: doc_mk_cs_BufferStreamWriteI8 → C-API write a PRIMITIVE TYPE into the MkBufferStreamC …
void WriteL_START()
C#: bus.WriteL_START() → C-API START write a list-item-type into the MkBufferStreamC …
void ErrorCheck(MkErrorE err)
Definition MkErrorC.cs:139
#define MK_NULL
The Programming-Language-Micro-Kernel (PLMK) NULL value as null in C# …
MkErrorE
→ C-API: MkErrorE → C-API: MkErrorE
MkTypeE
→ C-API: MkTypeE → C-API: MkTypeE