core/Optional.hh

   1 /******************************************************************************
   2  * Copyright (c) 2000-2016 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  * Contributors:
   9  *   Baji, Laszlo
  10  *   Balasko, Jeno
  11  *   Baranyi, Botond
  12  *   Beres, Szabolcs
  13  *   Delic, Adam
  14  *   Forstner, Matyas
  15  *   Horvath, Gabriella
  16  *   Kovacs, Ferenc
  17  *   Ormandi, Matyas
  18  *   Raduly, Csaba
  19  *   Szabados, Kristof
  20  *   Szabo, Bence Janos
  21  *   Szabo, Janos Zoltan – initial implementation
  22  *   Szalai, Gabor
  23  *
  24  ******************************************************************************/
  25 #ifndef OPTIONAL_HH
  26 #define OPTIONAL_HH
  27
  28 #include "Types.h"
  29 #include "Param_Types.hh"
  30 #include "Basetype.hh"
  31 #include "Template.hh"
  32 #include "BER.hh"
  33 #include "Logger.hh"
  34 #include "Encdec.hh"
  35 #include "Textbuf.hh"
  36 #include "Error.hh"
  37 #include "Parameters.h"
  38 #include "XER.hh"
  39 #include "JSON.hh"
  40 #include "XmlReader.hh"
  41
  42 enum optional_sel { OPTIONAL_UNBOUND, OPTIONAL_OMIT, OPTIONAL_PRESENT };
  43
  44 template <typename T_type>
  45 class OPTIONAL : public Base_Type
  46 #ifdef TITAN_RUNTIME_2
  47   , public RefdIndexInterface
  48 #endif
  49 {
  50   /** The value, if present (owned by OPTIONAL)
  51     * In Runtime2 the pointer is null, when the value is not present.
  52     * In Runtime1 its presence is indicated by the optional_selection member. */
  53   T_type *optional_value;
  54
  55   /** Specifies the state of the optional field
  56     * @tricky In Runtime2 the optional value can be modified through parameter references,
  57     * in which case this member variable will not be updated. Always use the function
  58     * get_selection() instead of directly referencing this variable. */
  59   optional_sel optional_selection;
  60
  61 #ifdef TITAN_RUNTIME_2
  62   /** Stores the number of elements referenced by 'out' and 'inout' parameters,
  63     * if the optional field is a record of/set of/array (only in Runtime2).
  64     * If at least one element is referenced, the value must not be deleted. */
  65   int param_refs;
  66 #endif
  67
  68   /** Set the optional value to present.
  69    * If the value was already present, does nothing.
  70    * Else allocates a new (uninitialized) T-type.
  71    * @post \c optional_selection is OPTIONAL_PRESENT
  72    * @post \c optional_value is not NULL
  73    */
  74 #ifdef TITAN_RUNTIME_2
  75 public:
  76   virtual
  77 #else
  78   inline
  79 #endif
  80   void set_to_present() {
  81     if (optional_selection != OPTIONAL_PRESENT) {
  82       optional_selection = OPTIONAL_PRESENT;
  83 #ifdef TITAN_RUNTIME_2
  84       if (optional_value == NULL)
  85 #endif
  86         optional_value = new T_type;
  87     }
  88   }
  89
  90   /** Set the optional value to omit.
  91    * If the value was present, frees it.
  92    * @post optional_selection is OPTIONAL_OMIT
  93    */
  94 #ifdef TITAN_RUNTIME_2
  95 public:
  96   virtual
  97 #else
  98   inline
  99 #endif
 100   void set_to_omit() {
 101 #ifdef TITAN_RUNTIME_2
 102     if (is_present()) {
 103       if (param_refs > 0) {
 104         optional_value->clean_up();
 105       }
 106       else {
 107         delete optional_value;
 108         optional_value = NULL;
 109       }
 110     }
 111 #else
 112     if (optional_selection == OPTIONAL_PRESENT) {
 113       delete optional_value;
 114     }
 115 #endif
 116     optional_selection = OPTIONAL_OMIT;
 117   }
 118
 119 public:
 120   /// Default constructor creates an unbound object
 121   OPTIONAL() : optional_value(NULL), optional_selection(OPTIONAL_UNBOUND)
 122 #ifdef TITAN_RUNTIME_2
 123   , param_refs(0)
 124 #endif
 125   { }
 126
 127   /// Construct an optional object set to omit.
 128   /// @p other_value must be OMIT_VALUE, or else dynamic testcase error.
 129   OPTIONAL(template_sel other_value);
 130
 131   /// Copy constructor.
 132   /// @note Copying an unbound object creates another unbound object,
 133   /// without causing a dynamic test case immediately.
 134   OPTIONAL(const OPTIONAL& other_value);
 135
 136   /// Construct from an optional of different type
 137   template <typename T_tmp>
 138   OPTIONAL(const OPTIONAL<T_tmp>& other_value);
 139
 140   /// Construct from an object of different type
 141   template <typename T_tmp>
 142   OPTIONAL(const T_tmp& other_value)
 143   : optional_value(new T_type(other_value))
 144   ,  optional_selection(OPTIONAL_PRESENT)
 145 #ifdef TITAN_RUNTIME_2
 146   ,  param_refs(0)
 147 #endif
 148   { }
 149
 150   ~OPTIONAL() {
 151 #ifdef TITAN_RUNTIME_2
 152     if (NULL != optional_value)
 153 #else
 154     if (optional_selection == OPTIONAL_PRESENT)
 155 #endif
 156       delete optional_value;
 157   }
 158
 159   void clean_up();
 160
 161   /// Set to omit.
 162   /// @p other_value must be OMIT_VALUE, or else dynamic testcase error.
 163   OPTIONAL& operator=(template_sel other_value);
 164
 165   /// Copy assignment
 166   OPTIONAL& operator=(const OPTIONAL& other_value);
 167
 168   /// Assign from an optional of another type
 169   template <typename T_tmp>
 170   OPTIONAL& operator=(const OPTIONAL<T_tmp>& other_value);
 171
 172   /// Assign the value
 173   template <typename T_tmp>
 174   OPTIONAL& operator=(const T_tmp& other_value);
 175
 176   boolean is_equal(template_sel other_value) const;
 177   boolean is_equal(const OPTIONAL& other_value) const;
 178   template <typename T_tmp>
 179   boolean is_equal(const OPTIONAL<T_tmp>& other_value) const;
 180   template <typename T_tmp>
 181   boolean is_equal(const T_tmp& other_value) const;
 182
 183   inline boolean operator==(template_sel other_value) const
 184     { return is_equal(other_value); }
 185   inline boolean operator!=(template_sel other_value) const
 186     { return !is_equal(other_value); }
 187   inline boolean operator==(const OPTIONAL& other_value) const
 188     { return is_equal(other_value); }
 189   inline boolean operator!=(const OPTIONAL& other_value) const
 190     { return !is_equal(other_value); }
 191   template <typename T_tmp>
 192   inline boolean operator==(const T_tmp& other_value) const
 193     { return is_equal(other_value); }
 194   template <typename T_tmp>
 195   inline boolean operator!=(const T_tmp& other_value) const
 196     { return !is_equal(other_value); }
 197 #if defined(__SUNPRO_CC) || defined(__clang__)
 198   /* Note: Without these functions the Sun Workshop Pro C++ compiler or clang reports
 199    * overloading ambiguity when comparing an optional charstring field with an
 200    * optional universal charstring. */
 201   template <typename T_tmp>
 202   inline boolean operator==(const OPTIONAL<T_tmp>& other_value) const
 203     { return is_equal(other_value); }
 204   template <typename T_tmp>
 205   inline boolean operator!=(const OPTIONAL<T_tmp>& other_value) const
 206     { return is_equal(other_value); }
 207 #endif
 208
 209 #ifdef TITAN_RUNTIME_2
 210   boolean is_bound() const;
 211 #else
 212   inline boolean is_bound() const { return optional_selection != OPTIONAL_UNBOUND; }
 213 #endif
 214   boolean is_value() const
 215    { return optional_selection == OPTIONAL_PRESENT && optional_value->is_value(); }
 216   /** Whether the optional value is present.
 217    * @return \c true if optional_selection is OPTIONAL_PRESENT, else \c false */
 218 #ifdef TITAN_RUNTIME_2
 219   boolean is_present() const;
 220 #else
 221   inline boolean is_present() const { return optional_selection==OPTIONAL_PRESENT; }
 222 #endif
 223
 224 #ifdef TITAN_RUNTIME_2
 225   /** @name override virtual functions of Base_Type
 226    * @{ */
 227
 228   /** Return \c true (this \b is an optional field) */
 229   boolean is_optional() const { return TRUE; }
 230
 231   /** Access the value for read/write
 232    *
 233    * @return a pointer to the (modifiable) value
 234    * @pre \p optional_selection must be \p OPTIONAL_PRESENT
 235    */
 236   Base_Type* get_opt_value();
 237
 238   /** Access the value (read/only)
 239    *
 240    * @return a pointer to the (const) value
 241    * @pre \p optional_selection must be \p OPTIONAL_PRESENT
 242    */
 243   const Base_Type* get_opt_value() const;
 244   boolean is_seof() const;
 245   boolean is_equal(const Base_Type* other_value) const { return is_equal(*(static_cast<const OPTIONAL*>(other_value))); }
 246   void set_value(const Base_Type* other_value) { *this = *(static_cast<const OPTIONAL*>(other_value)); }
 247   Base_Type* clone() const { return new OPTIONAL(*this); }
 248   const TTCN_Typedescriptor_t* get_descriptor() const;
 249   /** @} */
 250 #endif
 251
 252   /** Whether the value is present.
 253    * Note: this is not the TTCN-3 ispresent(), kept for backward compatibility
 254    *       with the runtime and existing testports which use this version where
 255    *       unbound errors are caught before causing more trouble
 256    *
 257    *  @return TRUE  if the value is present (optional_selection==OPTIONAL_PRESENT)
 258    *  @return FALSE if the value is not present (optional_selection==OPTIONAL_OMIT)
 259    *  @pre the value is bound (optional_selection!=OPTIONAL_UNBOUND)
 260    */
 261   boolean ispresent() const;
 262
 263 #ifdef TITAN_RUNTIME_2
 264   /** @tricky Calculates and returns the actual state of the optional object,
 265     * not just the optional_selection member.
 266     * (Only needed in Runtime2, in Runtime1 optional_selection is always up to date.) */
 267   optional_sel get_selection() const;
 268 #else
 269   inline optional_sel get_selection() const { return optional_selection; }
 270 #endif
 271
 272   void log() const;
 273   void set_param(Module_Param& param);
 274   Module_Param* get_param(Module_Param_Name& param_name) const;
 275   void encode_text(Text_Buf& text_buf) const;
 276   void decode_text(Text_Buf& text_buf);
 277
 278 #ifdef TITAN_RUNTIME_2
 279   virtual int RAW_decode(const TTCN_Typedescriptor_t& td, TTCN_Buffer& buf, int limit,
 280     raw_order_t top_bit_ord, boolean no_err=FALSE, int sel_field=-1, boolean first_call=TRUE);
 281 #endif
 282
 283   int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& buf, unsigned int flavor,
 284     int indent, embed_values_enc_struct_t* emb_val) const;
 285 #ifdef TITAN_RUNTIME_2
 286   int XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
 287     const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor,
 288     int indent, embed_values_enc_struct_t* emb_val) const;
 289 #endif
 290   /** Used during XML decoding, in case this object is an AnyElement field in a record.
 291     * Determines whether XER_decode() should be called or this field should be omitted.
 292     * The field should be omitted if:
 293     *  - the next element in the encoded XML is the next field in the record or
 294     *  - there are no more elements until the end of the record's XML element.
 295     *
 296     * @param reader parses the encoded XML
 297     * @param next_field_name name of the next field in the record, or null if this is the last one
 298     * @param parent_tag_closed true, if the record's XML tag is closed (is an empty element)*/
 299   bool XER_check_any_elem(XmlReaderWrap& reader, const char* next_field_name, bool parent_tag_closed);
 300   int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader,
 301     unsigned int flavor, unsigned int flavor2, embed_values_dec_struct_t* emb_val);
 302
 303   char ** collect_ns(const XERdescriptor_t& p_td, size_t& num, bool& def_ns) const;
 304
 305   operator T_type&();
 306   operator const T_type&() const;
 307
 308   inline T_type& operator()() { return (T_type&)*this; }
 309   inline const T_type& operator()() const { return (const T_type&)*this; }
 310
 311   ASN_BER_TLV_t* BER_encode_TLV(const TTCN_Typedescriptor_t& p_td,
 312                                 unsigned p_coding) const;
 313 #ifdef TITAN_RUNTIME_2
 314   ASN_BER_TLV_t* BER_encode_TLV_negtest(const Erroneous_descriptor_t* p_err_descr,
 315     const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const;
 316 #endif
 317   boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td,
 318                          const ASN_BER_TLV_t& p_tlv, unsigned L_form);
 319   boolean BER_decode_isMyMsg(const TTCN_Typedescriptor_t& p_td,
 320                              const ASN_BER_TLV_t& p_tlv);
 321   void BER_decode_opentypes(TTCN_Type_list& p_typelist, unsigned L_form);
 322
 323 #ifdef TITAN_RUNTIME_2
 324   int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const;
 325   int TEXT_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
 326     const TTCN_Typedescriptor_t&, TTCN_Buffer&) const;
 327   int TEXT_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, Limit_Token_List&,
 328                   boolean no_err=FALSE, boolean first_call=TRUE);
 329   int JSON_encode_negtest(const Erroneous_descriptor_t*,
 330                           const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const;
 331 #endif
 332
 333   /** Encodes accordingly to the JSON encoding rules.
 334     * Returns the length of the encoded data. */
 335   int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const;
 336
 337   /** Decodes accordingly to the JSON encoding rules.
 338     * Returns the length of the decoded data. */
 339   int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean);
 340
 341 #ifdef TITAN_RUNTIME_2
 342   /** Called before an element of an optional record of/set of is indexed and passed as an
 343     * 'inout' or 'out' parameter to a function (only in Runtime2).
 344     * Sets the optional value to present (this would be done by the indexing operation
 345     * anyway) and redirects the call to the optional value. */
 346   virtual void add_refd_index(int index);
 347
 348   /** Called after an element of an optional record of/set of is passed as an
 349     * 'inout' or 'out' parameter to a function (only in Runtime2).
 350     * Redirects the call to the optional value. */
 351   virtual void remove_refd_index(int index);
 352 #endif
 353 };
 354
 355 #if HAVE_GCC(4,6)
 356 #pragma GCC diagnostic push
 357 #pragma GCC diagnostic ignored "-Wswitch-enum"
 358 #endif
 359
 360 #ifdef TITAN_RUNTIME_2
 361
 362 template<typename T_type>
 363 Base_Type* OPTIONAL<T_type>::get_opt_value()
 364 {
 365 #ifdef TITAN_RUNTIME_2
 366   if (!is_present())
 367 #else
 368   if (optional_selection!=OPTIONAL_PRESENT)
 369 #endif
 370     TTCN_error("Internal error: get_opt_value() called on a non-present optional field.");
 371   return optional_value;
 372 }
 373
 374 template<typename T_type>
 375 const Base_Type* OPTIONAL<T_type>::get_opt_value() const
 376 {
 377 #ifdef TITAN_RUNTIME_2
 378   if (!is_present())
 379 #else
 380   if (optional_selection!=OPTIONAL_PRESENT)
 381 #endif
 382     TTCN_error("Internal error: get_opt_value() const called on a non-present optional field.");
 383   return optional_value;
 384 }
 385
 386 template<typename T_type>
 387 boolean OPTIONAL<T_type>::is_seof() const
 388 {
 389   return
 390 #ifdef TITAN_RUNTIME_2
 391   (is_present())
 392 #else
 393   (optional_selection==OPTIONAL_PRESENT)
 394 #endif
 395   ? optional_value->is_seof() : T_type().is_seof();
 396 }
 397
 398 template<typename T_type>
 399 const TTCN_Typedescriptor_t* OPTIONAL<T_type>::get_descriptor() const
 400 {
 401   return
 402 #ifdef TITAN_RUNTIME_2
 403   (is_present())
 404 #else
 405   (optional_selection==OPTIONAL_PRESENT)
 406 #endif
 407   ? optional_value->get_descriptor() : T_type().get_descriptor();
 408 }
 409
 410 #endif
 411
 412 template<typename T_type>
 413 OPTIONAL<T_type>::OPTIONAL(template_sel other_value)
 414   : optional_value(NULL), optional_selection(OPTIONAL_OMIT)
 415 #ifdef TITAN_RUNTIME_2
 416   , param_refs(0)
 417 #endif
 418 {
 419   if (other_value != OMIT_VALUE)
 420     TTCN_error("Setting an optional field to an invalid value.");
 421 }
 422
 423 template<typename T_type>
 424 OPTIONAL<T_type>::OPTIONAL(const OPTIONAL& other_value)
 425   : Base_Type(other_value)
 426 #ifdef TITAN_RUNTIME_2
 427   , RefdIndexInterface(other_value)
 428 #endif
 429   , optional_value(NULL)
 430   , optional_selection(other_value.optional_selection)
 431 #ifdef TITAN_RUNTIME_2
 432   , param_refs(0)
 433 #endif
 434 {
 435   switch (other_value.optional_selection) {
 436   case OPTIONAL_PRESENT:
 437     optional_value = new T_type(*other_value.optional_value);
 438     break;
 439   case OPTIONAL_OMIT:
 440     break;
 441   default:
 442     break;
 443   }
 444 }
 445
 446 template<typename T_type> template<typename T_tmp>
 447 OPTIONAL<T_type>::OPTIONAL(const OPTIONAL<T_tmp>& other_value)
 448   : optional_value(NULL), optional_selection(other_value.get_selection())
 449 #ifdef TITAN_RUNTIME_2
 450   , param_refs(0)
 451 #endif
 452 {
 453   switch (other_value.get_selection()) {
 454   case OPTIONAL_PRESENT:
 455     optional_value = new T_type((const T_tmp&)other_value);
 456     break;
 457   case OPTIONAL_OMIT:
 458     break;
 459   default:
 460     break;
 461   }
 462 }
 463
 464 template<typename T_type>
 465 void OPTIONAL<T_type>::clean_up()
 466 {
 467 #ifdef TITAN_RUNTIME_2
 468   if (is_present()) {
 469     if (param_refs > 0) {
 470       optional_value->clean_up();
 471     }
 472     else {
 473       delete optional_value;
 474       optional_value = NULL;
 475     }
 476   }
 477 #else
 478   if (OPTIONAL_PRESENT == optional_selection) {
 479     delete optional_value;
 480   }
 481 #endif
 482   optional_selection = OPTIONAL_UNBOUND;
 483 }
 484
 485 template<typename T_type>
 486 OPTIONAL<T_type>& OPTIONAL<T_type>::operator=(template_sel other_value)
 487 {
 488   if (other_value != OMIT_VALUE)
 489     TTCN_error("Internal error: Setting an optional field to an invalid value.");
 490   set_to_omit();
 491   return *this;
 492 }
 493
 494 template<typename T_type>
 495 OPTIONAL<T_type>& OPTIONAL<T_type>::operator=(const OPTIONAL& other_value)
 496 {
 497   switch (other_value.optional_selection) {
 498   case OPTIONAL_PRESENT:
 499 #ifdef TITAN_RUNTIME_2
 500     if (NULL == optional_value) {
 501 #else
 502     if (optional_selection != OPTIONAL_PRESENT) {
 503 #endif
 504       optional_value = new T_type(*other_value.optional_value);
 505       optional_selection = OPTIONAL_PRESENT;
 506     } else *optional_value = *other_value.optional_value;
 507     break;
 508   case OPTIONAL_OMIT:
 509     if (&other_value != this) set_to_omit();
 510     break;
 511   default:
 512     clean_up();
 513     break;
 514   }
 515   return *this;
 516 }
 517
 518 template<typename T_type> template <typename T_tmp>
 519 OPTIONAL<T_type>&
 520 OPTIONAL<T_type>::operator=(const OPTIONAL<T_tmp>& other_value)
 521 {
 522   switch (other_value.get_selection()) {
 523   case OPTIONAL_PRESENT:
 524 #ifdef TITAN_RUNTIME_2
 525     if (NULL == optional_value) {
 526 #else
 527     if (optional_selection != OPTIONAL_PRESENT) {
 528 #endif
 529       optional_value = new T_type((const T_tmp&)other_value);
 530       optional_selection = OPTIONAL_PRESENT;
 531     } else *optional_value = (const T_tmp&)other_value;
 532     break;
 533   case OPTIONAL_OMIT:
 534     set_to_omit();
 535     break;
 536   default:
 537     clean_up();
 538     break;
 539   }
 540   return *this;
 541 }
 542
 543 template<typename T_type> template <typename T_tmp>
 544 OPTIONAL<T_type>&
 545 OPTIONAL<T_type>::operator=(const T_tmp& other_value)
 546 {
 547 #ifdef TITAN_RUNTIME_2
 548   if (NULL == optional_value) {
 549 #else
 550   if (optional_selection != OPTIONAL_PRESENT) {
 551 #endif
 552     optional_value = new T_type(other_value);
 553     optional_selection = OPTIONAL_PRESENT;
 554   } else *optional_value = other_value;
 555   return *this;
 556 }
 557
 558 template<typename T_type>
 559 boolean OPTIONAL<T_type>::is_equal(template_sel other_value) const
 560 {
 561 #ifdef TITAN_RUNTIME_2
 562   if (!is_bound()) {
 563 #else
 564   if (optional_selection == OPTIONAL_UNBOUND) {
 565 #endif
 566     if (other_value == UNINITIALIZED_TEMPLATE) return TRUE;
 567     TTCN_error("The left operand of comparison is an unbound optional value.");
 568   }
 569   if (other_value != OMIT_VALUE) TTCN_error("Internal error: The right operand "
 570     "of comparison is an invalid value.");
 571   return
 572 #ifdef TITAN_RUNTIME_2
 573   !is_present();
 574 #else
 575   optional_selection == OPTIONAL_OMIT;
 576 #endif
 577 }
 578
 579 template<typename T_type>
 580 boolean OPTIONAL<T_type>::is_equal(const OPTIONAL& other_value) const
 581 {
 582 #ifdef TITAN_RUNTIME_2
 583   if (!is_bound()) {
 584     if (!other_value.is_bound())
 585 #else
 586   if (optional_selection == OPTIONAL_UNBOUND) {
 587     if (other_value.optional_selection == OPTIONAL_UNBOUND)
 588 #endif
 589       return TRUE;
 590     TTCN_error("The left operand of "
 591     "comparison is an unbound optional value.");
 592   }
 593 #ifdef TITAN_RUNTIME_2
 594   if (!other_value.is_bound())
 595 #else
 596   if (other_value.optional_selection == OPTIONAL_UNBOUND)
 597 #endif
 598     TTCN_error("The right operand of comparison is an unbound optional value.");
 599 #ifdef TITAN_RUNTIME_2
 600   boolean present = is_present();
 601   if (present != other_value.is_present()) return FALSE;
 602   else if (present)
 603 #else
 604   if (optional_selection != other_value.optional_selection) return FALSE;
 605   else if (optional_selection == OPTIONAL_PRESENT)
 606 #endif
 607     return *optional_value == *other_value.optional_value;
 608   else return TRUE;
 609 }
 610
 611 template<typename T_type> template <typename T_tmp>
 612 boolean OPTIONAL<T_type>::is_equal(const T_tmp& other_value) const
 613 {
 614 #ifdef TITAN_RUNTIME_2
 615   switch (get_selection()) {
 616 #else
 617   switch (optional_selection) {
 618 #endif
 619   case OPTIONAL_PRESENT:
 620     return *optional_value == other_value;
 621   case OPTIONAL_OMIT:
 622     return FALSE;
 623   default:
 624     TTCN_error("The left operand of comparison is an unbound optional value.");
 625   }
 626   return FALSE;
 627 }
 628
 629 template<typename T_type> template <typename T_tmp>
 630 boolean OPTIONAL<T_type>::is_equal(const OPTIONAL<T_tmp>& other_value) const
 631 {
 632 #ifdef TITAN_RUNTIME_2
 633   if (!is_bound()) {
 634     if (!other_value.is_bound())
 635 #else
 636   optional_sel other_selection = other_value.get_selection();
 637   if (optional_selection == OPTIONAL_UNBOUND) {
 638     if (other_selection == OPTIONAL_UNBOUND)
 639 #endif
 640       return TRUE;
 641     TTCN_error("The left operand of "
 642     "comparison is an unbound optional value.");
 643   }
 644 #ifdef TITAN_RUNTIME_2
 645   if (!other_value.is_bound())
 646 #else
 647   if (other_selection == OPTIONAL_UNBOUND)
 648 #endif
 649     TTCN_error("The right operand of comparison is an unbound optional value.");
 650 #ifdef TITAN_RUNTIME_2
 651   boolean present = is_present();
 652   if (present != other_value.is_present()) return FALSE;
 653   else if (present)
 654 #else
 655   if (optional_selection != other_selection) return FALSE;
 656   else if (optional_selection == OPTIONAL_PRESENT)
 657 #endif
 658     return *optional_value == (const T_tmp&)other_value;
 659   else return TRUE;
 660 }
 661
 662 #ifdef TITAN_RUNTIME_2
 663 template<typename T_type>
 664 boolean OPTIONAL<T_type>::is_bound() const
 665 {
 666   switch (optional_selection) {
 667   case OPTIONAL_PRESENT:
 668   case OPTIONAL_OMIT:
 669     return TRUE;
 670   default:
 671     if (NULL != optional_value) {
 672       return optional_value->is_bound();
 673     }
 674     return FALSE;
 675   }
 676 }
 677
 678 template<typename T_type>
 679 boolean OPTIONAL<T_type>::is_present() const
 680 {
 681   switch (optional_selection) {
 682   case OPTIONAL_PRESENT:
 683     return TRUE;
 684   case OPTIONAL_OMIT:
 685   default:
 686     if (NULL != optional_value) {
 687       return optional_value->is_bound();
 688     }
 689     return FALSE;
 690   }
 691 }
 692 #endif
 693
 694 template<typename T_type>
 695 boolean OPTIONAL<T_type>::ispresent() const
 696 {
 697   switch (optional_selection) {
 698   case OPTIONAL_PRESENT:
 699     return TRUE;
 700   case OPTIONAL_OMIT:
 701 #ifdef TITAN_RUNTIME_2
 702     if (NULL != optional_value) {
 703       return optional_value->is_bound();
 704     }
 705 #endif
 706     return FALSE;
 707   default:
 708 #ifdef TITAN_RUNTIME_2
 709     if (NULL != optional_value && optional_value->is_bound()) {
 710       return TRUE;
 711     }
 712 #endif
 713     TTCN_error("Using an unbound optional field.");
 714   }
 715   return FALSE;
 716 }
 717
 718 #ifdef TITAN_RUNTIME_2
 719 template<typename T_type>
 720 optional_sel OPTIONAL<T_type>::get_selection() const
 721 {
 722   if (is_present()) {
 723     return OPTIONAL_PRESENT;
 724   }
 725   if (is_bound()) {
 726     // not present, but bound => omit
 727     return OPTIONAL_OMIT;
 728   }
 729   return OPTIONAL_UNBOUND;
 730 }
 731 #endif
 732
 733 template<typename T_type>
 734 void OPTIONAL<T_type>::log() const
 735 {
 736 #ifdef TITAN_RUNTIME_2
 737   switch (get_selection()) {
 738 #else
 739   switch (optional_selection) {
 740 #endif
 741   case OPTIONAL_PRESENT:
 742     optional_value->log();
 743     break;
 744   case OPTIONAL_OMIT:
 745     TTCN_Logger::log_event_str("omit");
 746     break;
 747   default:
 748     TTCN_Logger::log_event_unbound();
 749     break;
 750   }
 751 }
 752
 753 template <typename T_type>
 754 void OPTIONAL<T_type>::set_param(Module_Param& param) {
 755   if (param.get_type()==Module_Param::MP_Omit) {
 756     if (param.get_ifpresent()) param.error("An optional field of a record value cannot have an 'ifpresent' attribute");
 757     if (param.get_length_restriction()!=NULL) param.error("An optional field of a record value cannot have a length restriction");
 758     set_to_omit();
 759     return;
 760   }
 761   set_to_present();
 762   optional_value->set_param(param);
 763   if (!optional_value->is_bound()) {
 764     clean_up();
 765   }
 766 }
 767
 768 template <typename T_type>
 769 Module_Param* OPTIONAL<T_type>::get_param(Module_Param_Name& param_name) const
 770 {
 771 #ifdef TITAN_RUNTIME_2
 772   switch (get_selection()) {
 773 #else
 774   switch (optional_selection) {
 775 #endif
 776   case OPTIONAL_PRESENT:
 777     return optional_value->get_param(param_name);
 778   case OPTIONAL_OMIT:
 779     return new Module_Param_Omit();
 780   default:
 781     return new Module_Param_Unbound();
 782   }
 783 }
 784
 785 template<typename T_type>
 786 void OPTIONAL<T_type>::encode_text(Text_Buf& text_buf) const
 787 {
 788 #ifdef TITAN_RUNTIME_2
 789   switch (get_selection()) {
 790 #else
 791   switch (optional_selection) {
 792 #endif
 793   case OPTIONAL_OMIT:
 794     text_buf.push_int((RInt)FALSE);
 795     break;
 796   case OPTIONAL_PRESENT:
 797     text_buf.push_int((RInt)TRUE);
 798     optional_value->encode_text(text_buf);
 799     break;
 800   default:
 801     TTCN_error("Text encoder: Encoding an unbound optional value.");
 802   }
 803 }
 804
 805 template<typename T_type>
 806 void OPTIONAL<T_type>::decode_text(Text_Buf& text_buf)
 807 {
 808   if (text_buf.pull_int().get_val()) {
 809     set_to_present();
 810     optional_value->decode_text(text_buf);
 811   } else set_to_omit();
 812 }
 813
 814 template<typename T_type>
 815 int OPTIONAL<T_type>::JSON_encode(const TTCN_Typedescriptor_t& p_td, JSON_Tokenizer& p_tok) const
 816 {
 817 #ifdef TITAN_RUNTIME_2
 818   switch(get_selection()) {
 819 #else
 820   switch(optional_selection) {
 821 #endif
 822   case OPTIONAL_PRESENT:
 823     return optional_value->JSON_encode(p_td, p_tok);
 824   case OPTIONAL_OMIT:
 825     return p_tok.put_next_token(JSON_TOKEN_LITERAL_NULL, NULL);
 826   default:
 827     TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND,
 828       "Encoding an unbound optional value.");
 829     return -1;
 830   }
 831 }
 832
 833 #ifdef TITAN_RUNTIME_2
 834 template<typename T_type>
 835 int OPTIONAL<T_type>::JSON_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
 836                                         const TTCN_Typedescriptor_t& p_td,
 837                                         JSON_Tokenizer& p_tok) const
 838 {
 839   switch (get_selection()) {
 840   case OPTIONAL_PRESENT:
 841     return optional_value->JSON_encode_negtest(p_err_descr, p_td, p_tok);
 842   case OPTIONAL_OMIT:
 843     return p_tok.put_next_token(JSON_TOKEN_LITERAL_NULL, NULL);
 844   default:
 845     TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND,
 846       "Encoding an unbound optional value.");
 847     return -1;
 848   }
 849 }
 850 #endif
 851
 852 template<typename T_type>
 853 int OPTIONAL<T_type>::JSON_decode(const TTCN_Typedescriptor_t& p_td, JSON_Tokenizer& p_tok, boolean p_silent)
 854 {
 855   // try the optional value first
 856   set_to_present();
 857   size_t buf_pos = p_tok.get_buf_pos();
 858   int dec_len = optional_value->JSON_decode(p_td, p_tok, p_silent);
 859   if (JSON_ERROR_FATAL == dec_len) {
 860     if (p_silent) {
 861       clean_up();
 862     } else {
 863       set_to_omit();
 864     }
 865   }
 866   else if (JSON_ERROR_INVALID_TOKEN == dec_len) {
 867     // invalid token, rewind the buffer and check if it's a "null" (= omit)
 868     // this needs to be checked after the optional value, because it might also be
 869     // able to decode a "null" value
 870     p_tok.set_buf_pos(buf_pos);
 871     json_token_t token = JSON_TOKEN_NONE;
 872     dec_len = p_tok.get_next_token(&token, NULL, NULL);
 873     if (JSON_TOKEN_LITERAL_NULL == token) {
 874       set_to_omit();
 875     }
 876     else {
 877       // cannot get JSON_TOKEN_ERROR here, that was already checked by the optional value
 878       dec_len = JSON_ERROR_INVALID_TOKEN;
 879     }
 880   }
 881   return dec_len;
 882 }
 883
 884 #ifdef TITAN_RUNTIME_2
 885 template<typename T_type>
 886 void OPTIONAL<T_type>::add_refd_index(int index)
 887 {
 888   ++param_refs;
 889   set_to_present();
 890   RefdIndexInterface* refd_opt_val = dynamic_cast<RefdIndexInterface*>(optional_value);
 891   if (0 != refd_opt_val) {
 892     refd_opt_val->add_refd_index(index);
 893   }
 894 }
 895
 896 template<typename T_type>
 897 void OPTIONAL<T_type>::remove_refd_index(int index)
 898 {
 899   --param_refs;
 900   RefdIndexInterface* refd_opt_val = dynamic_cast<RefdIndexInterface*>(optional_value);
 901   if (0 != refd_opt_val) {
 902     refd_opt_val->remove_refd_index(index);
 903   }
 904 }
 905 #endif
 906
 907 template<typename T_type>
 908 OPTIONAL<T_type>::operator T_type&()
 909 {
 910   set_to_present();
 911   return *optional_value;
 912 }
 913
 914 template<typename T_type>
 915 OPTIONAL<T_type>::operator const T_type&() const
 916 {
 917 #ifdef TITAN_RUNTIME_2
 918   if (!is_present())
 919 #else
 920   if (optional_selection != OPTIONAL_PRESENT)
 921 #endif
 922     TTCN_error("Using the value of an optional field containing omit.");
 923   return *optional_value;
 924 }
 925
 926 template<typename T_type>
 927 ASN_BER_TLV_t*
 928 OPTIONAL<T_type>::BER_encode_TLV(const TTCN_Typedescriptor_t& p_td,
 929                                  unsigned p_coding) const
 930 {
 931   BER_chk_descr(p_td);
 932 #ifdef TITAN_RUNTIME_2
 933   switch (get_selection()) {
 934 #else
 935   switch (optional_selection) {
 936 #endif
 937   case OPTIONAL_PRESENT:
 938     return optional_value->BER_encode_TLV(p_td, p_coding);
 939   case OPTIONAL_OMIT:
 940     return ASN_BER_TLV_t::construct();
 941   default:
 942     return ASN_BER_V2TLV(BER_encode_chk_bound(FALSE), p_td, p_coding);
 943   }
 944 }
 945
 946 #ifdef TITAN_RUNTIME_2
 947 template<typename T_type>
 948 ASN_BER_TLV_t*
 949 OPTIONAL<T_type>::BER_encode_TLV_negtest(const Erroneous_descriptor_t* p_err_descr,
 950     const TTCN_Typedescriptor_t& p_td, unsigned p_coding) const
 951 {
 952   BER_chk_descr(p_td);
 953 #ifdef TITAN_RUNTIME_2
 954   switch (get_selection()) {
 955 #else
 956   switch (optional_selection) {
 957 #endif
 958   case OPTIONAL_PRESENT:
 959     return optional_value->BER_encode_TLV_negtest(p_err_descr, p_td, p_coding);
 960   case OPTIONAL_OMIT:
 961     return ASN_BER_TLV_t::construct();
 962   default:
 963     return ASN_BER_V2TLV(BER_encode_chk_bound(FALSE), p_td, p_coding);
 964   }
 965 }
 966
 967 template<typename T_type>
 968 int OPTIONAL<T_type>::RAW_decode(const TTCN_Typedescriptor_t& p_td,
 969   TTCN_Buffer&, int /* limit */, raw_order_t /* top_bit_ord */,
 970   boolean /* no_error */, int /* sel_field */, boolean /* first_call */ )
 971 {
 972   TTCN_error("RAW decoding requested for optional type '%s'"
 973              " which has no RAW decoding method.",p_td.name);
 974   return 0;
 975 }
 976 #endif
 977
 978 template<typename T_type>
 979 int
 980 OPTIONAL<T_type>::XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& buf, unsigned int flavor, int indent, embed_values_enc_struct_t* emb_val) const
 981 {
 982 #ifdef TITAN_RUNTIME_2
 983   switch (get_selection()) {
 984 #else
 985   switch (optional_selection) {
 986 #endif
 987   case OPTIONAL_PRESENT:
 988     return optional_value->XER_encode(p_td, buf, flavor, indent, emb_val);
 989   case OPTIONAL_OMIT:
 990     return 0; // nothing to do !
 991   default:
 992     TTCN_EncDec_ErrorContext::error(
 993       TTCN_EncDec::ET_UNBOUND, "Encoding an unbound optional value.");
 994     return 0;
 995   }
 996 }
 997
 998 #ifdef TITAN_RUNTIME_2
 999 template<typename T_type>
1000 int
1001 OPTIONAL<T_type>::XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
1002   const XERdescriptor_t& p_td, TTCN_Buffer& buf, unsigned int flavor, int indent,
1003   embed_values_enc_struct_t* emb_val) const
1004 {
1005   switch (get_selection()) {
1006   case OPTIONAL_PRESENT:
1007     return optional_value->XER_encode_negtest(p_err_descr, p_td, buf, flavor, indent, emb_val);
1008   case OPTIONAL_OMIT:
1009     return 0; // nothing to do !
1010   default:
1011     TTCN_EncDec_ErrorContext::error(
1012       TTCN_EncDec::ET_UNBOUND, "Encoding an unbound optional value.");
1013     return 0;
1014   }
1015 }
1016 #endif
1017
1018
1019 template<typename T_type>
1020 bool
1021 OPTIONAL<T_type>::XER_check_any_elem(XmlReaderWrap& reader, const char* next_field_name, bool parent_tag_closed)
1022 {
1023   // If the record has no elements, then it can't have an AnyElement
1024   if (parent_tag_closed) {
1025     set_to_omit();
1026     return false;
1027   }
1028
1029   while (reader.Ok()) {
1030     // Leaving the record before finding an element -> no AnyElement
1031     if (XML_READER_TYPE_END_ELEMENT == reader.NodeType()) {
1032       set_to_omit();
1033       return false;
1034     }
1035     if (XML_READER_TYPE_ELEMENT == reader.NodeType()) {
1036       // The first element found is either the next field's element or the AnyElement
1037       if (NULL != next_field_name &&
1038           0 == strcmp((const char*)reader.LocalName(), next_field_name)) {
1039         set_to_omit();
1040         return false;
1041       }
1042       break;
1043     }
1044     reader.Read();
1045   }
1046
1047   return true;
1048 }
1049
1050 template<typename T_type>
1051 int
1052 OPTIONAL<T_type>::XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader,
1053   unsigned int flavor, unsigned int flavor2, embed_values_dec_struct_t* emb_val)
1054 {
1055   int exer  = is_exer(flavor);
1056   for (int success = reader.Ok(); success==1; success=reader.Read()) {
1057     int type = reader.NodeType();
1058     const char * name; // name of the optional field
1059     const char * ns_uri;
1060
1061     if (exer && (p_td.xer_bits & XER_ATTRIBUTE)) {
1062       if (XML_READER_TYPE_ATTRIBUTE == type) {
1063         for (; success==1; success = reader.MoveToNextAttribute()) {
1064           if (!reader.IsNamespaceDecl()) break;
1065         }
1066
1067         name = (const char*)reader.LocalName();
1068         if (!check_name(name, p_td, exer)) { // it's not us, bail
1069           break;
1070         }
1071         // we already checked for exer==1
1072         if (!check_namespace((const char*)reader.NamespaceUri(), p_td)) break;
1073
1074         // set to omit if the attribute is empty
1075         const char * value = (const char *)reader.Value();
1076         if (strlen(value) == 0) {
1077           break;
1078         }
1079
1080         set_to_present();
1081         optional_value->XER_decode(p_td, reader, flavor, flavor2, emb_val);
1082         goto finished;
1083       }
1084       else break;
1085     }
1086     else if(XML_READER_TYPE_ATTRIBUTE == type && (flavor & USE_NIL)){
1087         goto found_it;
1088     }
1089     else { // not attribute
1090       if (XML_READER_TYPE_ELEMENT == type) { // we are at an element
1091         name   = (const char*)reader.LocalName();
1092         ns_uri = (const char*)reader.NamespaceUri();
1093         if ((p_td.xer_bits & ANY_ELEMENT) || (exer && (flavor & USE_NIL))
1094             || ( (p_td.xer_bits & UNTAGGED) && !reader.IsEmptyElement())
1095           // If the optional field (a string) has anyElement, accept the element
1096           // regardless of its name. Else the name (and namespace) must match.
1097           || T_type::can_start(name, ns_uri, p_td, flavor)) { // it is us
1098           found_it:
1099           set_to_present();
1100           //success = reader.Read(); // move to next thing TODO should it loop till an element ?
1101           optional_value->XER_decode(p_td, reader, flavor, flavor2, emb_val);
1102           if (!optional_value->is_bound()) {
1103             set_to_omit();
1104           }
1105         }
1106         else break; // it's not us, bail
1107
1108         goto finished;
1109       }
1110       else if (XML_READER_TYPE_TEXT == type && (flavor & USE_NIL)) {
1111         goto found_it;
1112       }
1113       else if (XML_READER_TYPE_END_ELEMENT == type) {
1114         break;
1115       }
1116       // else circle around
1117     } // if attribute
1118   } // next
1119   set_to_omit();
1120   return 0;
1121 finished:
1122   return 1;
1123 }
1124
1125 template<typename T_type>
1126 char ** OPTIONAL<T_type>::collect_ns(const XERdescriptor_t& p_td, size_t& num, bool& def_ns) const {
1127 #ifdef TITAN_RUNTIME_2
1128   switch (get_selection()) {
1129 #else
1130   switch (optional_selection) {
1131 #endif
1132   case OPTIONAL_PRESENT:
1133     return optional_value->collect_ns(p_td, num, def_ns);
1134   case OPTIONAL_OMIT:
1135     def_ns = false;
1136     num = 0;
1137     return 0;
1138   default:
1139     TTCN_EncDec_ErrorContext::error(
1140       TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value.");
1141     return 0;
1142   }
1143 }
1144
1145 template<typename T_type>
1146 boolean OPTIONAL<T_type>::BER_decode_TLV(const TTCN_Typedescriptor_t& p_td,
1147                                          const ASN_BER_TLV_t& p_tlv,
1148                                          unsigned L_form)
1149 {
1150   BER_chk_descr(p_td);
1151   if (BER_decode_isMyMsg(p_td, p_tlv)) {
1152     return optional_value->BER_decode_TLV(p_td, p_tlv, L_form);
1153   } else {
1154     set_to_omit();
1155     return TRUE;
1156   }
1157 }
1158
1159 template<typename T_type>
1160 boolean OPTIONAL<T_type>::BER_decode_isMyMsg(const TTCN_Typedescriptor_t& p_td,
1161   const ASN_BER_TLV_t& p_tlv)
1162 {
1163   set_to_present();
1164   return optional_value->BER_decode_isMyMsg(p_td, p_tlv);
1165 }
1166
1167 template<typename T_type>
1168 void OPTIONAL<T_type>::BER_decode_opentypes(TTCN_Type_list& p_typelist,
1169   unsigned L_form)
1170 {
1171 #ifdef TITAN_RUNTIME_2
1172   if (is_present()) {
1173     optional_selection = OPTIONAL_PRESENT;
1174 #else
1175   if (optional_selection==OPTIONAL_PRESENT) {
1176 #endif
1177     optional_value->BER_decode_opentypes(p_typelist, L_form);
1178   }
1179 }
1180
1181 #ifdef TITAN_RUNTIME_2
1182
1183 template<typename T_type>
1184 int OPTIONAL<T_type>::TEXT_encode(const TTCN_Typedescriptor_t& p_td,
1185                            TTCN_Buffer& buff) const
1186 {
1187   if (is_present())
1188     return optional_value->TEXT_encode(p_td, buff);
1189   TTCN_error("Internal error: TEXT encoding an unbound/omit optional field.");
1190   return 0;
1191 }
1192
1193 template<typename T_type>
1194 int OPTIONAL<T_type>::TEXT_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
1195   const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& buff) const
1196 {
1197   if (is_present())
1198     return optional_value->TEXT_encode_negtest(p_err_descr, p_td, buff);
1199   TTCN_error("Internal error: TEXT encoding an unbound/omit optional field.");
1200   return 0;
1201 }
1202
1203 template<typename T_type>
1204 int OPTIONAL<T_type>::TEXT_decode(const TTCN_Typedescriptor_t& p_td,
1205   TTCN_Buffer& buff, Limit_Token_List& limit, boolean no_err, boolean first_call)
1206 {
1207   set_to_present();
1208   return optional_value->TEXT_decode(p_td, buff, limit, no_err, first_call);
1209 }
1210
1211 #endif
1212
1213 #if defined(__GNUC__) && __GNUC__ >= 3
1214 /** Note: These functions allow most efficient operation by passing the left
1215  * operand OMIT_VALUE as value instead of constant reference.
1216  * However, with GCC 2.95.x the functions cause overloading ambiguities. */
1217 template<typename T_type>
1218 inline boolean operator==(template_sel left_value,
1219   const OPTIONAL<T_type>& right_value)
1220   { return right_value.is_equal(left_value); }
1221
1222 template<typename T_type>
1223 inline boolean operator!=(template_sel left_value,
1224   const OPTIONAL<T_type>& right_value)
1225   { return !right_value.is_equal(left_value); }
1226 #endif
1227
1228 template<typename T_left, typename T_right>
1229 inline boolean operator==(const T_left& left_value,
1230   const OPTIONAL<T_right>& right_value)
1231   { return right_value.is_equal(left_value); }
1232
1233 template<typename T_left, typename T_right>
1234 inline boolean operator!=(const T_left& left_value,
1235   const OPTIONAL<T_right>& right_value)
1236   { return !right_value.is_equal(left_value); }
1237
1238 #endif
1239
1240 #if HAVE_GCC(4,6)
1241 #pragma GCC diagnostic pop
1242 #endif