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 ///////////////////////////////////////////////////////////////////////////////
11 #include "../Setting.hh"
12 #include "../Type.hh" // for Common::Common::Type::MessageEncodingType_t
13 #include "AST_ttcn3.hh" // For Def_Function_Base::prototype_t
15 #include "../vector.hh"
22 * Class to represent an error behavior setting in the codec API of the
23 * run-time environment. The setting contains a pair of strings:
24 * the error type identifier and the way of error handling.
26 class ErrorBehaviorSetting : public Common::Node, public Common::Location {
28 string error_type, error_handling;
30 ErrorBehaviorSetting(const string& p_error_type,
31 const string& p_error_handling)
32 : Common::Node(), Common::Location(), error_type(p_error_type),
33 error_handling(p_error_handling) { }
34 virtual ErrorBehaviorSetting *clone() const;
35 const string& get_error_type() const { return error_type; }
36 void set_error_type(const string& p_error_type)
37 { error_type = p_error_type; }
38 const string& get_error_handling() const { return error_handling; }
39 void set_error_handling(const string& p_error_handling)
40 { error_handling = p_error_handling; }
41 virtual void dump(unsigned level) const;
45 * Class to represent a list of error behavior settings in the codec API
46 * of the run-time environment.
48 class ErrorBehaviorList : public Common::Node, public Common::Location {
50 vector<ErrorBehaviorSetting> ebs_v;
51 map<string, ErrorBehaviorSetting> ebs_m;
52 ErrorBehaviorSetting *ebs_all;
54 /** Copy constructor not implemented */
55 ErrorBehaviorList(const ErrorBehaviorList& p);
56 /** Assignment disabled */
57 ErrorBehaviorList& operator=(const ErrorBehaviorList& p);
59 ErrorBehaviorList() : Common::Node(), Common::Location(), ebs_all(0), checked(false) { }
60 virtual ~ErrorBehaviorList();
61 virtual ErrorBehaviorList *clone() const;
62 virtual void set_fullname(const string& p_fullname);
63 void add_ebs(ErrorBehaviorSetting *p_ebs);
64 void steal_ebs(ErrorBehaviorList *p_eblist);
65 size_t get_nof_ebs() const { return ebs_v.size(); }
66 ErrorBehaviorSetting *get_ebs_byIndex(size_t n) const { return ebs_v[n]; }
67 bool has_setting(const string& p_error_type);
68 string get_handling(const string& p_error_type);
70 char *generate_code(char *str);
71 virtual void dump(unsigned level) const;
74 /** Printing type class for JSON encoder functions */
75 class PrintingType : public Common::Node, public Common::Location {
79 /** No printing has been set */
81 /** Printing without any white spaces to make the JSON code as short as possible */
83 /** Printing with extra white spaces to make the JSON code easier to read */
87 PrintingType() : Common::Node(), Common::Location(), printing(PT_NONE) { }
88 virtual ~PrintingType() {};
89 virtual PrintingType *clone() const;
90 void set_printing(printing_t p_pt) { printing = p_pt; }
91 printing_t get_printing() const { return printing; }
92 char *generate_code(char *str);
97 /** Copy constructor not implemented */
98 PrintingType(const PrintingType& p);
99 /** Assignment disabled */
100 PrintingType& operator=(const PrintingType& p);
103 /** A single target type for type mapping */
104 class TypeMappingTarget : public Common::Node, public Common::Location {
106 enum TypeMappingType_t {
107 TM_SIMPLE, /**< simple mapping (source == target) */
108 TM_DISCARD, /**< the message is discarded (target type is NULL) */
109 TM_FUNCTION, /**< mapping using a [external] function */
110 TM_ENCODE, /**< mapping using a built-in encoder */
111 TM_DECODE /**< mapping using a built-in decoder */
114 Common::Type *target_type; // owned
115 TypeMappingType_t mapping_type;
118 Ttcn::Reference *function_ref;
119 Ttcn::Def_Function_Base *function_ptr;
122 Common::Type::MessageEncodingType_t coding_type; // BER,RAW,...
123 string *coding_options;
124 ErrorBehaviorList *eb_list;
128 /** Copy constructor not implemented */
129 TypeMappingTarget(const TypeMappingTarget& p);
130 /** Assignment disabled */
131 TypeMappingTarget& operator=(const TypeMappingTarget& p);
133 /** Constructor for TM_SIMPLE and TM_DISCARD. */
134 TypeMappingTarget(Common::Type *p_target_type, TypeMappingType_t p_mapping_type);
135 /** Constructor for TM_FUNCTION. */
136 TypeMappingTarget(Common::Type *p_target_type, TypeMappingType_t p_mapping_type,
137 Ttcn::Reference *p_function_ref);
138 /** Constructor for TM_ENCODE and TM_DECODE. */
139 TypeMappingTarget(Common::Type *p_target_type, TypeMappingType_t p_mapping_type,
140 Common::Type::MessageEncodingType_t p_coding_type, string *p_coding_options,
141 ErrorBehaviorList *p_eb_list);
142 virtual ~TypeMappingTarget();
143 virtual TypeMappingTarget *clone() const;
144 virtual void set_fullname(const string& p_fullname);
145 virtual void set_my_scope(Common::Scope *p_scope);
146 TypeMappingType_t get_mapping_type() const { return mapping_type; }
147 /** Returns the string representation of \a mapping_type */
148 const char *get_mapping_name() const;
149 Common::Type *get_target_type() const { return target_type; }
150 /** Applicable if \a mapping_type is TM_FUNCTION. */
151 Ttcn::Def_Function_Base *get_function() const;
152 /** Applicable if \a mapping_type is TM_ENCODE or TM_DECODE. */
153 Common::Type::MessageEncodingType_t get_coding_type() const;
154 /** Applicable if \a mapping_type is TM_ENCODE or TM_DECODE. */
155 bool has_coding_options() const;
156 /** Applicable if \a mapping_type is TM_ENCODE or TM_DECODE and
157 * \a has_coding_options() returned true. */
158 const string& get_coding_options() const;
159 /** Applicable if \a mapping_type is TM_ENCODE or TM_DECODE. */
160 ErrorBehaviorList *get_eb_list() const;
162 /** Check that the source_type is identical with the target_type of
163 * this simple mapping. */
164 void chk_simple(Common::Type *source_type);
165 /** Check function mapping.
166 * The function must have "prototype()", the function's input parameter
167 * must match the source_type and its return type must match the target_type
168 * of this mapping. */
169 void chk_function(Common::Type *source_type);
170 /** Check "encode()" mapping. */
171 void chk_encode(Common::Type *source_type);
172 /** Check "decode()" mapping. */
173 void chk_decode(Common::Type *source_type);
175 void chk(Common::Type *source_type);
176 /** Fills the appropriate data structure \a target for code generation. */
177 bool fill_type_mapping_target(port_msg_type_mapping_target *target,
178 Common::Type *source_type, Common::Scope *p_scope, stringpool& pool);
179 virtual void dump(unsigned level) const;
182 /** A list of mapping targets */
183 class TypeMappingTargets : public Common::Node {
185 vector<TypeMappingTarget> targets_v;
186 /** Copy constructor not implemented */
187 TypeMappingTargets(const TypeMappingTargets& p);
188 /** Assignment disabled */
189 TypeMappingTargets& operator=(const TypeMappingTargets& p);
191 TypeMappingTargets() : Common::Node() { }
192 virtual ~TypeMappingTargets();
193 virtual TypeMappingTargets *clone() const;
194 virtual void set_fullname(const string& p_fullname);
195 virtual void set_my_scope(Common::Scope *p_scope);
196 void add_target(TypeMappingTarget *p_target);
197 size_t get_nof_targets() const { return targets_v.size(); }
198 TypeMappingTarget *get_target_byIndex(size_t n) const
199 { return targets_v[n]; }
200 virtual void dump(unsigned level) const;
204 * One source type, multiple targets:
206 * in(octetstring -> PDU1 : function(f),
207 * PDU2 : decode(RAW),
212 class TypeMapping : public Common::Node, public Common::Location {
214 Common::Type *source_type;
215 TypeMappingTargets *targets;
216 /** Copy constructor not implemented */
217 TypeMapping(const TypeMapping& p);
218 /** Assignment disabled */
219 TypeMapping& operator=(const TypeMapping& p);
221 TypeMapping(Common::Type *p_source_type, TypeMappingTargets *p_targets);
222 virtual ~TypeMapping();
223 virtual TypeMapping *clone() const;
224 virtual void set_fullname(const string& p_fullname);
225 virtual void set_my_scope(Common::Scope *p_scope);
226 Common::Type *get_source_type() const { return source_type; }
227 size_t get_nof_targets() const { return targets->get_nof_targets(); }
228 TypeMappingTarget *get_target_byIndex(size_t n) const
229 { return targets->get_target_byIndex(n); }
231 virtual void dump(unsigned level) const;
234 class TypeMappings : public Common::Node, public Common::Location {
236 vector<TypeMapping> mappings_v;
237 map<string, TypeMapping> mappings_m;
239 /** Copy constructor not implemented */
240 TypeMappings(const TypeMappings& p);
241 /** Assignment disabled */
242 TypeMappings& operator=(const TypeMappings& p);
244 TypeMappings() : Common::Node(), Common::Location(), checked(false) { }
245 virtual ~TypeMappings();
246 virtual TypeMappings *clone() const;
247 virtual void set_fullname(const string& p_fullname);
248 virtual void set_my_scope(Common::Scope *p_scope);
249 void add_mapping(TypeMapping *p_mapping);
250 void steal_mappings(TypeMappings *p_mappings);
251 size_t get_nof_mappings() const { return mappings_v.size(); }
252 TypeMapping *get_mapping_byIndex(size_t n) const { return mappings_v[n]; }
253 bool has_mapping_for_type(Common::Type *p_type) const;
254 TypeMapping *get_mapping_byType(Common::Type *p_type) const;
256 virtual void dump(unsigned level) const;
260 * Type list, used in port types
262 class Types : public Common::Node, public Common::Location {
264 vector<Common::Type> types;
265 /** Copy constructor not implemented */
266 Types(const Types& p);
267 /** Assignment disabled */
268 Types& operator=(const Types& p);
270 Types() : Common::Node(), Common::Location() { }
272 virtual Types *clone() const;
274 /** Add a new type to the list.
275 * It is now owned by the list. */
276 void add_type(Common::Type *p_type);
277 /** Moves (appends) all types of \a p_tl into this. */
278 void steal_types(Types *p_tl);
279 size_t get_nof_types() const { return types.size(); }
280 /** Return a type based on its index. */
281 Common::Type *get_type_byIndex(size_t n) const { return types[n]; }
282 /** Remove a type from the list and return it.
283 * The old value is replaced with a NULL pointer. */
284 Common::Type *extract_type_byIndex(size_t n);
286 virtual void set_fullname(const string& p_fullname);
287 virtual void set_my_scope(Common::Scope *p_scope);
288 virtual void dump(unsigned level) const;
292 * Unique set of types. It does not own its members. The types are identified
293 * using the string returned by get_typename().
295 class TypeSet : public Common::Node {
296 /** Copy constructor not implemented */
297 TypeSet(const TypeSet& p);
298 /** Assignment not implemented */
299 TypeSet& operator=(const TypeSet& p);
301 vector<Common::Type> types_v;
302 map<string, Common::Type> types_m;
304 TypeSet() : Common::Node() { }
306 virtual TypeSet *clone() const;
308 /** Adds type \a p_type to the set. */
309 void add_type(Common::Type *p_type);
310 /** Returns the number of types in the set. */
311 size_t get_nof_types() const { return types_v.size(); }
312 /** Returns the \a n-th element of the set. */
313 Common::Type *get_type_byIndex(size_t n) const { return types_v[n]; }
314 /** Returns whether type \a p_type is a member of the set. */
315 bool has_type(Common::Type *p_type) const;
316 /** Returns the number of types in the set that are compatible with
318 size_t get_nof_compatible_types(Common::Type *p_type) const;
319 /** Returns the index of type \a p_type in the set. It is assumed that
320 * \a p_type is a member of the set, otherwise FATAL_ERROR occurs. */
321 size_t get_index_byType(Common::Type *p_type) const;
322 /** Returns whether the set contains a type with typename \a p_name. */
323 bool has_type_withName(const string& p_name) const
324 { return types_m.has_key(p_name); }
325 /** Returns the type from the set with typename \a p_name. */
326 Common::Type *get_type_byName(const string& p_name) const
327 { return types_m[p_name]; }
329 virtual void dump(unsigned level) const;
332 /** Class to hold a parsed PortDefAttribs.
333 * This includes the operation mode and the input/output types. */
334 class PortTypeBody : public Common::Node, public Common::Location {
337 * Enumeration to represent TTCN-3 port operation modes.
339 enum PortOperationMode_t {
345 * Enumeration to represent the test port API variants.
348 TP_REGULAR, /**< regular test port API */
349 TP_INTERNAL, /**< no test port (only connections are allowed) */
350 TP_ADDRESS /**< usage of the address type is supported */
353 * Enumeration to represent the the properties of the port type.
356 PT_REGULAR, /**< regular port type */
357 PT_PROVIDER, /**< the port type provides the external interface for other
359 PT_USER /**< the port type uses another port type as external interface */
362 Common::Type *my_type; // the Type that owns this object
363 PortOperationMode_t operation_mode; // message|procedure|mixed
364 Types *in_list, *out_list, *inout_list;
365 bool in_all, out_all, inout_all; // whether "(in|out|inout) all" was used
367 /* Types and signatures that can be sent and received.
368 * These are initially empty; filled by PortTypeBody::chk_list based on
369 * in_list, out_list, inout_list.
370 * Signature types are added to _sigs, "normal" types to _msgs.
372 TypeSet *in_msgs, *out_msgs, *in_sigs, *out_sigs;
373 TestPortAPI_t testport_type; // regular|internal|address
374 PortType_t port_type; // regular|provider|user
375 Ttcn::Reference *provider_ref; ///< reference to provider port, for PT_USER
376 Common::Type *provider_type; ///< the type that provider_ref refers to
377 TypeMappings *in_mappings, *out_mappings; ///< mappings for PT_USER
378 /** Copy constructor not implemented */
379 PortTypeBody(const PortTypeBody& p);
380 /** Assignment disabled */
381 PortTypeBody& operator=(const PortTypeBody& p);
383 PortTypeBody(PortOperationMode_t p_operation_mode,
384 Types *p_in_list, Types *p_out_list, Types *p_inout_list,
385 bool p_in_all, bool p_out_all, bool p_inout_all);
387 virtual PortTypeBody *clone() const;
388 virtual void set_fullname(const string& p_fullname);
389 virtual void set_my_scope(Common::Scope *p_scope);
390 void set_my_type(Common::Type *p_type);
391 PortOperationMode_t get_operation_mode() const { return operation_mode; }
392 TypeSet *get_in_msgs() const;
393 TypeSet *get_out_msgs() const;
394 TypeSet *get_in_sigs() const;
395 TypeSet *get_out_sigs() const;
396 bool has_queue() const;
397 bool getreply_allowed() const;
398 bool catch_allowed() const;
399 bool is_internal() const;
400 /** Returns the address type that can be used in communication operations
401 * on this port type. NULL is returned if addressing inside SUT is not
402 * supported or the address type does not exist. */
403 Common::Type *get_address_type();
404 TestPortAPI_t get_testport_type() const { return testport_type; }
405 void set_testport_type(TestPortAPI_t p_testport_type)
406 { testport_type = p_testport_type; }
407 PortType_t get_type() const { return port_type; }
408 void add_provider_attribute();
409 void add_user_attribute(Ttcn::Reference *p_provider_ref,
410 TypeMappings *p_in_mappings, TypeMappings *p_out_mappings);
411 Common::Type *get_provider_type() const;
413 void chk_list(const Types *list, bool is_in, bool is_out);
414 void chk_user_attribute();
417 void chk_attributes(Ttcn::WithAttribPath *w_attrib_path);
418 /** Returns whether the outgoing messages and signatures of \a this are
419 * on the incoming lists of \a p_other. */
420 bool is_connectable(PortTypeBody *p_other) const;
421 /** Reports the error messages about the outgoing types of \a this that
422 * are not handled by the incoming lists of \a p_other.
423 * Applicable only if \a is_connectable() returned false. */
424 void report_connection_errors(PortTypeBody *p_other) const;
425 /** Returns whether \a this as the type of a test component port can be
426 * mapped to a system port with type \a p_other. */
427 bool is_mappable(PortTypeBody *p_other) const;
428 /** Reports all errors that prevent mapping of \a this as the type of a
429 * test component port to system port \a p_other.
430 * Applicable only if \a is_mappable() returned false. */
431 void report_mapping_errors(PortTypeBody *p_other) const;
432 void generate_code(output_struct *target);
433 virtual void dump(unsigned level) const;
436 /** Class to represent an "extension" attribute.
439 class ExtensionAttribute : public Location {
441 enum extension_t { NONE, PROTOTYPE, ENCODE, DECODE, PORT_API, // 0-4
442 PORT_TYPE_USER, PORT_TYPE_PROVIDER, ERRORBEHAVIOR, ANYTYPELIST, // 5-8
443 ENCDECVALUE, VERSION, VERSION_TEMPLATE, REQUIRES, REQ_TITAN, // 9-13
444 TRANSPARENT, PRINTING // 14-15
447 /// Constructor for the PROTOTYPE type (convert, fast, backtrack, sliding)
448 ExtensionAttribute(Def_Function_Base::prototype_t p)
449 : Location(), type_(PROTOTYPE), value_()
454 /// Constructor for the ENCODE/DECODE type
455 ExtensionAttribute(extension_t t, Type::MessageEncodingType_t met,
457 : Location(), type_(t), value_()
459 if (type_ != ENCODE && type_ != DECODE)
460 FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
461 value_.encdec_.mess_ = met;
462 value_.encdec_.s_ = enc_opt; // may be NULL
465 /// Constructor for the ERRORBEHAVIOR type
466 ExtensionAttribute(ErrorBehaviorList *ebl)
467 : Location(), type_(ERRORBEHAVIOR), value_()
469 if (ebl == NULL) FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
473 /// Constructor for the PRINTING type
474 ExtensionAttribute(PrintingType *pt)
475 : Location(), type_(PRINTING), value_()
478 FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
483 /// Constructor for the PORT_API type (internal or address)
484 ExtensionAttribute(PortTypeBody::TestPortAPI_t api)
485 : Location(), type_(PORT_API), value_()
490 /// Constructor for the PORT_TYPE_PROVIDER and TRANSPARENT type
491 ExtensionAttribute(extension_t type)
492 : Location(), type_(type), value_()
495 case PORT_TYPE_PROVIDER:
499 FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
503 /// Constructor for the USER type
504 ExtensionAttribute(Reference *ref, TypeMappings *in, TypeMappings *out)
505 : Location(), type_(PORT_TYPE_USER), value_()
507 if (in == NULL && out == NULL) // one may be null but not both
508 FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
509 value_.user_.ref_ = ref;
510 value_.user_.inmaps_ = in;
511 value_.user_.outmaps_ = out;
514 /// Constructor for the ANYTYPELIST type
515 ExtensionAttribute(Types *t)
516 : Location(), type_(ANYTYPELIST), value_()
518 if (t == NULL) FATAL_ERROR("ExtensionAttribute::ExtensionAttribute()");
519 value_.anytypes_ = t;
522 /** Constructor for the ENCDECVALUE type
524 * @param in "in" type mappings
525 * @param out "out" type mappings
526 * @note at most one out of \a in and \a out may be NULL
528 ExtensionAttribute(TypeMappings *in, TypeMappings *out)
529 : Location(), type_(ENCDECVALUE), value_()
531 if (in == NULL && out == NULL)
532 FATAL_ERROR("ExtensionAttribute::ExtensionAttribute");
533 value_.encdecvalue_.inmaps_ = in;
534 value_.encdecvalue_.outmaps_ = out;
537 /** Constructor for the VERSION type
539 * @param ver contains the unparsed version
540 * (a string according to the template "RnXnn")
542 * Parses \p ver. If parsing is successful, the ExtensionAttribute
543 * becomes responsible for \p ver, otherwise the caller has to free it.
545 ExtensionAttribute(const char* ABCClass, int type_number, int sequence,
546 int suffix, Identifier *ver);
548 /** Constructor for the REQUIRES type
550 * @param mod contains the module name
551 * @param ver contains the unparsed version
552 * (a string according to the template "RnXnn")
554 * Parses \p ver. If successful, ExtensionAttribute becomes responsible
555 * for both (stores \p mod and deletes \p ver).
556 * If unsuccessful, freeing the identifiers remains the caller's duty.
558 ExtensionAttribute(Identifier *mod, const char* ABCClass, int type_number,
559 int sequence, int suffix, Identifier *ver);
561 /** Constructor for the REQ_TITAN type or the VERSION_TEMPLATE type
563 * @param et either REQ_TITAN or VERSION_TEMPLATE
564 * @param ver contains the unparsed version
565 * (a string according to the template "RnXnn" for REQ_TITAN
566 * or exactly "RnXnn" - the template itself - for VERSION_TEMPLATE)
568 * Parses \p ver. If parsing is successful, the ExtensionAttribute
569 * becomes responsible for \p ver, otherwise the caller has to free it.
571 ExtensionAttribute(const char* ABCClass, int type_number, int sequence,
572 int suffix, Identifier* ver, extension_t et);
574 ~ExtensionAttribute();
576 /// Return the type of the attribute
577 extension_t get_type() const { return type_; }
581 * All these functions act as extractors: resource ownership is passed
582 * to the caller, and type is set to NONE. Therefore only one of these
583 * functions can be called during object's life, and only once!
586 /// Return the data for the anytype
587 /// @pre type_ is ANYTYPELIST, or else FATAL_ERROR
588 /// @post type_ is NONE
591 /// Return the data for the prototype (convert, fast, backtrack, sliding)
592 /// @pre type_ is PROTOTYPE, or else FATAL_ERROR
593 /// @post type_ is NONE
594 Ttcn::Def_Function_Base::prototype_t get_proto();
596 /// Return the data for the encode/decode attribute
597 /// @pre type_ is ENCODE or DECODE, or else FATAL_ERROR
598 /// @post type_ is NONE
599 void get_encdec_parameters(Type::MessageEncodingType_t &p_encoding_type,
600 string *&p_encoding_options);
602 /// Return the error behavior list
603 /// @pre type_ is ERRORBEHAVIOR, or else FATAL_ERROR
604 /// @post type_ is NONE
605 ErrorBehaviorList *get_eb_list();
607 /// Return the printing type
608 /// @pre type_ is PRINTING, or else FATAL_ERROR
609 /// @post type_ is NONE
610 PrintingType *get_printing();
612 /// Return the data for (internal or address)
613 /// @pre type_ is PORT_API, or else FATAL_ERROR
614 /// @post type_ is NONE
615 PortTypeBody::TestPortAPI_t get_api();
617 /// Return the data for the "user" attribute
618 /// @pre type_ is USER, or else FATAL_ERROR
619 /// @post type_ is NONE
620 void get_user(Reference *&ref, TypeMappings *&in, TypeMappings *&out);
622 /// Returns the in and out mappings
623 /// @pre type_ is ENCDECVALUE
624 void get_encdecvalue_mappings(TypeMappings *&in, TypeMappings *&out);
626 /** Return version information
628 * @pre type_ is REQUIRES, REQ_TITAN, VERSION or VERSION_TEMPLATE
630 * @param[out] product_number a string like "CRL 113 200"
631 * @param[out] suffix the /3
632 * @param[out] rel release
633 * @param[out] patch patch version
634 * @param[out] bld build number
635 * @return pointer to the identifier of the module; the caller must not free
637 Common::Identifier *get_id(char*& product_number, unsigned int& suffix,
638 unsigned int& rel, unsigned int& patch, unsigned int& bld, char*& extra);
644 * All pointers are owned by the object and deleted in the destructor.
647 Ttcn::Def_Function_Base::prototype_t proto_;
649 Common::Type::MessageEncodingType_t mess_;
652 ErrorBehaviorList *ebl_;
653 PortTypeBody::TestPortAPI_t api_;
656 TypeMappings *inmaps_;
657 TypeMappings *outmaps_;
660 TypeMappings *inmaps_;
661 TypeMappings *outmaps_;
665 Common::Identifier *module_;
666 char* productNumber_; ///< "CRL 113 200"
667 unsigned int suffix_; ///< The "/3"
668 unsigned int release_;///< release
669 unsigned int patch_; ///< patch
670 unsigned int build_; ///< build number
671 char* extra_; ///< extra junk at the end, for titansim
676 void check_product_number(const char* ABCClass, int type_number, int sequence);
677 void parse_version(Identifier *ver);
680 /** Container for ExtensionAttribute.
681 * Private inheritance means is-implemented-in-terms-of. */
682 class ExtensionAttributes : private vector<ExtensionAttribute> {
684 ExtensionAttributes() : vector<ExtensionAttribute>()
686 ~ExtensionAttributes();
687 void add(ExtensionAttribute *a);
689 ExtensionAttribute &get(size_t idx) const
691 return *vector<ExtensionAttribute>::operator[](idx);
694 /** Take over the elements of another container.
696 * @param other source container, will be emptied.
698 void import(ExtensionAttributes *other);
700 /// Return the number of elements
701 size_t size() const { return vector<ExtensionAttribute>::size(); }
706 #endif /* TTCNSTUFF_H_ */