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 INTEGER_HH | |
9 | #define INTEGER_HH | |
10 | ||
11 | #include "Basetype.hh" | |
12 | #include "Template.hh" | |
13 | #include "Optional.hh" | |
14 | #include "Error.hh" | |
15 | #include "RInt.hh" | |
16 | ||
17 | class BITSTRING; | |
18 | class CHARSTRING; | |
19 | class HEXSTRING; | |
20 | class OCTETSTRING; | |
21 | ||
22 | class Module_Param; | |
23 | ||
24 | class INTEGER : public Base_Type { | |
25 | // Private constructor for internal initialization. It's not part of the | |
26 | // public API. | |
27 | explicit INTEGER(BIGNUM *other_value); | |
28 | int from_string(const char *); | |
29 | ||
30 | int get_nof_digits(); | |
31 | ||
32 | friend class INTEGER_template; | |
33 | friend INTEGER operator+(int int_value, const INTEGER& other_value); | |
34 | friend INTEGER operator-(int int_value, const INTEGER& other_value); | |
35 | friend INTEGER operator*(int int_value, const INTEGER& other_value); | |
36 | friend INTEGER operator/(int int_value, const INTEGER& other_value); | |
37 | friend INTEGER rem(const INTEGER& left_value, const INTEGER& right_value); | |
38 | friend INTEGER rem(const INTEGER& left_value, int right_value); | |
39 | friend INTEGER rem(int left_value, const INTEGER& right_value); | |
40 | friend INTEGER mod(const INTEGER& left_value, const INTEGER& right_value); | |
41 | friend INTEGER mod(const INTEGER& left_value, int right_value); | |
42 | friend INTEGER mod(int left_value, const INTEGER& right_value); | |
43 | friend boolean operator==(int int_value, const INTEGER& other_value); | |
44 | friend boolean operator< (int int_value, const INTEGER& other_value); | |
45 | friend boolean operator> (int int_value, const INTEGER& other_value); | |
46 | ||
47 | friend INTEGER bit2int(const BITSTRING& value); | |
48 | friend INTEGER hex2int(const HEXSTRING& value); | |
49 | friend INTEGER oct2int(const OCTETSTRING& value); | |
50 | friend INTEGER str2int(const CHARSTRING& value); | |
51 | ||
52 | friend void log_param_value(); | |
53 | ||
54 | boolean bound_flag; | |
55 | boolean native_flag; | |
56 | union { | |
57 | RInt native; | |
58 | BIGNUM *openssl; | |
59 | } val; | |
60 | ||
61 | public: | |
62 | INTEGER(); | |
63 | INTEGER(const INTEGER& other_value); | |
64 | INTEGER(int other_value); | |
65 | explicit INTEGER(const char *other_value); | |
66 | ~INTEGER(); | |
67 | void clean_up(); | |
68 | ||
69 | INTEGER& operator=(int other_value); | |
70 | INTEGER& operator=(const INTEGER& other_value); | |
71 | INTEGER& operator++(); | |
72 | INTEGER& operator--(); | |
73 | ||
74 | INTEGER operator+() const; | |
75 | INTEGER operator-() const; | |
76 | ||
77 | INTEGER operator+(int other_value) const; | |
78 | INTEGER operator+(const INTEGER& other_value) const; | |
79 | INTEGER operator-(int other_value) const; | |
80 | INTEGER operator-(const INTEGER& other_value) const; | |
81 | INTEGER operator*(int other_value) const; | |
82 | INTEGER operator*(const INTEGER& other_value) const; | |
83 | INTEGER operator/(int other_value) const; | |
84 | INTEGER operator/(const INTEGER& other_value) const; | |
85 | ||
86 | boolean operator==(int other_value) const; | |
87 | boolean operator==(const INTEGER& other_value) const; | |
88 | inline boolean operator!=(int other_value) const | |
89 | { return !(*this == other_value); } | |
90 | inline boolean operator!=(const INTEGER& other_value) const | |
91 | { return !(*this == other_value); } | |
92 | ||
93 | boolean operator<(int other_value) const; | |
94 | boolean operator<(const INTEGER& other_value) const; | |
95 | boolean operator>(int other_value) const; | |
96 | boolean operator>(const INTEGER& other_value) const; | |
97 | inline boolean operator<=(int other_value) const | |
98 | { return !(*this > other_value); } | |
99 | inline boolean operator<=(const INTEGER& other_value) const | |
100 | { return !(*this > other_value); } | |
101 | inline boolean operator>=(int other_value) const | |
102 | { return !(*this < other_value); } | |
103 | inline boolean operator>=(const INTEGER& other_value) const | |
104 | { return !(*this < other_value); } | |
105 | ||
106 | operator int() const; | |
107 | long long int get_long_long_val() const; | |
108 | void set_long_long_val(long long int other_value); | |
109 | ||
110 | inline boolean is_native() const { return native_flag; } | |
111 | inline boolean is_bound() const { return bound_flag; } | |
112 | inline boolean is_value() const { return bound_flag; } | |
113 | inline void must_bound(const char *err_msg) const | |
114 | { if (!bound_flag) | |
115 | TTCN_error("%s", err_msg); | |
116 | } | |
117 | int_val_t get_val() const; | |
118 | void set_val(const int_val_t& other_value); | |
119 | ||
120 | void log() const; | |
121 | ||
122 | #ifdef TITAN_RUNTIME_2 | |
123 | boolean is_equal(const Base_Type* other_value) const { return *this == *(static_cast<const INTEGER*>(other_value)); } | |
124 | void set_value(const Base_Type* other_value) { *this = *(static_cast<const INTEGER*>(other_value)); } | |
125 | Base_Type* clone() const { return new INTEGER(*this); } | |
126 | const TTCN_Typedescriptor_t* get_descriptor() const { return &INTEGER_descr_; } | |
127 | #else | |
128 | inline boolean is_present() const { return is_bound(); } | |
129 | #endif | |
130 | ||
131 | void set_param(Module_Param& param); | |
132 | void encode_text(Text_Buf& text_buf) const; | |
133 | void decode_text(Text_Buf& text_buf); | |
134 | ||
135 | void encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, | |
136 | TTCN_EncDec::coding_t p_coding, ...) const; | |
137 | ||
138 | void decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, | |
139 | TTCN_EncDec::coding_t p_coding, ...); | |
140 | ||
141 | ASN_BER_TLV_t* BER_encode_TLV(const TTCN_Typedescriptor_t& p_td, | |
142 | unsigned p_coding) const; | |
143 | ||
144 | boolean BER_decode_TLV(const TTCN_Typedescriptor_t& p_td, | |
145 | const ASN_BER_TLV_t& p_tlv, unsigned L_form); | |
146 | ||
147 | /** Encodes the value of the variable according to the | |
148 | * TTCN_Typedescriptor_t. It must be public because called by | |
149 | * another types during encoding. Returns the length of encoded data. */ | |
150 | int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
151 | int RAW_encode_openssl(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const; | |
152 | ||
153 | /** Decodes the value of the variable according to the | |
154 | * TTCN_Typedescriptor_t. It must be public because called by | |
155 | * another types during encoding. Returns the number of decoded bits. */ | |
156 | int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, | |
157 | boolean no_err=FALSE, int sel_field=-1, boolean first_call=TRUE); | |
158 | int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const; | |
159 | int TEXT_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, | |
160 | Limit_Token_List&, boolean no_err = FALSE, boolean first_call=TRUE); | |
161 | /** @brief Encode according to XML Encoding Rules. | |
162 | **/ | |
163 | int XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor, | |
af710487 | 164 | int indent, embed_values_enc_struct_t*) const; |
970ed795 EL |
165 | /** @brief Decode according to XML Encoding Rules. |
166 | **/ | |
167 | int XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader, | |
af710487 | 168 | unsigned int flavor, embed_values_dec_struct_t*); |
970ed795 EL |
169 | |
170 | /** Encodes accordingly to the JSON encoding rules. | |
171 | * Returns the length of the encoded data. */ | |
172 | int JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&) const; | |
173 | ||
174 | /** Decodes accordingly to the JSON encoding rules. | |
175 | * Returns the length of the decoded data. */ | |
176 | int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean); | |
177 | }; | |
178 | ||
179 | extern INTEGER operator+(int int_value, const INTEGER& other_value); | |
180 | extern INTEGER operator-(int int_value, const INTEGER& other_value); | |
181 | extern INTEGER operator*(int int_value, const INTEGER& other_value); | |
182 | extern INTEGER operator/(int int_value, const INTEGER& other_value); | |
183 | ||
184 | extern INTEGER rem(int left_value, int right_value); | |
185 | extern INTEGER rem(const INTEGER& left_value, const INTEGER& right_value); | |
186 | extern INTEGER rem(const INTEGER& left_value, int right_value); | |
187 | extern INTEGER rem(int left_value, const INTEGER& right_value); | |
188 | ||
189 | extern INTEGER mod(int left_value, int right_value); | |
190 | extern INTEGER mod(const INTEGER& left_value, const INTEGER& right_value); | |
191 | extern INTEGER mod(const INTEGER& left_value, int right_value); | |
192 | extern INTEGER mod(int left_value, const INTEGER& right_value); | |
193 | ||
194 | extern boolean operator==(int int_value, const INTEGER& other_value); | |
195 | extern boolean operator<(int int_value, const INTEGER& other_value); | |
196 | extern boolean operator>(int int_value, const INTEGER& other_value); | |
197 | ||
198 | inline boolean operator!=(int int_value, const INTEGER& other_value) | |
199 | { | |
200 | return !(int_value == other_value); | |
201 | } | |
202 | ||
203 | inline boolean operator<=(int int_value, const INTEGER& other_value) | |
204 | { | |
205 | return !(int_value > other_value); | |
206 | } | |
207 | ||
208 | inline boolean operator>=(int int_value, const INTEGER& other_value) | |
209 | { | |
210 | return !(int_value < other_value); | |
211 | } | |
212 | ||
213 | // Integer template class. | |
214 | ||
215 | class INTEGER_template : public Base_Template { | |
216 | private: | |
217 | union { | |
218 | struct { | |
219 | boolean native_flag; | |
220 | union { | |
221 | RInt native; | |
222 | BIGNUM *openssl; | |
223 | } val; | |
224 | } int_val; | |
225 | struct { | |
226 | unsigned int n_values; | |
227 | INTEGER_template *list_value; | |
228 | } value_list; | |
229 | struct { | |
230 | boolean min_is_present, max_is_present; | |
231 | struct { | |
232 | boolean native_flag; | |
233 | union { | |
234 | RInt native; | |
235 | BIGNUM *openssl; | |
236 | } val; | |
237 | } min_value, max_value; | |
238 | } value_range; | |
239 | }; | |
240 | ||
241 | void copy_template(const INTEGER_template& other_value); | |
242 | ||
243 | public: | |
244 | INTEGER_template(); | |
245 | INTEGER_template(const INTEGER_template& other_value); | |
246 | INTEGER_template(template_sel other_value); | |
247 | INTEGER_template(int other_value); | |
248 | INTEGER_template(const INTEGER& other_value); | |
249 | INTEGER_template(const OPTIONAL<INTEGER>& other_value); | |
250 | ~INTEGER_template(); | |
251 | void clean_up(); | |
252 | ||
253 | INTEGER_template& operator=(template_sel other_value); | |
254 | INTEGER_template& operator=(int other_value); | |
255 | INTEGER_template& operator=(const INTEGER& other_value); | |
256 | INTEGER_template& operator=(const OPTIONAL<INTEGER>& other_value); | |
257 | INTEGER_template& operator=(const INTEGER_template& other_value); | |
258 | ||
259 | boolean match(int other_value) const; | |
260 | boolean match(const INTEGER& other_value) const; | |
261 | INTEGER valueof() const; | |
262 | ||
263 | /** Sets the template type. | |
264 | * | |
265 | * Calls clean_up(), so the template becomes uninitialized. | |
266 | * | |
267 | * @param template_type | |
268 | * @param list_length used for VALUE_LIST and COMPLEMENTED_LIST only. | |
269 | * | |
270 | * @post template_selection = UNINITIALIZED_TEMPLATE | |
271 | */ | |
272 | void set_type(template_sel template_type, unsigned int list_length = 0); | |
273 | /** Returns the specified list item | |
274 | * | |
275 | * @param list_index | |
276 | * @return the list item | |
277 | * @pre template_selection is VALUE_LIST or COMPLEMENTED_LIST | |
278 | */ | |
279 | INTEGER_template& list_item(unsigned int list_index); | |
280 | ||
281 | /** Sets the lower bound of the value range. | |
282 | * | |
283 | * @param min_value | |
284 | * @pre template_selection == VALUE_RANGE; else DTE | |
285 | */ | |
286 | void set_min(int min_value); | |
287 | /** Sets the lower bound of the value range. | |
288 | * | |
289 | * @param min_value | |
290 | * @pre template_selection == VALUE_RANGE; else DTE | |
291 | * @pre min_value must be bound; else DTE | |
292 | */ | |
293 | void set_min(const INTEGER& min_value); | |
294 | /** Sets the upper bound of the value range. | |
295 | * | |
296 | * @param max_value | |
297 | * @pre template_selection == VALUE_RANGE; else DTE | |
298 | * @pre min_value must be bound; else DTE | |
299 | */ | |
300 | void set_max(int max_value); | |
301 | /** Sets the upper bound of the value range. | |
302 | * | |
303 | * @param max_value | |
304 | * @pre template_selection == VALUE_RANGE; else DTE | |
305 | * @pre min_value must be bound; else DTE | |
306 | */ | |
307 | void set_max(const INTEGER& max_value); | |
308 | ||
309 | void log() const; | |
310 | void log_match(const INTEGER& match_value) const; | |
311 | ||
312 | void set_param(Module_Param& param); | |
313 | ||
314 | void encode_text(Text_Buf& text_buf) const; | |
315 | void decode_text(Text_Buf& text_buf); | |
316 | ||
317 | boolean is_present() const; | |
318 | boolean match_omit() const; | |
319 | ||
320 | #ifdef TITAN_RUNTIME_2 | |
321 | void valueofv(Base_Type* value) const { *(static_cast<INTEGER*>(value)) = valueof(); } | |
322 | void set_value(template_sel other_value) { *this = other_value; } | |
323 | void copy_value(const Base_Type* other_value) { *this = *(static_cast<const INTEGER*>(other_value)); } | |
324 | Base_Template* clone() const { return new INTEGER_template(*this); } | |
325 | const TTCN_Typedescriptor_t* get_descriptor() const { return &INTEGER_descr_; } | |
326 | boolean matchv(const Base_Type* other_value) const { return match(*(static_cast<const INTEGER*>(other_value))); } | |
327 | void log_matchv(const Base_Type* match_value) const { log_match(*(static_cast<const INTEGER*>(match_value))); } | |
328 | #else | |
329 | void check_restriction(template_res t_res, const char* t_name=NULL) const; | |
330 | #endif | |
331 | }; | |
332 | ||
333 | #endif // INTEGER_HH | |
334 |