1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
/******************************************************************************
* Copyright (c) 2000-2016 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Balasko, Jeno
* Baranyi, Botond
* Beres, Szabolcs
* Delic, Adam
* Forstner, Matyas
* Raduly, Csaba
* Szabados, Kristof
* Szabo, Bence Janos
* Szabo, Janos Zoltan – initial implementation
* Tatarka, Gabor
*
******************************************************************************/
#ifndef VERDICTTYPE_HH
#define VERDICTTYPE_HH
#include "Basetype.hh"
#include "Template.hh"
#include "Optional.hh"
class Module_Param;
/// verdicttype value class
class VERDICTTYPE: public Base_Type {
friend class VERDICTTYPE_template;
friend boolean operator==(verdicttype par_value,
const VERDICTTYPE& other_value);
verdicttype verdict_value;
verdicttype str_to_verdict(const char *v, boolean silent = false);
public:
/** Default constructor.
* Initialises \p verdict_value to UNBOUND_VERDICT, a private macro
* outside the range of \p verdicttype enum.
*
* @post \p is_bound() would return \p false */
VERDICTTYPE();
VERDICTTYPE(verdicttype other_value);
VERDICTTYPE(const VERDICTTYPE& other_value);
VERDICTTYPE& operator=(verdicttype other_value);
VERDICTTYPE& operator=(const VERDICTTYPE& other_value);
boolean operator==(verdicttype other_value) const;
boolean operator==(const VERDICTTYPE& other_value) const;
inline boolean operator!=(verdicttype other_value) const
{
return !(*this == other_value);
}
inline boolean operator!=(const VERDICTTYPE& other_value) const
{
return !(*this == other_value);
}
operator verdicttype() const;
inline boolean is_bound() const
{
return verdict_value >= NONE && verdict_value <= ERROR;
}
inline boolean is_value() const
{
return is_bound();
}
void clean_up();
#ifdef TITAN_RUNTIME_2
boolean is_equal(const Base_Type* other_value) const {return *this == *(static_cast<const VERDICTTYPE*>(other_value));}
void set_value(const Base_Type* other_value) {*this = *(static_cast<const VERDICTTYPE*>(other_value));}
Base_Type* clone() const {return new VERDICTTYPE(*this);}
const TTCN_Typedescriptor_t* get_descriptor() const {return &VERDICTTYPE_descr_;}
Module_Param* get_param(Module_Param_Name& param_name) const;
#else
inline boolean is_present() const { return is_bound(); }
#endif
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf,
TTCN_EncDec::coding_t p_coding, ...) const;
void decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf,
TTCN_EncDec::coding_t p_coding, ...);
int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf,
unsigned int flavor, int indent, embed_values_enc_struct_t*) const;
int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader,
unsigned int flavor, unsigned int flavor2, embed_values_dec_struct_t*);
/** Encodes accordingly to the JSON encoding rules.
* Returns the length of the encoded data. */
int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const;
/** Decodes accordingly to the JSON encoding rules.
* Returns the length of the decoded data. */
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean);
};
inline boolean operator==(verdicttype par_value, verdicttype other_value)
{
return (int) par_value == (int) other_value;
}
inline boolean operator!=(verdicttype par_value, verdicttype other_value)
{
return (int) par_value != (int) other_value;
}
extern boolean operator==(verdicttype par_value, const VERDICTTYPE& other_value);
inline boolean operator!=(verdicttype par_value, const VERDICTTYPE& other_value)
{
return !(par_value == other_value);
}
// verdicttype template class
class VERDICTTYPE_template: public Base_Template {
union {
verdicttype single_value;
struct {
unsigned int n_values;
VERDICTTYPE_template *list_value;
} value_list;
};
void copy_value(const VERDICTTYPE& other_value);
void copy_template(const VERDICTTYPE_template& other_value);
public:
VERDICTTYPE_template();
VERDICTTYPE_template(template_sel other_value);
VERDICTTYPE_template(verdicttype other_value);
VERDICTTYPE_template(const VERDICTTYPE& other_value);
VERDICTTYPE_template(const OPTIONAL<VERDICTTYPE>& other_value);
VERDICTTYPE_template(const VERDICTTYPE_template& other_value);
~VERDICTTYPE_template();
void clean_up();
VERDICTTYPE_template& operator=(template_sel other_value);
VERDICTTYPE_template& operator=(verdicttype other_value);
VERDICTTYPE_template& operator=(const VERDICTTYPE& other_value);
VERDICTTYPE_template& operator=(const OPTIONAL<VERDICTTYPE>& other_value);
VERDICTTYPE_template& operator=(const VERDICTTYPE_template& other_value);
boolean match(verdicttype other_value, boolean legacy = FALSE) const;
boolean match(const VERDICTTYPE& other_value, boolean legacy = FALSE) const;
verdicttype valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
VERDICTTYPE_template& list_item(unsigned int list_index);
void log() const;
void log_match(const VERDICTTYPE& match_value, boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
#ifdef TITAN_RUNTIME_2
Module_Param* get_param(Module_Param_Name& param_name) const;
void valueofv(Base_Type* value) const {*(static_cast<VERDICTTYPE*>(value)) = valueof();}
void set_value(template_sel other_value) {*this = other_value;}
void copy_value(const Base_Type* other_value) {*this = *(static_cast<const VERDICTTYPE*>(other_value));}
Base_Template* clone() const {return new VERDICTTYPE_template(*this);}
const TTCN_Typedescriptor_t* get_descriptor() const {return &VERDICTTYPE_descr_;}
boolean matchv(const Base_Type* other_value, boolean legacy) const {return match(*(static_cast<const VERDICTTYPE*>(other_value)), legacy);}
void log_matchv(const Base_Type* match_value, boolean legacy) const {log_match(*(static_cast<const VERDICTTYPE*>(match_value)), legacy);}
#else
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
#endif
};
#endif
|
