Qore Programming Language - C/C++ Library  0.8.13.6
params.h
Go to the documentation of this file.
1 /* -*- mode: c++; indent-tabs-mode: nil -*- */
2 /*
3  params.h
4 
5  Qore Programming Language
6 
7  Copyright (C) 2003 - 2017 Qore Technologies, s.r.o.
8 
9  Permission is hereby granted, free of charge, to any person obtaining a
10  copy of this software and associated documentation files (the "Software"),
11  to deal in the Software without restriction, including without limitation
12  the rights to use, copy, modify, merge, publish, distribute, sublicense,
13  and/or sell copies of the Software, and to permit persons to whom the
14  Software is furnished to do so, subject to the following conditions:
15 
16  The above copyright notice and this permission notice shall be included in
17  all copies or substantial portions of the Software.
18 
19  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
24  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25  DEALINGS IN THE SOFTWARE.
26 
27  Note that the Qore library is released under a choice of three open-source
28  licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
29  information.
30 */
31 
32 #ifndef _QORE_PARAMS_H
33 
34 #define _QORE_PARAMS_H
35 
36 #include <qore/AbstractQoreNode.h>
37 
42 
46 static inline unsigned num_args(const QoreListNode* n) {
47  return n ? (unsigned)n->size() : 0;
48 }
49 
51 
54 static inline unsigned num_args(const QoreValueList* n) {
55  return n ? (unsigned)n->size() : 0;
56 }
57 
59 
62 static inline unsigned num_params(const QoreListNode* n) {
63  return n ? (unsigned)n->size() : 0;
64 }
65 
67 
72 static inline const AbstractQoreNode* get_param(const QoreListNode* n, qore_size_t i) {
73  if (!n) return 0;
74  const AbstractQoreNode* p = n->retrieve_entry(i);
75  return is_nothing(p) ? 0 : p;
76 }
77 
79 
84 static inline qore_type_t get_param_type(const QoreListNode* n, qore_size_t i) {
85  if (!n) return NT_NOTHING;
86  const AbstractQoreNode* p = n->retrieve_entry(i);
87  return p ? p->getType() : NT_NOTHING;
88 }
89 
91 static inline int get_int_param(const QoreListNode* n, qore_size_t i) {
92  if (!n) return 0;
93  const AbstractQoreNode* p = n->retrieve_entry(i);
94  return is_nothing(p) ? 0 : p->getAsInt();
95 }
96 
98 static inline int64 get_bigint_param(const QoreListNode* n, qore_size_t i) {
99  if (!n) return 0;
100  const AbstractQoreNode* p = n->retrieve_entry(i);
101  return is_nothing(p) ? 0 : p->getAsBigInt();
102 }
103 
105 static inline int get_int_param_with_default(const QoreListNode* n, qore_size_t i, int def) {
106  if (!n) return def;
107  const AbstractQoreNode* p = n->retrieve_entry(i);
108  return is_nothing(p) ? def : p->getAsInt();
109 }
110 
113  if (!n) return def;
114  const AbstractQoreNode* p = n->retrieve_entry(i);
115  return is_nothing(p) ? def : p->getAsBigInt();
116 }
117 
119 static inline double get_float_param(const QoreListNode* n, qore_size_t i) {
120  if (!n) return 0;
121  const AbstractQoreNode* p = n->retrieve_entry(i);
122  return is_nothing(p) ? 0 : p->getAsFloat();
123 }
124 
126 static inline bool get_bool_param(const QoreListNode* n, qore_size_t i) {
127  if (!n) return 0;
128  const AbstractQoreNode* p = n->retrieve_entry(i);
129  return is_nothing(p) ? false : p->getAsBool();
130 }
131 
133 
138 static inline const BinaryNode* test_binary_param(const QoreListNode* n, qore_size_t i) {
139  if (!n) return 0;
140  const AbstractQoreNode* p = n->retrieve_entry(i);
141  // the following is faster than a dynamic_cast
142  return p && p->getType() == NT_BINARY ? reinterpret_cast<const BinaryNode*>(p) : 0;
143 }
144 
146 
151 static inline const QoreStringNode* test_string_param(const QoreListNode* n, qore_size_t i) {
152  if (!n) return 0;
153  const AbstractQoreNode* p = n->retrieve_entry(i);
154  // the following is faster than a dynamic_cast
155  return p && p->getType() == NT_STRING ? reinterpret_cast<const QoreStringNode*>(p) : 0;
156 }
157 
159 
165  if (!n) return 0;
166  const AbstractQoreNode* p = n->retrieve_entry(i);
167  // the following is faster than a dynamic_cast
168  return p && p->getType() == NT_OBJECT ? const_cast<QoreObject*>(reinterpret_cast<const QoreObject*>(p)) : 0;
169 }
170 
172 
177 static inline const DateTimeNode* test_date_param(const QoreListNode* n, qore_size_t i) {
178  if (!n) return 0;
179  const AbstractQoreNode* p = n->retrieve_entry(i);
180  // the following is faster than a dynamic_cast
181  return p && p->getType() == NT_DATE ? reinterpret_cast<const DateTimeNode*>(p) : 0;
182 }
183 
185 
190 static inline const QoreHashNode* test_hash_param(const QoreListNode* n, qore_size_t i) {
191  if (!n) return 0;
192  const AbstractQoreNode* p = n->retrieve_entry(i);
193  // the following is faster than a dynamic_cast
194  return p && p->getType() == NT_HASH ? reinterpret_cast<const QoreHashNode*>(p) : 0;
195 }
196 
198 
203 static inline const QoreListNode* test_list_param(const QoreListNode* n, qore_size_t i) {
204  if (!n) return 0;
205  const AbstractQoreNode* p = n->retrieve_entry(i);
206  // the following is faster than a dynamic_cast
207  return p && p->getType() == NT_LIST ? reinterpret_cast<const QoreListNode*>(p) : 0;
208 }
209 
211 
217  if (!n) return 0;
218  const AbstractQoreNode* p = n->retrieve_entry(i);
219  // the following is faster than a dynamic_cast
220  return p && (p->getType() == NT_FUNCREF || p->getType() == NT_RUNTIME_CLOSURE) ? reinterpret_cast<const ResolvedCallReferenceNode*>(p) : 0;
221 }
222 
224 
230  return test_callref_param(n, i);
231 }
232 
234 
240 static inline const ReferenceNode* test_reference_param(const QoreListNode* n, qore_size_t i) {
241  if (!n) return 0;
242  const AbstractQoreNode* p = n->retrieve_entry(i);
243  // the following is faster than a dynamic_cast
244  return p && p->getType() == NT_REFERENCE ? reinterpret_cast<const ReferenceNode*>(p) : 0;
245 }
246 
248 
253 static inline bool test_nothing_param(const QoreListNode* n, qore_size_t i) {
254  if (!n) return true;
255  return is_nothing(n->retrieve_entry(i));
256 }
257 
259 static inline const QoreEncoding* get_encoding_param(const QoreListNode* n, qore_size_t i, const QoreEncoding* def = QCS_DEFAULT) {
260  const QoreStringNode* str = test_string_param(n, i);
261  return str ? QEM.findCreate(str) : def;
262 }
263 
265 template <typename T>
266 static inline T* get_hard_or_nothing_param(const QoreListNode* n, qore_size_t i) {
267  assert(n);
268  return reinterpret_cast<T*>(n->retrieve_entry(i));
269 }
270 
272 template <typename T>
273 static inline T* get_hard_param(const QoreListNode* n, qore_size_t i) {
274  assert(n);
275  assert(dynamic_cast<T*>(n->retrieve_entry(i)));
276  return reinterpret_cast<T*>(n->retrieve_entry(i));
277 }
278 
279 static inline void HARD_QORE_DATA(const QoreListNode* n, qore_size_t i, const void*& ptr, qore_size_t& len) {
280  const AbstractQoreNode* p = get_hard_param<const AbstractQoreNode>(n, i);
281  if (p->getType() == NT_STRING) {
282  const QoreStringNode* str = reinterpret_cast<const QoreStringNode*>(p);
283  ptr = (const void*)str->getBuffer();
284  len = str->size();
285  return;
286  }
287  const BinaryNode* b = reinterpret_cast<const BinaryNode*>(p);
288  ptr = b->getPtr();
289  len = b->size();
290 }
291 
293 #define HARD_QORE_OR_NOTHING_PARAM(name, Type, list, i) Type* name = get_hard_or_nothing_param<Type>(list, i)
294 
296 #define HARD_QORE_PARAM(name, Type, list, i) Type* name = get_hard_param<Type>(list, i)
297 
299 #define HARD_QORE_INT(list, i) get_hard_param<const QoreBigIntNode>(list, i)->val
300 
302 #define HARD_QORE_FLOAT(list, i) get_hard_param<const QoreFloatNode>(list, i)->f
303 
305 #define HARD_QORE_NUMBER(list, i) get_hard_param<const QoreNumberNode>(list, i)
306 
308 #define HARD_QORE_BOOL(list, i) get_hard_param<const QoreBoolNode>(list, i)->getValue()
309 
311 #define HARD_QORE_STRING(list, i) get_hard_param<const QoreStringNode>(list, i)
312 
314 #define HARD_QORE_DATE(list, i) get_hard_param<const DateTimeNode>(list, i)
315 
317 #define HARD_QORE_BINARY(list, i) get_hard_param<const BinaryNode>(list, i)
318 
320 #define HARD_QORE_LIST(list, i) get_hard_param<const QoreListNode>(list, i)
321 
323 #define HARD_QORE_HASH(list, i) get_hard_param<const QoreHashNode>(list, i)
324 
326 #define HARD_QORE_REF(list, i) get_hard_param<const ReferenceNode>(list, i)
327 
329 #define HARD_QORE_OBJECT(list, i) const_cast<QoreObject*>(get_hard_param<const QoreObject>(list, i))
330 
331 // sets up an object pointer
332 #define HARD_QORE_OBJ_DATA(vname, Type, list, i, cid, dname, cname, xsink) HARD_QORE_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = reinterpret_cast<Type*>(obj_##vname->getReferencedPrivateData(cid, xsink)); if (!vname && !*xsink) xsink->raiseException("OBJECT-ALREADY-DELETED", "cannot complete call setup to %s() because parameter %d (<class %s>) has already been deleted", cname, i + 1, dname)
333 
334 // destructively sets up an object pointer; caller owns the pointer
335 #define TAKE_HARD_QORE_OBJ_DATA(vname, Type, list, i, cid, dname, cname, xsink) HARD_QORE_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = reinterpret_cast<Type*>(const_cast<QoreObject*>(obj_##vname)->getAndClearPrivateData(cid, xsink)); if (!vname && !*xsink) xsink->raiseException("OBJECT-ALREADY-DELETED", "cannot complete call setup to %s() because parameter %d (<class %s>) has already been deleted", cname, i + 1, dname); else if (vname) const_cast<QoreObject*>(obj_##vname)->doDelete(xsink)
336 
337 // sets up an object pointer
338 #define HARD_QORE_OBJ_OR_NOTHING_DATA(vname, Type, list, i, cid, xsink) HARD_QORE_OR_NOTHING_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = obj_##vname ? reinterpret_cast<Type*>(obj_##vname->getReferencedPrivateData(cid, xsink)) : 0;
339 
342  HARD_QORE_PARAM(str, const QoreStringNode, n, i);
343  return QEM.findCreate(str);
344 }
345 
347 
353  if (!n)
354  return QoreValue();
355  return n->retrieveEntry(i);
356 }
357 
359 template <typename T>
361  assert(n);
362  return n->retrieveEntry(i).get<T>();
363 }
364 
367  assert(n);
368  return n->retrieveEntry(i);
369 }
370 
372 #define HARD_QORE_VALUE_OR_NOTHING_PARAM(name, Type, list, i) Type* name = get_hard_value_or_nothing_param<Type>(list, i)
373 
375 #define HARD_QORE_VALUE_PARAM(name, Type, list, i) Type* name = get_hard_value_param(list, i).get<Type>()
376 
378 #define HARD_QORE_VALUE_INT(list, i) get_hard_value_param(list, i).getAsBigInt()
379 
381 #define HARD_QORE_VALUE_FLOAT(list, i) get_hard_value_param(list, i).getAsFloat()
382 
384 #define HARD_QORE_VALUE_NUMBER(list, i) get_hard_value_param(list, i).get<const QoreNumberNode>()
385 
387 #define HARD_QORE_VALUE_BOOL(list, i) get_hard_value_param(list, i).getAsBool()
388 
390 #define HARD_QORE_VALUE_STRING(list, i) get_hard_value_param(list, i).get<const QoreStringNode>()
391 
393 #define HARD_QORE_VALUE_DATE(list, i) get_hard_value_param(list, i).get<const DateTimeNode>()
394 
396 #define HARD_QORE_VALUE_BINARY(list, i) get_hard_value_param(list, i).get<const BinaryNode>()
397 
399 #define HARD_QORE_VALUE_LIST(list, i) get_hard_value_param(list, i).get<const QoreListNode>()
400 
402 #define HARD_QORE_VALUE_HASH(list, i) get_hard_value_param(list, i).get<const QoreHashNode>()
403 
405 #define HARD_QORE_VALUE_REF(list, i) get_hard_value_param(list, i).get<const ReferenceNode>()
406 
408 #define HARD_QORE_VALUE_OBJECT(list, i) const_cast<QoreObject*>(get_hard_value_param(list, i).get<const QoreObject>())
409 
411 #define HARD_QORE_VALUE_OBJ_DATA(vname, Type, list, i, cid, dname, cname, xsink) HARD_QORE_VALUE_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = reinterpret_cast<Type*>(obj_##vname->getReferencedPrivateData(cid, xsink)); if (!vname && !*xsink) xsink->raiseException("OBJECT-ALREADY-DELETED", "cannot complete call setup to %s() because parameter %d (<class %s>) has already been deleted", cname, i + 1, dname)
412 
414 #define TAKE_HARD_QORE_VALUE_OBJ_DATA(vname, Type, list, i, cid, dname, cname, xsink) HARD_QORE_VALUE_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = reinterpret_cast<Type*>(const_cast<QoreObject*>(obj_##vname)->getAndClearPrivateData(cid, xsink)); if (!vname && !*xsink) xsink->raiseException("OBJECT-ALREADY-DELETED", "cannot complete call setup to %s() because parameter %d (<class %s>) has already been deleted", cname, i + 1, dname); else if (vname) const_cast<QoreObject*>(obj_##vname)->doDelete(xsink)
415 
417 #define HARD_QORE_VALUE_OBJ_OR_NOTHING_DATA(vname, Type, list, i, cid, xsink) HARD_QORE_VALUE_OR_NOTHING_PARAM(obj_##vname, const QoreObject, list, i); Type* vname = obj_##vname ? reinterpret_cast<Type*>(obj_##vname->getReferencedPrivateData(cid, xsink)) : 0;
418 
421  const QoreStringNode* str = HARD_QORE_VALUE_STRING(n, i);
422  return str ? QEM.findCreate(str) : def;
423 }
424 
425 static inline const QoreEncoding* get_hard_qore_value_encoding_param(const QoreValueList* n, qore_size_t i) {
426  HARD_QORE_VALUE_PARAM(str, const QoreStringNode, n, i);
427  return QEM.findCreate(str);
428 }
429 
430 #endif
const qore_type_t NT_BINARY
type value for BinaryNode
Definition: node_types.h:49
DLLLOCAL detail::QoreValueCastHelper< T >::Result get()
returns the value as the given type
Definition: QoreValue.h:270
defines string encoding functions in Qore
Definition: QoreEncoding.h:85
DLLLOCAL qore_type_t getType() const
returns the data type
Definition: AbstractQoreNode.h:296
#define HARD_QORE_PARAM(name, Type, list, i)
returns a hard typed parameter
Definition: params.h:296
static QoreValue get_hard_value_param(const QoreValueList *n, qore_size_t i)
returns the given type for hard typed parameters
Definition: params.h:366
DLLEXPORT int getAsInt() const
returns the integer value of the object
This is the hash or associative list container type in Qore, dynamically allocated only...
Definition: QoreHashNode.h:50
static const ResolvedCallReferenceNode * test_callref_param(const QoreListNode *n, qore_size_t i)
returns a ResolvedCallReferenceNode pointer for the argument position given or 0 if there is no argum...
Definition: params.h:216
DLLEXPORT const QoreEncoding * QCS_DEFAULT
the default encoding for the Qore library
static int get_int_param_with_default(const QoreListNode *n, qore_size_t i, int def)
returns an integer corresponding to the argument given or a default value if there is none ...
Definition: params.h:105
static const ResolvedCallReferenceNode * test_funcref_param(const QoreListNode *n, qore_size_t i)
returns a ResolvedCallReferenceNode pointer for the argument position given or 0 if there is no argum...
Definition: params.h:229
static const QoreHashNode * test_hash_param(const QoreListNode *n, qore_size_t i)
returns a QoreHashNode pointer for the argument position given or 0 if there is no argument there or ...
Definition: params.h:190
const qore_type_t NT_LIST
type value for QoreListNode
Definition: node_types.h:50
DLLEXPORT bool getAsBool() const
returns the boolean value of the object
This is the list container type in Qore, dynamically allocated only, reference counted.
Definition: QoreValueList.h:45
The base class for all value and parse types in Qore expression trees.
Definition: AbstractQoreNode.h:54
static QoreValue get_param_value(const QoreValueList *n, qore_size_t i)
returns the argument in the position given or 0 if there is none
Definition: params.h:352
static T * get_hard_or_nothing_param(const QoreListNode *n, qore_size_t i)
returns the given type for hard typed parameters
Definition: params.h:266
const qore_type_t NT_NOTHING
type value for QoreNothingNode
Definition: node_types.h:42
static T * get_hard_value_or_nothing_param(const QoreValueList *n, qore_size_t i)
returns the given type for hard typed parameters
Definition: params.h:360
const qore_type_t NT_OBJECT
type value for QoreObject
Definition: node_types.h:52
size_t qore_size_t
used for sizes (same range as a pointer)
Definition: common.h:74
static const DateTimeNode * test_date_param(const QoreListNode *n, qore_size_t i)
returns a DateTimeNode pointer for the argument position given or 0 if there is no argument there or ...
Definition: params.h:177
static const ReferenceNode * test_reference_param(const QoreListNode *n, qore_size_t i)
returns a ReferenceNode pointer for the argument position given or 0 if there is no argument there or...
Definition: params.h:240
const qore_type_t NT_DATE
type value for DateTimeNode
Definition: node_types.h:46
static const QoreEncoding * get_hard_qore_encoding_param(const QoreListNode *n, qore_size_t i)
returns the QoreEncoding corresponding to the string passed or a default encoding ...
Definition: params.h:341
const qore_type_t NT_FUNCREF
type value for AbstractCallReferenceNode
Definition: node_types.h:71
static QoreObject * test_object_param(const QoreListNode *n, qore_size_t i)
returns a QoreObject pointer for the argument position given or 0 if there is no argument there or if...
Definition: params.h:164
static const BinaryNode * test_binary_param(const QoreListNode *n, qore_size_t i)
returns a const BinaryNode pointer for the argument position given or 0 if there is no argument there...
Definition: params.h:138
DLLEXPORT AbstractQoreNode * retrieve_entry(qore_size_t index)
returns the element at "index" (first element is index 0)
Qore&#39;s string value type, reference counted, dynamically-allocated only.
Definition: QoreStringNode.h:50
DLLEXPORT const char * getBuffer() const
returns the string&#39;s buffer; this data should not be changed
static unsigned num_args(const QoreListNode *n)
returns the number of arguments passed to the function
Definition: params.h:46
static bool is_nothing(const AbstractQoreNode *n)
to check if an AbstractQoreNode object is NOTHING
Definition: QoreLib.h:319
static const QoreEncoding * get_value_encoding_param(const QoreValueList *n, qore_size_t i, const QoreEncoding *def=QCS_DEFAULT)
returns the QoreEncoding corresponding to the string passed or a default encoding ...
Definition: params.h:420
static T * get_hard_param(const QoreListNode *n, qore_size_t i)
returns the given type for hard typed parameters
Definition: params.h:273
This is the list container type in Qore, dynamically allocated only, reference counted.
Definition: QoreListNode.h:52
DLLEXPORT QoreEncodingManager QEM
the QoreEncodingManager object
Qore&#39;s parse tree/value type for date-time values, reference-counted, dynamically-allocated only...
Definition: DateTimeNode.h:45
static bool get_bool_param(const QoreListNode *n, qore_size_t i)
returns a boolean value corresponding to the argument given or false if there is none ...
Definition: params.h:126
parse type: reference to a lvalue expression
Definition: ReferenceNode.h:45
const qore_type_t NT_RUNTIME_CLOSURE
type value for ResolvedCallReferenceNode (QoreClosureNode, QoreObjectClosureNode) ...
Definition: node_types.h:74
const qore_type_t NT_HASH
type value for QoreHashNode
Definition: node_types.h:51
static bool test_nothing_param(const QoreListNode *n, qore_size_t i)
returns true if the arugment position given is NOTHING
Definition: params.h:253
const qore_type_t NT_REFERENCE
type value for ReferenceNode
Definition: node_types.h:64
static DLLEXPORT const QoreEncoding * findCreate(const char *name)
finds an encoding if it exists (also looks up against alias names) and creates a new one if it doesn&#39;...
static const QoreListNode * test_list_param(const QoreListNode *n, qore_size_t i)
returns a QoreListNode pointer for the argument position given or 0 if there is no argument there or ...
Definition: params.h:203
DLLEXPORT size_t size() const
returns the number of elements in the list
The main value class in Qore, designed to be passed by value.
Definition: QoreValue.h:112
const qore_type_t NT_STRING
type value for QoreStringNode
Definition: node_types.h:45
static const QoreStringNode * test_string_param(const QoreListNode *n, qore_size_t i)
returns a const QoreStringNode pointer for the argument position given or 0 if there is no argument t...
Definition: params.h:151
the implementation of Qore&#39;s object data type, reference counted, dynamically-allocated only ...
Definition: QoreObject.h:62
DLLEXPORT int64 getAsBigInt() const
returns the 64-bit integer value of the object
static unsigned num_params(const QoreListNode *n)
returns the number of arguments passed to the function
Definition: params.h:62
#define HARD_QORE_VALUE_PARAM(name, Type, list, i)
returns a hard typed parameter
Definition: params.h:375
long long int64
64bit integer type, cannot use int64_t here since it breaks the API on some 64-bit systems due to equ...
Definition: common.h:241
DLLEXPORT const void * getPtr() const
returns the pointer to the data
static int64 get_bigint_param(const QoreListNode *n, qore_size_t i)
returns a 64-bit integer corresponding to the argument given or 0 if there is none ...
Definition: params.h:98
#define HARD_QORE_VALUE_STRING(list, i)
returns a const QoreStringNode* from a hard typed string param
Definition: params.h:390
DLLEXPORT double getAsFloat() const
returns the float value of the object
base class for resolved call references
Definition: CallReferenceNode.h:130
static int64 get_bigint_param_with_default(const QoreListNode *n, qore_size_t i, int64 def)
returns a 64-bit integer corresponding to the argument given or a default value if there is none ...
Definition: params.h:112
DLLEXPORT QoreValue retrieveEntry(size_t index)
returns the element at "index" (first element is index 0)
int16_t qore_type_t
used to identify unique Qore data and parse types (descendents of AbstractQoreNode) ...
Definition: common.h:71
static const QoreEncoding * get_encoding_param(const QoreListNode *n, qore_size_t i, const QoreEncoding *def=QCS_DEFAULT)
returns the QoreEncoding corresponding to the string passed or a default encoding ...
Definition: params.h:259
static double get_float_param(const QoreListNode *n, qore_size_t i)
returns a float corresponding to the argument given or 0 if there is none
Definition: params.h:119
DLLEXPORT qore_size_t size() const
returns the number of bytes in the object
DLLEXPORT qore_size_t size() const
returns the number of elements in the list
DLLEXPORT qore_size_t size() const
returns number of bytes in the string (not including the null pointer)
static int get_int_param(const QoreListNode *n, qore_size_t i)
returns an integer corresponding to the argument given or 0 if there is none
Definition: params.h:91
static const AbstractQoreNode * get_param(const QoreListNode *n, qore_size_t i)
returns the argument in the position given or 0 if there is none
Definition: params.h:72
static qore_type_t get_param_type(const QoreListNode *n, qore_size_t i)
returns the argument type in the position given or 0 if there is none
Definition: params.h:84
holds arbitrary binary data
Definition: BinaryNode.h:41