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
17 * Szabo, Janos Zoltan – initial implementation
20 ******************************************************************************/
21 #ifndef VERDICTTYPE_HH
22 #define VERDICTTYPE_HH
24 #include "Basetype.hh"
25 #include "Template.hh"
26 #include "Optional.hh"
30 /// verdicttype value class
32 class VERDICTTYPE: public Base_Type {
33 friend class VERDICTTYPE_template;
34 friend boolean operator==(verdicttype par_value,
35 const VERDICTTYPE& other_value);
37 verdicttype verdict_value;
38 verdicttype str_to_verdict(const char *v, boolean silent = false);
40 /** Default constructor.
41 * Initialises \p verdict_value to UNBOUND_VERDICT, a private macro
42 * outside the range of \p verdicttype enum.
44 * @post \p is_bound() would return \p false */
46 VERDICTTYPE(verdicttype other_value);
47 VERDICTTYPE(const VERDICTTYPE& other_value);
49 VERDICTTYPE& operator=(verdicttype other_value);
50 VERDICTTYPE& operator=(const VERDICTTYPE& other_value);
52 boolean operator==(verdicttype other_value) const;
53 boolean operator==(const VERDICTTYPE& other_value) const;
54 inline boolean operator!=(verdicttype other_value) const
56 return !(*this == other_value);
58 inline boolean operator!=(const VERDICTTYPE& other_value) const
60 return !(*this == other_value);
63 operator verdicttype() const;
65 inline boolean is_bound() const
67 return verdict_value >= NONE && verdict_value <= ERROR;
69 inline boolean is_value() const
75 #ifdef TITAN_RUNTIME_2
76 boolean is_equal(const Base_Type* other_value) const {return *this == *(static_cast<const VERDICTTYPE*>(other_value));}
77 void set_value(const Base_Type* other_value) {*this = *(static_cast<const VERDICTTYPE*>(other_value));}
78 Base_Type* clone() const {return new VERDICTTYPE(*this);}
79 const TTCN_Typedescriptor_t* get_descriptor() const {return &VERDICTTYPE_descr_;}
81 inline boolean is_present() const { return is_bound(); }
86 void set_param(Module_Param& param);
87 Module_Param* get_param(Module_Param_Name& param_name) const;
89 void encode_text(Text_Buf& text_buf) const;
90 void decode_text(Text_Buf& text_buf);
92 void encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf,
93 TTCN_EncDec::coding_t p_coding, ...) const;
95 void decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf,
96 TTCN_EncDec::coding_t p_coding, ...);
98 int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf,
99 unsigned int flavor, int indent, embed_values_enc_struct_t*) const;
100 int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader,
101 unsigned int flavor, unsigned int flavor2, embed_values_dec_struct_t*);
103 /** Encodes accordingly to the JSON encoding rules.
104 * Returns the length of the encoded data. */
105 int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const;
107 /** Decodes accordingly to the JSON encoding rules.
108 * Returns the length of the decoded data. */
109 int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean);
112 inline boolean operator==(verdicttype par_value, verdicttype other_value)
114 return (int) par_value == (int) other_value;
117 inline boolean operator!=(verdicttype par_value, verdicttype other_value)
119 return (int) par_value != (int) other_value;
122 extern boolean operator==(verdicttype par_value, const VERDICTTYPE& other_value);
124 inline boolean operator!=(verdicttype par_value, const VERDICTTYPE& other_value)
126 return !(par_value == other_value);
129 // verdicttype template class
131 class VERDICTTYPE_template: public Base_Template {
133 verdicttype single_value;
135 unsigned int n_values;
136 VERDICTTYPE_template *list_value;
140 void copy_value(const VERDICTTYPE& other_value);
141 void copy_template(const VERDICTTYPE_template& other_value);
144 VERDICTTYPE_template();
145 VERDICTTYPE_template(template_sel other_value);
146 VERDICTTYPE_template(verdicttype other_value);
147 VERDICTTYPE_template(const VERDICTTYPE& other_value);
148 VERDICTTYPE_template(const OPTIONAL<VERDICTTYPE>& other_value);
149 VERDICTTYPE_template(const VERDICTTYPE_template& other_value);
151 ~VERDICTTYPE_template();
154 VERDICTTYPE_template& operator=(template_sel other_value);
155 VERDICTTYPE_template& operator=(verdicttype other_value);
156 VERDICTTYPE_template& operator=(const VERDICTTYPE& other_value);
157 VERDICTTYPE_template& operator=(const OPTIONAL<VERDICTTYPE>& other_value);
158 VERDICTTYPE_template& operator=(const VERDICTTYPE_template& other_value);
160 boolean match(verdicttype other_value, boolean legacy = FALSE) const;
161 boolean match(const VERDICTTYPE& other_value, boolean legacy = FALSE) const;
162 verdicttype valueof() const;
164 void set_type(template_sel template_type, unsigned int list_length);
165 VERDICTTYPE_template& list_item(unsigned int list_index);
168 void log_match(const VERDICTTYPE& match_value, boolean legacy = FALSE) const;
170 void set_param(Module_Param& param);
171 Module_Param* get_param(Module_Param_Name& param_name) const;
173 void encode_text(Text_Buf& text_buf) const;
174 void decode_text(Text_Buf& text_buf);
176 boolean is_present(boolean legacy = FALSE) const;
177 boolean match_omit(boolean legacy = FALSE) const;
178 #ifdef TITAN_RUNTIME_2
179 void valueofv(Base_Type* value) const {*(static_cast<VERDICTTYPE*>(value)) = valueof();}
180 void set_value(template_sel other_value) {*this = other_value;}
181 void copy_value(const Base_Type* other_value) {*this = *(static_cast<const VERDICTTYPE*>(other_value));}
182 Base_Template* clone() const {return new VERDICTTYPE_template(*this);}
183 const TTCN_Typedescriptor_t* get_descriptor() const {return &VERDICTTYPE_descr_;}
184 boolean matchv(const Base_Type* other_value, boolean legacy) const {return match(*(static_cast<const VERDICTTYPE*>(other_value)), legacy);}
185 void log_matchv(const Base_Type* match_value, boolean legacy) const {log_match(*(static_cast<const VERDICTTYPE*>(match_value)), legacy);}
187 void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;