Commit | Line | Data |
---|---|---|
970ed795 EL |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Copyright (c) 2000-2014 Ericsson Telecom AB | |
3 | // All rights reserved. This program and the accompanying materials | |
4 | // are made available under the terms of the Eclipse Public License v1.0 | |
5 | // which accompanies this distribution, and is available at | |
6 | // http://www.eclipse.org/legal/epl-v10.html | |
7 | /////////////////////////////////////////////////////////////////////////////// | |
8 | #ifndef BASETYPE_HH | |
9 | #define BASETYPE_HH | |
10 | ||
11 | #include "Types.h" | |
12 | #include "Encdec.hh" | |
13 | #include "RInt.hh" | |
14 | #include "JSON_Tokenizer.hh" | |
15 | #include "Vector.hh" | |
16 | #ifdef TITAN_RUNTIME_2 | |
17 | #include "Struct_of.hh" | |
af710487 | 18 | #include "XER.hh" |
970ed795 EL |
19 | #endif |
20 | ||
21 | struct ASN_BERdescriptor_t; | |
22 | struct ASN_BER_TLV_t; | |
23 | struct TTCN_RAWdescriptor_t; | |
24 | struct TTCN_TEXTdescriptor_t; | |
25 | struct XERdescriptor_t; | |
26 | struct TTCN_JSONdescriptor_t; | |
27 | class XmlReaderWrap; | |
28 | class Module_Param; | |
af710487 | 29 | struct embed_values_enc_struct_t; |
30 | struct embed_values_dec_struct_t; | |
970ed795 EL |
31 | |
32 | /** @brief Type descriptor | |
33 | * | |
34 | * There is one type descriptor object for each type. | |
35 | * Descriptors for built-in types are supplied by the runtime. | |
36 | * Descriptors for user-defined types are written by the compiler | |
37 | * in the generated code. | |
38 | */ | |
39 | struct TTCN_Typedescriptor_t { | |
40 | const char * const name; /**< Name of the type, e.g INTEGER, REAL, verdicttype, etc */ | |
41 | const ASN_BERdescriptor_t * const ber; /**< Information for BER coding */ | |
42 | const TTCN_RAWdescriptor_t * const raw; /**< Information for RAW coding */ | |
43 | const TTCN_TEXTdescriptor_t * const text; /**< Information for TEXT coding */ | |
44 | const XERdescriptor_t * const xer; /**< Information for XER */ | |
45 | const TTCN_JSONdescriptor_t * const json; /**< Information for JSON coding */ | |
46 | /** ASN subtype | |
47 | * | |
48 | * Used by classes implementing more than one ASN.1 type | |
49 | * (OBJID and UNIVERSAL_CHARSTRING). | |
50 | */ | |
51 | enum { | |
52 | DONTCARE, | |
53 | UNIVERSALSTRING, BMPSTRING, UTF8STRING, | |
54 | TELETEXSTRING, VIDEOTEXSTRING, GRAPHICSTRING, GENERALSTRING, | |
55 | OBJID, ROID | |
56 | } const asnbasetype; | |
57 | }; | |
58 | ||
59 | #ifdef TITAN_RUNTIME_2 | |
60 | ||
61 | struct Erroneous_value_t { | |
62 | const bool raw; | |
63 | const Base_Type * const errval; // NULL if `omit' | |
64 | const TTCN_Typedescriptor_t* type_descr; // NULL if `omit' or raw | |
65 | }; | |
66 | ||
67 | struct Erroneous_values_t { | |
68 | const int field_index; | |
69 | const char* field_qualifier; | |
70 | const Erroneous_value_t * const before; | |
71 | const Erroneous_value_t * const value; | |
72 | const Erroneous_value_t * const after; | |
73 | }; | |
74 | ||
75 | struct Erroneous_descriptor_t { | |
76 | const int field_index; | |
77 | const int omit_before; // -1 if none | |
78 | const char* omit_before_qualifier; // NULL if none | |
79 | const int omit_after; // -1 if none | |
80 | const char* omit_after_qualifier; // NULL if none | |
81 | const int values_size; | |
82 | const Erroneous_values_t * const values_vec; | |
83 | const int embedded_size; | |
84 | const Erroneous_descriptor_t * const embedded_vec; | |
85 | /** search in values_vec for the field with index field_idx */ | |
86 | const Erroneous_values_t* get_field_err_values(int field_idx) const; | |
87 | /** search in embedded_vec for the field with index field_idx */ | |
88 | const Erroneous_descriptor_t* get_field_emb_descr(int field_idx) const; | |
89 | /** if the current element of values_vec has index field_idx then returns it and increments values_idx */ | |
90 | const Erroneous_values_t* next_field_err_values(const int field_idx, int& values_idx) const; | |
91 | /** if the current element of embedded_vec has index field_idx then returns it and increments edescr_idx */ | |
92 | const Erroneous_descriptor_t* next_field_emb_descr(const int field_idx, int& edescr_idx) const; | |
93 | void log() const; | |
94 | void log_() const; | |
95 | }; | |
96 | ||
97 | #endif | |
98 | ||
99 | class TTCN_Type_list; | |
100 | class RAW_enc_tree; | |
101 | class Limit_Token_List; | |
102 | #ifdef TITAN_RUNTIME_2 | |
103 | class Text_Buf; | |
104 | #endif | |
105 | ||
106 | #ifdef TITAN_RUNTIME_2 | |
107 | #define VIRTUAL_IF_RUNTIME_2 virtual | |
108 | #else | |
109 | #define VIRTUAL_IF_RUNTIME_2 | |
110 | #endif | |
111 | ||
112 | /** | |
113 | * The base class for all types in TTCN-3 runtime environment. | |
114 | * | |
115 | * Uses the compiler-generated default constructor, copy constructor | |
116 | * and assignment operator (they do nothing because the class is empty). | |
117 | */ | |
118 | class Base_Type { | |
119 | public: | |
120 | ||
121 | /** Whether the value is present. | |
122 | * Note: this is not the TTCN-3 ispresent(), kept for backward compatibility! | |
123 | * causes DTE, must be used only if the field is OPTIONAL<> | |
124 | */ | |
125 | VIRTUAL_IF_RUNTIME_2 boolean ispresent() const; | |
126 | ||
127 | VIRTUAL_IF_RUNTIME_2 void log() const; | |
128 | ||
129 | /** Check whether the XML encoding of the type can begin with an XML element | |
130 | * having the specified name and namespace. | |
131 | * | |
132 | * This function checks for the "starter tag" of the type. This usually | |
133 | * means the tag should match the name in the XER descriptor, | |
134 | * with a few notable exceptions: | |
135 | * | |
136 | * - If the type is untagged, then | |
137 | * - if it's a record, all fields up to the the first non-optional field | |
138 | * are checked; | |
139 | * - if it's a record-of, the element is checked. | |
140 | * - A \c universal \c charstring with ANY-ELEMENT can begin with any tag. | |
141 | * | |
142 | * @param name the XML element name (local name) | |
143 | * @param uri the namespace URI of the element | |
144 | * @param xd XER descriptor | |
145 | * @param flavor one or more bits from XER_flavor. Only XER_EXTENDED counts | |
146 | * @return TRUE if the XML element can begin the XER encoding of the type, | |
147 | * FALSE otherwise. | |
148 | */ | |
149 | static boolean can_start(const char *name, const char *uri, | |
150 | XERdescriptor_t const& xd, unsigned int flavor); | |
151 | ||
152 | #ifdef TITAN_RUNTIME_2 | |
153 | virtual void set_param(Module_Param& param) = 0; | |
154 | /** Whether the type is a sequence-of. | |
155 | * @return \c FALSE */ | |
156 | virtual boolean is_seof() const { return FALSE; } | |
157 | ||
158 | virtual void encode_text(Text_Buf& text_buf) const = 0; | |
159 | virtual void decode_text(Text_Buf& text_buf) = 0; | |
160 | ||
161 | virtual boolean is_bound() const = 0; | |
162 | virtual boolean is_value() const { return is_bound(); } | |
163 | virtual void clean_up() = 0; | |
164 | ||
165 | /** returns if the value of this is equal to the value of the parameter. */ | |
166 | virtual boolean is_equal(const Base_Type* other_value) const = 0; | |
167 | ||
168 | /** Performs: *this = *other_value. | |
169 | * Does not take ownership of \p other_value. */ | |
170 | virtual void set_value(const Base_Type* other_value) = 0; | |
171 | ||
172 | /** creates a copy of this object, returns a pointer to it. */ | |
173 | virtual Base_Type* clone() const = 0; | |
174 | ||
175 | /** return reference to the type descriptor object for this type. */ | |
176 | virtual const TTCN_Typedescriptor_t* get_descriptor() const = 0; | |
177 | ||
178 | /** @name override in class OPTIONAL<T> | |
179 | * @{ */ | |
180 | virtual boolean is_optional() const { return FALSE; } | |
181 | ||
182 | /** Is the optional value present or omit. | |
183 | * @return \c true if present, \c false otherwise | |
184 | * used for TTCN-3 ispresent() | |
185 | **/ | |
186 | virtual boolean is_present() const; | |
187 | ||
188 | /** Access the embedded type of the optional. | |
189 | * | |
190 | * The implementation in Base_Type always causes a dynamic testcase error. | |
191 | */ | |
192 | virtual Base_Type* get_opt_value(); | |
193 | ||
194 | /** Access the embedded type of the optional. | |
195 | * | |
196 | * The implementation in Base_Type always causes a dynamic testcase error. | |
197 | */ | |
198 | virtual const Base_Type* get_opt_value() const; | |
199 | ||
200 | /** Set the optional field to \c omit. | |
201 | * The implementation in Base_Type always causes a dynamic testcase error. | |
202 | */ | |
203 | virtual void set_to_omit(); | |
204 | ||
205 | /** Set the optional field to present. | |
206 | * The implementation in Base_Type always causes a dynamic testcase error. | |
207 | */ | |
208 | virtual void set_to_present(); | |
209 | /** @} */ | |
af710487 | 210 | |
970ed795 EL |
211 | virtual ~Base_Type() { } |
212 | ||
213 | #endif | |
214 | ||
215 | /** Do nothing for non-structured types. */ | |
216 | VIRTUAL_IF_RUNTIME_2 void set_implicit_omit() { } | |
217 | ||
218 | /** @brief Encode an instance of this object | |
219 | ||
220 | Description: | |
221 | ||
222 | @param p_td type descriptor | |
223 | @param p_buf buffer | |
224 | @param p_coding coding type to select BER, RAW or TEXT coding | |
225 | ||
226 | */ | |
227 | VIRTUAL_IF_RUNTIME_2 void encode(const TTCN_Typedescriptor_t& p_td, | |
228 | TTCN_Buffer& p_buf, TTCN_EncDec::coding_t p_coding, ...) const; | |
229 | ||
230 | /** @brief Decode an instance of this object | |
231 | ||
232 | Description: | |
233 | ||
234 | @param p_td type descriptor | |
235 | @param p_buf buffer | |
236 | @param p_coding coding type to select BER, RAW or TEXT coding | |
237 | ||
238 | */ | |
239 | VIRTUAL_IF_RUNTIME_2 void decode(const TTCN_Typedescriptor_t& p_td, | |
240 | TTCN_Buffer& p_buf, TTCN_EncDec::coding_t p_coding, ...); | |
241 | ||
242 | protected: | |
243 | /** Check type descriptor for BER encoding | |
244 | * | |
245 | * @param p_td a TTCN type descriptor | |
246 | * | |
247 | * Calls TTCN_EncDec_ErrorContext::error_internal if | |
248 | * p_td has no BER descriptor. | |
249 | */ | |
250 | static void BER_chk_descr(const TTCN_Typedescriptor_t& p_td); | |
251 | ||
252 | /** Check the BER coding | |
253 | * | |
254 | * If \p p_coding is either BER_ENCODE_CER or BER_ENCODE_DER, | |
255 | * this function does nothing. Otherwise, it issues a warning | |
256 | * and sets \p p_coding to BER_ENCODE_DER. | |
257 | * | |
258 | * @param[in, out] p_coding BER coding | |
259 | * @post p_coding is either BER_ENCODE_CER or BER_ENCODE_DER | |
260 | */ | |
261 | static void BER_encode_chk_coding(unsigned& p_coding); | |
262 | ||
263 | /** Check type descriptor for XER encoding and the XER coding variant | |
264 | * | |
265 | * @param[in, out] p_coding XER coding | |
266 | * @param[in] p_td TTCN type descriptor | |
267 | * | |
268 | * If \p p_td has no XER descriptor, calls | |
269 | * TTCN_EncDec_ErrorContext::error_internal() | |
270 | * | |
271 | * If \p p_coding is one of XER_BASIC, XER_CANONICAL or XER_EXTENDED, | |
272 | * this function does nothing. Otherwise, it issues a warning | |
273 | * and sets \p p_coding to XER_BASIC. | |
274 | * | |
275 | * @post p_coding is one of XER_BASIC, XER_CANONICAL or XER_EXTENDED | |
276 | */ | |
277 | static void XER_encode_chk_coding(unsigned& p_coding, | |
278 | const TTCN_Typedescriptor_t& p_td); | |
279 | ||
280 | /** Check bound and create a 0-length TLV in case unbound is ignored. | |
281 | * | |
282 | * @param[in] p_isbound | |
283 | * @return a newly constructed and empty \c ASN_BER_TLV_t | |
284 | * if p_isbound is false, or NULL if p_isbound is true | |
285 | * @note if p_isbound is false, this function calls | |
286 | * TTCN_EncDec_ErrorContext::error with TTCN_EncDec::ET_UNBOUND. | |
287 | * If that error is not ignored, this function does not return at all. | |
288 | */ | |
289 | static ASN_BER_TLV_t* BER_encode_chk_bound(boolean p_isbound); | |
290 | ||
291 | private: | |
292 | static void BER_encode_putoctets_OCTETSTRING | |
293 | (unsigned char *target, | |
294 | unsigned int octetnum_start, unsigned int octet_count, | |
295 | int p_nof_octets, const unsigned char *p_octets_ptr); | |
296 | ||
297 | protected: | |
298 | static ASN_BER_TLV_t* BER_encode_TLV_OCTETSTRING | |
299 | (unsigned p_coding, | |
300 | int p_nof_octets, const unsigned char *p_octets_ptr); | |
301 | ||
302 | static ASN_BER_TLV_t *BER_encode_TLV_INTEGER(unsigned p_coding, | |
303 | const int_val_t& p_int_val); | |
304 | static ASN_BER_TLV_t *BER_encode_TLV_INTEGER(unsigned p_coding, | |
305 | const int& p_int_val); | |
306 | ||
307 | static void BER_encode_chk_enum_valid(const TTCN_Typedescriptor_t& p_td, | |
308 | boolean p_isvalid, int p_value); | |
309 | ||
310 | static void BER_decode_str2TLV(TTCN_Buffer& p_buf, ASN_BER_TLV_t& p_tlv, | |
311 | unsigned L_form); | |
312 | ||
313 | static boolean BER_decode_constdTLV_next(const ASN_BER_TLV_t& p_tlv, | |
314 | size_t& V_pos, | |
315 | unsigned L_form, | |
316 | ASN_BER_TLV_t& p_target_tlv); | |
317 | ||
318 | static void BER_decode_constdTLV_end(const ASN_BER_TLV_t& p_tlv, | |
319 | size_t& V_pos, | |
320 | unsigned L_form, | |
321 | ASN_BER_TLV_t& p_target_tlv, | |
322 | boolean tlv_present); | |
323 | ||
324 | static void BER_decode_strip_tags(const ASN_BERdescriptor_t& p_ber, | |
325 | const ASN_BER_TLV_t& p_tlv, | |
326 | unsigned L_form, | |
327 | ASN_BER_TLV_t& stripped_tlv); | |
328 | ||
329 | private: | |
330 | static void BER_decode_getoctets_OCTETSTRING | |
331 | (const unsigned char *source, size_t s_len, | |
332 | unsigned int& octetnum_start, | |
333 | int& p_nof_octets, unsigned char *p_octets_ptr); | |
334 | ||
335 | protected: | |
336 | static void BER_decode_TLV_OCTETSTRING | |
337 | (const ASN_BER_TLV_t& p_tlv, unsigned L_form, | |
338 | unsigned int& octetnum_start, | |
339 | int& p_nof_octets, unsigned char *p_octets_ptr); | |
340 | ||
341 | static boolean BER_decode_TLV_INTEGER(const ASN_BER_TLV_t& p_tlv, | |
342 | unsigned L_form, int_val_t& p_int_val); | |
343 | static boolean BER_decode_TLV_INTEGER(const ASN_BER_TLV_t& p_tlv, | |
344 | unsigned L_form, int& p_int_val); | |
345 | ||
346 | static boolean BER_decode_TLV_CHOICE(const ASN_BERdescriptor_t& p_ber, | |
347 | const ASN_BER_TLV_t& p_tlv, | |
348 | unsigned L_form, | |
349 | ASN_BER_TLV_t& p_target_tlv); | |
350 | ||
351 | static boolean BER_decode_CHOICE_selection(boolean select_result, | |
352 | const ASN_BER_TLV_t& p_tlv); | |
353 | ||
354 | static void BER_decode_chk_enum_valid(const TTCN_Typedescriptor_t& p_td, | |
355 | boolean p_isvalid, int p_value); | |
356 | ||
357 | public: | |
358 | VIRTUAL_IF_RUNTIME_2 ASN_BER_TLV_t* BER_encode_TLV( | |
359 | const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
360 | #ifdef TITAN_RUNTIME_2 | |
361 | virtual ASN_BER_TLV_t* BER_encode_TLV_negtest(const Erroneous_descriptor_t* /*p_err_descr*/, | |
362 | const TTCN_Typedescriptor_t& /*p_td*/, unsigned /*p_coding*/) const; | |
363 | virtual ASN_BER_TLV_t* BER_encode_negtest_raw() const; | |
364 | virtual int encode_raw(TTCN_Buffer& p_buf) const; | |
365 | virtual int RAW_encode_negtest_raw(RAW_enc_tree& p_myleaf) const; | |
366 | #endif | |
367 | ||
368 | /** Examines whether this message corresponds the tags in the | |
369 | * descriptor. If the BER descriptor contains no tags, then returns | |
370 | * TRUE. Otherwise, examines the first (outermost) tag only. */ | |
371 | #ifdef TITAN_RUNTIME_2 | |
372 | virtual | |
373 | #else | |
374 | static | |
375 | #endif | |
376 | boolean BER_decode_isMyMsg(const TTCN_Typedescriptor_t& p_td, | |
377 | const ASN_BER_TLV_t& p_tlv); | |
378 | ||
379 | /** Returns TRUE on success, FALSE otherwise. */ | |
380 | VIRTUAL_IF_RUNTIME_2 boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td, | |
381 | const ASN_BER_TLV_t& p_tlv, unsigned L_form); | |
382 | ||
383 | VIRTUAL_IF_RUNTIME_2 void BER_decode_opentypes( | |
384 | TTCN_Type_list& /*p_typelist*/, unsigned /*L_form*/) {} | |
385 | ||
386 | /** Encode with RAW coding. | |
387 | * @return the length of the encoding | |
388 | * @param p_td type descriptor | |
389 | * @param myleaf filled with RAW encoding data | |
390 | * @note Basetype::RAW_encode throws an error. */ | |
391 | VIRTUAL_IF_RUNTIME_2 int RAW_encode(const TTCN_Typedescriptor_t& p_td, | |
392 | RAW_enc_tree& myleaf) const; | |
393 | #ifdef TITAN_RUNTIME_2 | |
394 | virtual int RAW_encode_negtest(const Erroneous_descriptor_t *p_err_descr, | |
395 | const TTCN_Typedescriptor_t& p_td, RAW_enc_tree& myleaf) const; | |
396 | #endif | |
397 | ||
398 | /** Decode with RAW coding | |
399 | * | |
400 | * @param p_td type descriptor | |
401 | * @param p_buf buffer with data to be decoded | |
402 | * @param limit number of bits the decoder is allowed to use. At the top level | |
403 | * this is 8x the number of bytes in the buffer. | |
404 | * @param top_bit_ord (LSB/MSB) from TTCN_RAWdescriptor_t::top_bit_order | |
405 | * @param no_err set to TRUE if the decoder is to return errors silently, | |
406 | * without calling TTCN_EncDec_ErrorContext::error | |
407 | * @param sel_field selected field indicator for CROSSTAG, or -1 | |
408 | * @param first_call default TRUE. May be FALSE for a REPEATABLE record-of | |
409 | * inside a set, if an element has been successfully decoded. | |
410 | * @return length of decoded field, or a negative number for error | |
411 | * @note Basetype::RAW_decode throws an error. */ | |
412 | VIRTUAL_IF_RUNTIME_2 int RAW_decode( | |
413 | const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, | |
414 | raw_order_t top_bit_ord, boolean no_err=FALSE, int sel_field=-1, | |
415 | boolean first_call=TRUE); | |
416 | ||
417 | ||
418 | /** Encode with TEXT encoding. | |
419 | * @return the length of the encoding | |
420 | * @param p_td type descriptor | |
421 | * @param p_buf buffer for the encoded data | |
422 | * @note Basetype::TEXT_encode throws an error. */ | |
423 | VIRTUAL_IF_RUNTIME_2 int TEXT_encode(const TTCN_Typedescriptor_t& p_td, | |
424 | TTCN_Buffer& p_buf) const; | |
425 | ||
426 | #ifdef TITAN_RUNTIME_2 | |
427 | /** Encode with TEXT encoding negative test. | |
428 | * @return the length of the encoding | |
429 | * @param p_err_descr type descriptor | |
430 | * @param p_td type descriptor | |
431 | * @param p_buf buffer for the encoded data | |
432 | * @note Basetype::TEXT_encode_negtest throws an error. */ | |
433 | virtual int TEXT_encode_negtest(const Erroneous_descriptor_t* p_err_descr, const TTCN_Typedescriptor_t& p_td, | |
434 | TTCN_Buffer& p_buf) const; | |
435 | #endif | |
436 | ||
437 | /** Decode TEXT. | |
438 | * @return decoded length | |
439 | * @note Basetype::TEXT_decode throws an error. */ | |
440 | VIRTUAL_IF_RUNTIME_2 int TEXT_decode( | |
441 | const TTCN_Typedescriptor_t&, TTCN_Buffer&, Limit_Token_List&, | |
442 | boolean no_err=FALSE, boolean first_call=TRUE); | |
443 | ||
444 | /** Write the XER encoding of the current object into the buffer. | |
445 | * | |
446 | * @param p_td type descriptor | |
447 | * @param p_buf buffer | |
448 | * @param flavor one of XER_flavor values | |
449 | * @param indent indentation level | |
af710487 | 450 | * @param emb_val embed values data (only relevant for record of types) |
970ed795 EL |
451 | * @return number of bytes written into the buffer |
452 | */ | |
453 | VIRTUAL_IF_RUNTIME_2 int XER_encode(const XERdescriptor_t& p_td, | |
af710487 | 454 | TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t* emb_val) const; |
970ed795 EL |
455 | |
456 | #ifdef TITAN_RUNTIME_2 | |
457 | virtual int XER_encode_negtest(const Erroneous_descriptor_t* /*p_err_descr*/, | |
458 | const XERdescriptor_t& /*p_td*/, TTCN_Buffer& /*p_buf*/, | |
af710487 | 459 | unsigned int /*flavor*/, int /*indent*/, embed_values_enc_struct_t* /*emb_val*/) const; |
970ed795 EL |
460 | #endif |
461 | ||
462 | /** Decode the current object from the supplied buffer. | |
463 | * | |
464 | * The XML pull parser presents a forward iterator over the XML elements. | |
465 | * @pre Upon entering this function, the current node should be the one corresponding | |
466 | * to this object, or possibly a text or whitespace node before it. | |
467 | * Code should begin like this: | |
468 | * @code | |
469 | * int Foo::XER_decode() { | |
470 | * int success=1, type; | |
471 | * for ( ; success==1; success=reader.Read() ) { | |
472 | * int type=reader.NodeType(); | |
473 | * if (XML_READER_TYPE_ELEMENT==type) { | |
474 | * verify_name( | |
475 | * } | |
476 | * } | |
477 | * } | |
478 | * @endcode | |
479 | * | |
480 | * @post Upon leaving the function, the current node should be \b past | |
481 | * the end tag, i.e. the next start tag (or any whitespace before it). | |
482 | * | |
483 | * It is important not to advance the parser too far, to avoid "stealing" | |
484 | * the content of other fields (the parser can only go forward). | |
485 | * | |
486 | * @param p_td type descriptor | |
487 | * @param reader Wrapper around the XML processor | |
488 | * @param flavor one of XER_flavor values | |
af710487 | 489 | * @param emb_val embed values data (only relevant for record of types) |
970ed795 EL |
490 | * @return number of bytes "consumed" |
491 | */ | |
492 | VIRTUAL_IF_RUNTIME_2 int XER_decode(const XERdescriptor_t& p_td, | |
af710487 | 493 | XmlReaderWrap& reader, unsigned int flavor, embed_values_dec_struct_t* emb_val); |
970ed795 EL |
494 | |
495 | /** Return an array of namespace declarations. | |
496 | * | |
497 | * @param[in] p_td XER descriptor of the type. | |
498 | * @param[out] num set to the number of strings returned. | |
499 | * @param[out] def_ns set to @p true if a default namespace was encountered | |
500 | * @return an array of strings or NULL. All the strings in the array | |
501 | * and the array itself must be deallocated by the caller (if num>0). | |
502 | * | |
503 | * The strings are in the following format: | |
504 | * @code " xmlns:prefix='uri'" @endcode | |
505 | * (the space at start allows direct concatenation of the strings) | |
506 | */ | |
507 | VIRTUAL_IF_RUNTIME_2 char ** collect_ns(const XERdescriptor_t& p_td, | |
508 | size_t& num, bool& def_ns) const; | |
509 | ||
510 | /** Copy strings from @p new_namespaces to @p collected_ns, | |
511 | * discarding duplicates. | |
512 | * | |
513 | * May reallocate @p collected_ns, in which case @p num_collected | |
514 | * is adjusted accordingly. | |
515 | * | |
516 | * @param collected_ns target array | |
517 | * @param num_collected number of already collected namespaces | |
518 | * @param new_namespaces new array | |
519 | * @param num_new number of new namespaces | |
520 | * | |
521 | * @post new_namespaces has been deallocated and set to NULL. | |
522 | */ | |
523 | static void merge_ns(char **&collected_ns, size_t& num_collected, | |
524 | char **new_namespaces, size_t num_new); | |
525 | ||
526 | typedef char** (Base_Type::*collector_fn) | |
527 | (const XERdescriptor_t& p_td, size_t& num, bool& def_ns) const; | |
528 | ||
529 | /** Start writing the XML representation | |
530 | * | |
531 | * @param[in] p_td XER descriptor | |
532 | * @param[out] p_buf buffer to write into | |
533 | * @param[in,out] flavor XER variant (basic, canonical or extended), | |
534 | * also used to pass various flags between begin_xml and its caller | |
535 | * @param[in] indent indentation level | |
536 | * @param[in] empty true if an empty-element tag is needed | |
537 | * @param[in] collector namespace collector function | |
538 | * @param[in] type_atr type identification attribute for useNil/useUnion, | |
539 | * in the following format: "xsi:type='foo'" | |
540 | * @return "omit_tag": zero if the type's own tag was written (not omitted | |
541 | * e.g. due to untagged). | |
542 | * If the XML tag was omitted, the return value is nonzero. | |
543 | * The special value -1 is returned if the XML in the buffer | |
544 | * was shortened by exactly one character. | |
545 | */ | |
546 | VIRTUAL_IF_RUNTIME_2 int begin_xml(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
547 | unsigned int& flavor, int indent, bool empty, | |
548 | collector_fn collector = &Base_Type::collect_ns, const char *type_atr = NULL) const; | |
549 | /** Finish the XML representation. | |
550 | * | |
551 | * @param[in] p_td XER descriptor | |
552 | * @param[out] p_buf buffer to write into | |
553 | * @param[in] flavor XER variant (basic, canonical or extended), | |
554 | * also used to pass various flags | |
555 | * @param[in] indent indentation level | |
556 | * @param[in] empty true if an empty-element tag is needed | |
557 | */ | |
558 | VIRTUAL_IF_RUNTIME_2 void end_xml (const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
559 | unsigned int flavor, int indent, bool empty) const; | |
560 | ||
561 | /** Encode JSON. | |
562 | * @return encoded length | |
563 | * @note Basetype::JSON_encode throws an error. */ | |
564 | VIRTUAL_IF_RUNTIME_2 int JSON_encode(const TTCN_Typedescriptor_t& p_td, JSON_Tokenizer&) const; | |
565 | ||
566 | /** Decode JSON. | |
567 | * @return decoded length | |
568 | * @note Basetype::JSON_decode throws an error. */ | |
569 | VIRTUAL_IF_RUNTIME_2 int JSON_decode(const TTCN_Typedescriptor_t& p_td, JSON_Tokenizer&, boolean); | |
570 | ||
571 | /** not a component by default (components will return true) */ | |
572 | inline boolean is_component() { return FALSE; } | |
573 | }; | |
574 | ||
575 | /** | |
576 | * This class is used by BER decoding to handle | |
577 | * ComponentRelationConstraint. | |
578 | */ | |
579 | class TTCN_Type_list { | |
580 | private: | |
581 | size_t n_types; | |
582 | const Base_Type **types; | |
583 | /// Copy constructor disabled | |
584 | TTCN_Type_list(const TTCN_Type_list&); | |
585 | /// Assignment disabled | |
586 | TTCN_Type_list& operator=(const TTCN_Type_list&); | |
587 | public: | |
588 | TTCN_Type_list() : n_types(0), types(NULL) {} | |
589 | ~TTCN_Type_list(); | |
590 | void push(const Base_Type *p_type); | |
591 | const Base_Type* pop(); | |
592 | /** If \a pos is 0 then returns the outermost, otherwise the "pos"th | |
593 | * inner parent. */ | |
594 | const Base_Type* get_nth(size_t pos) const; | |
595 | }; | |
596 | ||
597 | /** @name Type descriptor objects | |
598 | @{ | |
599 | */ | |
600 | extern const TTCN_Typedescriptor_t BOOLEAN_descr_; | |
601 | extern const TTCN_Typedescriptor_t INTEGER_descr_; | |
602 | extern const TTCN_Typedescriptor_t FLOAT_descr_; | |
603 | extern const TTCN_Typedescriptor_t VERDICTTYPE_descr_; | |
604 | extern const TTCN_Typedescriptor_t OBJID_descr_; | |
605 | extern const TTCN_Typedescriptor_t BITSTRING_descr_; | |
606 | extern const TTCN_Typedescriptor_t HEXSTRING_descr_; | |
607 | extern const TTCN_Typedescriptor_t OCTETSTRING_descr_; | |
608 | extern const TTCN_Typedescriptor_t CHARSTRING_descr_; | |
609 | extern const TTCN_Typedescriptor_t UNIVERSAL_CHARSTRING_descr_; | |
610 | extern const TTCN_Typedescriptor_t COMPONENT_descr_; | |
611 | extern const TTCN_Typedescriptor_t DEFAULT_descr_; | |
612 | extern const TTCN_Typedescriptor_t ASN_NULL_descr_; | |
613 | extern const TTCN_Typedescriptor_t ASN_ANY_descr_; | |
614 | extern const TTCN_Typedescriptor_t EXTERNAL_descr_; | |
615 | extern const TTCN_Typedescriptor_t EMBEDDED_PDV_descr_; | |
616 | extern const TTCN_Typedescriptor_t CHARACTER_STRING_descr_; | |
617 | extern const TTCN_Typedescriptor_t ObjectDescriptor_descr_; | |
618 | extern const TTCN_Typedescriptor_t UTF8String_descr_; | |
619 | extern const TTCN_Typedescriptor_t ASN_ROID_descr_; | |
620 | extern const TTCN_Typedescriptor_t NumericString_descr_; | |
621 | extern const TTCN_Typedescriptor_t PrintableString_descr_; | |
622 | extern const TTCN_Typedescriptor_t TeletexString_descr_; | |
623 | extern const TTCN_Typedescriptor_t& T61String_descr_; | |
624 | extern const TTCN_Typedescriptor_t VideotexString_descr_; | |
625 | extern const TTCN_Typedescriptor_t IA5String_descr_; | |
626 | extern const TTCN_Typedescriptor_t ASN_GeneralizedTime_descr_; | |
627 | extern const TTCN_Typedescriptor_t ASN_UTCTime_descr_; | |
628 | extern const TTCN_Typedescriptor_t GraphicString_descr_; | |
629 | extern const TTCN_Typedescriptor_t VisibleString_descr_; | |
630 | extern const TTCN_Typedescriptor_t& ISO646String_descr_; | |
631 | extern const TTCN_Typedescriptor_t GeneralString_descr_; | |
632 | extern const TTCN_Typedescriptor_t UniversalString_descr_; | |
633 | extern const TTCN_Typedescriptor_t BMPString_descr_; | |
634 | /** @} */ | |
635 | ||
636 | #ifdef TITAN_RUNTIME_2 | |
637 | ||
638 | class Text_Buf; | |
639 | class INTEGER; | |
640 | ||
641 | /** The base class of all record-of types when using RT2 | |
642 | * | |
643 | */ | |
644 | // Record_Of_Template can be found in Template.hh | |
645 | class Record_Of_Type : public Base_Type | |
646 | { | |
647 | friend class Set_Of_Template; | |
648 | friend class Record_Of_Template; | |
649 | protected: | |
650 | friend boolean operator==(null_type null_value, | |
651 | const Record_Of_Type& other_value); | |
652 | struct recordof_setof_struct { | |
653 | int ref_count; | |
654 | int n_elements; | |
655 | Base_Type **value_elements; | |
656 | } *val_ptr; | |
657 | Erroneous_descriptor_t* err_descr; | |
658 | ||
af710487 | 659 | struct refd_index_struct { |
660 | /** Stores the indices of elements that are referenced by 'out' and 'inout' parameters. | |
661 | * These elements must not be deleted.*/ | |
662 | Vector<int> refd_indices; | |
663 | ||
664 | /** Cached maximum value of \a refd_indices (default: -1).*/ | |
665 | int max_refd_index; | |
666 | } *refd_ind_ptr; | |
970ed795 EL |
667 | |
668 | static boolean compare_function(const Record_Of_Type *left_ptr, int left_index, const Record_Of_Type *right_ptr, int right_index); | |
af710487 | 669 | Record_Of_Type() : val_ptr(NULL), err_descr(NULL), refd_ind_ptr(NULL) {} |
970ed795 EL |
670 | Record_Of_Type(null_type other_value); |
671 | Record_Of_Type(const Record_Of_Type& other_value); | |
672 | /// Assignment disabled | |
673 | Record_Of_Type& operator=(const Record_Of_Type& other_value); | |
674 | ||
675 | /** Returns the number of actual elements in the record of (does not count the | |
676 | * unbound elements left at the end of the record of struct to make sure | |
677 | * referenced elements are not deleted). */ | |
678 | int get_nof_elements() const; | |
679 | ||
680 | /** Returns true if the indexed element is bound */ | |
681 | bool is_elem_bound(int index) const; | |
682 | ||
683 | /** Returns the highest referenced index (uses \a max_refd_index as its cache)*/ | |
684 | int get_max_refd_index(); | |
685 | ||
686 | /** Returns true if the element at the given index is referenced by an 'out' or | |
687 | * 'inout' parameter. */ | |
688 | bool is_index_refd(int index); | |
689 | ||
690 | public: | |
691 | void set_val(null_type other_value); | |
692 | ||
693 | boolean operator==(null_type other_value) const; | |
694 | boolean operator!=(null_type other_value) const; | |
695 | ||
696 | Base_Type* get_at(int index_value); | |
697 | Base_Type* get_at(const INTEGER& index_value); | |
698 | const Base_Type* get_at(int index_value) const; | |
699 | const Base_Type* get_at(const INTEGER& index_value) const; | |
700 | ||
701 | virtual boolean is_equal(const Base_Type* other_value) const; | |
702 | virtual void set_value(const Base_Type* other_value); | |
703 | ||
704 | /* following functions return rec_of or this or other_value */ | |
705 | Record_Of_Type* rotl(const INTEGER& rotate_count, Record_Of_Type* rec_of) const; | |
706 | Record_Of_Type* rotr(int rotate_count, Record_Of_Type* rec_of) const; | |
707 | Record_Of_Type* rotr(const INTEGER& rotate_count, Record_Of_Type* rec_of) const; | |
708 | Record_Of_Type* concat(const Record_Of_Type* other_value, Record_Of_Type* rec_of) const; | |
709 | /* parameter rec_of must be a newly created descendant object, these helper functions fill it */ | |
710 | void substr_(int index, int returncount, Record_Of_Type* rec_of) const; | |
711 | void replace_(int index, int len, const Record_Of_Type* repl, Record_Of_Type* rec_of) const; | |
712 | void replace_(int index, int len, const Record_Of_Template* repl, Record_Of_Type* rec_of) const; | |
713 | void replace_(int index, int len, const Set_Of_Template* repl, Record_Of_Type* rec_of) const; | |
714 | ||
715 | void set_size(int new_size); | |
716 | ||
717 | /** Implementation for isbound. | |
718 | * @return \c true if the Record_Of itself is bound, \c false otherwise. | |
719 | * Ignores elements. No need to be overridden. */ | |
720 | virtual boolean is_bound() const; | |
721 | /** Implementation for isvalue. | |
722 | * @return \c true if all elements are bound, \c false otherwise */ | |
723 | virtual boolean is_value() const; | |
724 | virtual void clean_up(); | |
725 | ||
726 | virtual boolean is_seof() const { return TRUE; } | |
727 | ||
728 | /** Implementation for the \c sizeof operation | |
729 | * @return the number of elements */ | |
730 | int size_of() const; | |
731 | int n_elem() const { return size_of(); } | |
732 | ||
733 | /** Implementation for the lengthof operation. | |
734 | * @return the index of the last bound element +1 */ | |
735 | int lengthof() const; | |
736 | virtual void log() const; | |
737 | virtual void set_param(Module_Param& param); | |
738 | virtual void set_implicit_omit(); | |
739 | virtual void encode_text(Text_Buf& text_buf) const; | |
740 | virtual void decode_text(Text_Buf& text_buf); | |
741 | ||
742 | virtual void BER_decode_opentypes(TTCN_Type_list& p_typelist, unsigned L_form); | |
743 | ||
744 | virtual void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const; | |
745 | virtual void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...); | |
746 | ||
747 | virtual ASN_BER_TLV_t* BER_encode_TLV(const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
748 | virtual ASN_BER_TLV_t* BER_encode_TLV_negtest(const Erroneous_descriptor_t* p_err_descr, const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
749 | virtual boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td, const ASN_BER_TLV_t& p_tlv, unsigned L_form); | |
750 | ||
751 | virtual int RAW_encode_negtest(const Erroneous_descriptor_t *p_err_descr, const TTCN_Typedescriptor_t& p_td, RAW_enc_tree& myleaf) const; | |
752 | virtual int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
753 | /** Decode RAW | |
754 | * | |
755 | * @param td type descriptor | |
756 | * @param buf buffer | |
757 | * @param limit max number of bits that can be used | |
758 | * @param top_bit_ord | |
759 | * @param no_err (not used) | |
760 | * @param sel_field | |
761 | * @param first_call default true, false for second and subsequent calls | |
762 | * of a REPEATABLE record-of. Equivalent to "not repeated" | |
763 | * @return number of bits used, or a negative number in case of error | |
764 | */ | |
765 | virtual int RAW_decode(const TTCN_Typedescriptor_t& td, TTCN_Buffer& buf, int limit, | |
766 | raw_order_t top_bit_ord, boolean no_err=FALSE, int sel_field=-1, boolean first_call=TRUE); | |
767 | /// raw extension bit | |
768 | virtual int rawdec_ebv() const; | |
769 | ||
770 | virtual int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
771 | virtual int TEXT_encode_negtest(const Erroneous_descriptor_t* p_err_descr, const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
772 | virtual int TEXT_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, Limit_Token_List&, boolean no_err=FALSE, boolean first_call=TRUE); | |
773 | ||
774 | virtual int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
af710487 | 775 | unsigned int flavor, int indent, embed_values_enc_struct_t*) const; |
970ed795 | 776 | virtual int XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr, |
af710487 | 777 | const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned flavor, int indent, embed_values_enc_struct_t*) const; |
970ed795 EL |
778 | /// Helper for XER_encode_negtest |
779 | int encode_element(int i, const Erroneous_values_t* err_vals, | |
780 | const Erroneous_descriptor_t* emb_descr, | |
af710487 | 781 | TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t* emb_val) const; |
782 | virtual int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader, unsigned int, embed_values_dec_struct_t*); | |
970ed795 EL |
783 | virtual boolean isXerAttribute() const; |
784 | virtual boolean isXmlValueList() const; | |
785 | ||
786 | /** Encodes accordingly to the JSON encoding rules. | |
787 | * Returns the length of the encoded data. */ | |
788 | int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const; | |
789 | ||
790 | /** Decodes accordingly to the JSON encoding rules. | |
791 | * Returns the length of the decoded data. */ | |
792 | int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean); | |
793 | ||
794 | /** @returns \c true if this is a set-of type, | |
795 | * \c false if this is a record-of type */ | |
796 | virtual boolean is_set() const = 0; | |
797 | /** return the type descriptor of the element */ | |
798 | virtual const TTCN_Typedescriptor_t* get_elem_descr() const = 0; | |
799 | /** creates an instance of the record's element class, using the default constructor */ | |
800 | virtual Base_Type* create_elem() const = 0; | |
801 | ||
802 | /** Constant unbound element - return this instead of NULL in constant functions */ | |
803 | virtual const Base_Type* get_unbound_elem() const = 0; | |
804 | ||
805 | virtual char ** collect_ns(const XERdescriptor_t& p_td, size_t& num, bool& def_ns) const; | |
806 | virtual boolean can_start_v(const char *name, const char *prefix, | |
807 | XERdescriptor_t const& xd, unsigned int flavor) = 0; | |
808 | ||
809 | void set_err_descr(Erroneous_descriptor_t* p_err_descr) { err_descr=p_err_descr; } | |
810 | Erroneous_descriptor_t* get_err_descr() const { return err_descr; } | |
811 | ||
812 | /** Indicates that the element at the given index is referenced by an 'out' or | |
813 | * 'inout' parameter and must not be deleted. | |
814 | * Used just before the actual function call that references the element. */ | |
815 | void add_refd_index(int index); | |
816 | ||
817 | /** Indicates that the element at the given index is no longer referenced by | |
818 | * an 'out' or 'inout' parameter. | |
819 | * Used immediately after the actual function call that referenced the element. */ | |
820 | void remove_refd_index(int index); | |
821 | }; | |
822 | ||
823 | extern boolean operator==(null_type null_value, | |
824 | const Record_Of_Type& other_value); | |
825 | extern boolean operator!=(null_type null_value, | |
826 | const Record_Of_Type& other_value); | |
827 | ||
828 | //////////////////////////////////////////////////////////////////////////////// | |
829 | ||
830 | /** The base class of all record types when using RT2 */ | |
831 | // Record_Template can be found in Template.hh | |
832 | class Record_Type : public Base_Type { | |
833 | protected: | |
834 | struct default_struct { | |
835 | int index; | |
836 | const Base_Type* value; | |
837 | }; | |
838 | Erroneous_descriptor_t* err_descr; | |
839 | boolean bound_flag; | |
840 | public: | |
841 | Record_Type() : err_descr(NULL), bound_flag(false) {} | |
842 | ||
843 | /// @{ | |
844 | /** get pointer to a field */ | |
845 | virtual Base_Type* get_at(int index_value) = 0; | |
846 | virtual const Base_Type* get_at(int index_value) const = 0; | |
847 | /// @} | |
848 | ||
849 | /** get the index to a field based on its name and namespace URI, or -1 */ | |
850 | int get_index_byname(const char *name, const char *uri) const; | |
851 | ||
852 | /** get number of fields */ | |
853 | virtual int get_count() const = 0; | |
854 | /** number of optional fields */ | |
855 | virtual int optional_count() const { return 0; } | |
856 | ||
857 | /** virtual functions inherited from Base_Type */ | |
858 | boolean is_equal(const Base_Type* other_value) const; | |
859 | void set_value(const Base_Type* other_value); | |
860 | ||
861 | /** @returns \c true if this is a set type, | |
862 | * \c false if this is a record type */ | |
863 | virtual boolean is_set() const = 0; | |
864 | ||
865 | /** return the name of a field */ | |
866 | virtual const char* fld_name(int field_index) const = 0; | |
867 | ||
868 | /** return the descriptor of a field */ | |
869 | virtual const TTCN_Typedescriptor_t* fld_descr(int field_index) const = 0; | |
870 | ||
871 | /** return int array which contains the indexes of optional fields | |
872 | and a -1 value appended to the end, or return NULL if no optional fields, | |
873 | generated classes override if there are optional fields */ | |
874 | virtual const int* get_optional_indexes() const { return NULL; } | |
875 | /** default values and indexes, if no default fields then returns NULL, | |
876 | the last default_struct.index is -1 */ | |
877 | virtual const default_struct* get_default_indexes() const { return NULL; } | |
878 | ||
879 | /** override if it's TRUE for the specific type (if sdef->opentype_outermost) */ | |
880 | virtual boolean is_opentype_outermost() const { return FALSE; } | |
881 | ||
882 | virtual boolean default_as_optional() const { return FALSE; } | |
883 | ||
884 | virtual boolean is_bound() const; | |
885 | virtual boolean is_value() const; | |
886 | virtual void clean_up(); | |
887 | virtual void log() const; | |
888 | virtual void set_param(Module_Param& param); | |
889 | virtual void set_implicit_omit(); | |
890 | ||
891 | int size_of() const; | |
892 | virtual void encode_text(Text_Buf& text_buf) const; | |
893 | virtual void decode_text(Text_Buf& text_buf); | |
894 | ||
895 | virtual void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const; | |
896 | virtual void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...); | |
897 | ||
898 | virtual ASN_BER_TLV_t* BER_encode_TLV(const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
899 | virtual ASN_BER_TLV_t* BER_encode_TLV_negtest(const Erroneous_descriptor_t* p_err_descr, | |
900 | const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
901 | virtual boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td, const ASN_BER_TLV_t& p_tlv, unsigned L_form); | |
902 | virtual void BER_decode_opentypes(TTCN_Type_list& p_typelist, unsigned L_form); | |
903 | ||
904 | virtual int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
905 | virtual int RAW_encode_negtest(const Erroneous_descriptor_t *, const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
906 | virtual int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err = FALSE, int sel_field = -1, boolean first_call = TRUE); | |
907 | // Helper functions for RAW enc/dec, shall be overridden in descendants if the default behavior is not enough. | |
908 | virtual boolean raw_has_ext_bit() const { return FALSE; } | |
909 | ||
910 | virtual int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
911 | virtual int TEXT_encode_negtest(const Erroneous_descriptor_t* p_err_descr, const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
912 | virtual int TEXT_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, Limit_Token_List&, boolean no_err=FALSE, boolean first_call=TRUE); | |
913 | ||
914 | virtual int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
af710487 | 915 | unsigned int flavor, int indent, embed_values_enc_struct_t*) const; |
970ed795 EL |
916 | virtual int XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr, |
917 | const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
af710487 | 918 | unsigned int flavor, int indent, embed_values_enc_struct_t*) const; |
919 | virtual int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader, | |
920 | unsigned int, embed_values_dec_struct_t*); | |
970ed795 EL |
921 | /// @{ |
922 | /// Methods overridden in the derived (generated) class | |
923 | virtual int get_xer_num_attr() const { return 0; /* default */ } | |
924 | virtual const XERdescriptor_t* xer_descr(int field_index) const; | |
925 | /// @} | |
926 | virtual char ** collect_ns(const XERdescriptor_t& p_td, size_t& num, bool& def_ns) const; | |
927 | virtual boolean can_start_v(const char *name, const char *prefix, | |
928 | XERdescriptor_t const& xd, unsigned int flavor) = 0; | |
929 | ||
930 | /** Encodes accordingly to the JSON encoding rules. | |
931 | * Returns the length of the encoded data. */ | |
932 | int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const; | |
933 | ||
934 | /** Decodes accordingly to the JSON encoding rules. | |
935 | * Returns the length of the decoded data. */ | |
936 | int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean); | |
937 | ||
938 | void set_err_descr(Erroneous_descriptor_t* p_err_descr) { err_descr=p_err_descr; } | |
939 | Erroneous_descriptor_t* get_err_descr() const { return err_descr; } | |
940 | private: | |
941 | /// Helper for XER_encode_negtest | |
942 | int encode_field(int i, const Erroneous_values_t* err_vals, const Erroneous_descriptor_t* emb_descr, | |
af710487 | 943 | TTCN_Buffer& p_buf, unsigned int sub_flavor, int indent, embed_values_enc_struct_t* emb_val) const; |
970ed795 EL |
944 | }; |
945 | ||
946 | //////////////////////////////////////////////////////////////////////////////// | |
947 | class Empty_Record_Type : public Base_Type { | |
948 | protected: | |
949 | boolean bound_flag; | |
950 | ||
951 | Empty_Record_Type(); | |
952 | Empty_Record_Type(const Empty_Record_Type& other_value); | |
953 | ||
954 | public: | |
955 | boolean operator==(null_type other_value) const; | |
956 | inline boolean operator!=(null_type other_value) const { return !(*this == other_value); } | |
957 | ||
958 | /** virtual functions inherited from Base_Type */ | |
959 | virtual boolean is_equal(const Base_Type* other_value) const; | |
960 | virtual void set_value(const Base_Type* other_value); | |
961 | ||
962 | /** @returns \c true if this is a set type, | |
963 | * \c false if this is a record type */ | |
964 | virtual boolean is_set() const = 0; | |
965 | ||
966 | inline void set_null() { bound_flag = TRUE; } | |
967 | virtual boolean is_bound() const { return bound_flag; } | |
968 | virtual void clean_up() { bound_flag = FALSE; } | |
969 | virtual void log() const; | |
970 | virtual void set_param(Module_Param& param); | |
971 | ||
972 | int size_of() const { return 0; } | |
973 | virtual void encode_text(Text_Buf& text_buf) const; | |
974 | virtual void decode_text(Text_Buf& text_buf); | |
975 | ||
976 | virtual void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const; | |
977 | virtual void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...); | |
978 | ||
979 | virtual ASN_BER_TLV_t* BER_encode_TLV(const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const; | |
980 | virtual boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td, const ASN_BER_TLV_t& p_tlv, unsigned L_form); | |
981 | ||
982 | virtual int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
983 | virtual int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE, int sel_field=-1, boolean first_call=TRUE); | |
984 | ||
985 | virtual int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
986 | virtual int TEXT_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, Limit_Token_List&, boolean no_err=FALSE, boolean first_call=TRUE); | |
987 | ||
988 | virtual int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, | |
af710487 | 989 | unsigned int flavor, int indent, embed_values_enc_struct_t*) const; |
990 | virtual int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader, | |
991 | unsigned int, embed_values_dec_struct_t*); | |
970ed795 EL |
992 | |
993 | /** Encodes accordingly to the JSON encoding rules. | |
994 | * Returns the length of the encoded data. */ | |
995 | virtual int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const; | |
996 | ||
997 | /** Decodes accordingly to the JSON encoding rules. | |
998 | * Returns the length of the decoded data. */ | |
999 | virtual int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean); | |
1000 | }; | |
1001 | ||
1002 | struct Enum_Type : public Base_Type { | |
1003 | virtual int as_int() const = 0; | |
1004 | virtual void from_int(int) = 0; | |
1005 | }; | |
1006 | ||
1007 | extern boolean operator==(null_type null_value, const Empty_Record_Type& other_value); | |
1008 | extern boolean operator!=(null_type null_value, const Empty_Record_Type& other_value); | |
1009 | ||
1010 | #undef VIRTUAL_IF_RUNTIME_2 | |
1011 | #endif | |
1012 | ||
1013 | template <class EXPR_TYPE> | |
1014 | class Lazy_Param { | |
1015 | protected: | |
1016 | bool expr_evaluated; | |
1017 | EXPR_TYPE expr_cache; | |
1018 | virtual void eval_expr() {} | |
1019 | public: | |
1020 | Lazy_Param(): expr_evaluated(false) {} | |
1021 | enum evaluated_state_t { EXPR_EVALED }; | |
1022 | Lazy_Param(evaluated_state_t /*p_es*/, EXPR_TYPE p_cache): expr_evaluated(true), expr_cache(p_cache) {} | |
1023 | operator EXPR_TYPE&() { | |
1024 | if (!expr_evaluated) { eval_expr(); expr_evaluated=true; } | |
1025 | return expr_cache; | |
1026 | } | |
1027 | virtual ~Lazy_Param() {} | |
1028 | }; | |
1029 | ||
1030 | #endif |