SEQUENCE OF

---

The ASN.1 SEQUENCE OF type is converted into one of the following C/C++ types:

• A doubly-linked list structure (Asn1RTDList for C, or ASN1TSeqOfList, a class derived from Asn1RTDList, for C++)
  
• A structure containing an integer count of elements and a pointer to hold an array of the referenced data type (a dynamic array)
  
• A structure containing an integer count of elements and a fixed-sized array of the referenced data type (a static array)
  

The linked list option is the default for constructed types. An array is used for a sequence of primitive types. The allocation for the contents field of the array depends on how the SEQUENCE OF is specified in the ASN.1 definition. If a size constraint is used, a static array of that size is generated; otherwise, a pointer variable is generated to hold a dynamically allocated array of values. The decoder will automatically allocate memory to hold parsed SEQUENCE OF data values.

The type used for a given SEQUENCE OF construct can be modified by the use of a configuration item. The <storage> qualifier with the `dynamic' keyword can be used at the global, module, or production level to specify that dynamic memory (i.e., a pointer) is used for the array. The syntax of this qualifier is as follows:

	<storage>dynamic</storage>
 

The `list' keyword can also be used in a similar fashion to specify the use of a linked-linked structure to hold the elements:

	<storage>list</storage>
 

See the section entitled Compiler Configuration File for further details on setting up a configuration file.

Dynamic SEQUENCE OF Type

    ASN.1 production:     <name> ::= SEQUENCE OF <type>
 

    Generated C code:      typedef struct {
 
 			       int        n;
 
 			       <type>*    elem;
 
			     } <name>;
 

    Generated C++ code:	    typedef struct {
 
 			       int        n;
 
			       <type>*    elem;
 
			     } ASN1T_<name>;
 

Note that parsed values can be accessed from the dynamic data variable just as they would be from a static array variable; i.e., an array subscript can be used (ex: elem[0], elem[1]...).

Static (sized) SEQUENCE OF Type

    ASN.1 production:    <name> ::= SEQUENCE SIZE <len> OF <type>
 

    Generated C code:     typedef struct {
 
			      int        n;
 
			      <type>     elem[<len>];
 
		          } <name>;
 

    Generated C++ code:   typedef struct {
 
			      int        n;
 
			      <type>     elem[<len>];
 
		          } ASN1T_<name>;
 

List-based SEQUENCE OF Type

A doubly-linked list header type (Asn1RTDList) is used for the typedef if the list storage configuration setting is used (see above). This can be used for either a sized or unsized SEQUENCE OF construct. The generated C or C++ code is as follows:

          Generated C code:   typedef Asn1RTDList <name>;
 

          Generated C++ code: typedef ASN1TSeqOfList ASN1T_<name>;
 

The type definition of the Asn1RTDList structure can be found in the asn1type.h header file. The common run-time utility functions beginning with the prefix rtDList are available for initializing and adding elements to the list. See the Common Run-time Functions section for a full description of these functions.

In addition to the Asn1RTDList C structure and C functions, a C++ class is provided for linked list support. This is the ASN1CSeqOfList class. This class provides methods for adding and deleting elements to and from lists and an iterator interface for traversing lists. See the ASN1CSeqOfList section in the C++ Run-Time Classes area for details on all of the methods available in this class.

Generation of Temporary Types for SEQUENCE OF Elements

As with other constructed types, the <type> variable can reference any ASN.1 type, including other ASN.1 constructed types. Therefore, it is possible to have a SEQUENCE OF SEQUENCE, SEQUENCE OF CHOICE, etc.

When a constructed type or type that maps to a C structured type is referenced, a temporary type is generated for use in the final production. The format of this temporary type name is as follows:

	<prodName>_element
 

In this definition, <prodName> refers to the name of the production containing the SEQUENCE OF type.

For example, a simple (and very common) single level nested SEQUENCE OF construct might be as follows:

A ::= SEQUENCE OF SEQUENCE { INTEGER a, BOOLEAN b }

In this case, a temporary type is generated for the element of the SEQUENCE OF construct. This results in the following two equivalent ASN.1 types:

	A-element ::= SEQUENCE { INTEGER a, BOOLEAN b }
 

	A ::= SEQUENCE OF A-element
 

These types are then converted into the equivalent C or C++ typedefs using the standard mapping that was previously described.

SEQUENCE OF Type Elements in Other Constructed Types

Frequently, a SEQUENCE OF construct is used to define an array of some common type in an element in some other constructed type (for example, a SEQUENCE). An example of this is as follows:

	SomePDU ::= SEQUENCE {
 
	   addresses SEQUENCE OF AliasAddress, 
 
	   ...
 
	}
 

Normally, this would result in the addresses element being pulled out and used to create a temporary type with a name equal to "SomePDU-addresses" as follows:

	SomePDU-addresses ::= SEQUENCE OF AliasAddress
 

 
	SomePDU ::= SEQUENCE {
 
	   addresses SomePDU-addresses,
 
	   ...
 
	}
 

However, when the SEQUENCE OF element references a simple defined type as above with no additional tagging or constraint information, an optimization is done to cut down on the size of the generated code. This optimization is to generate a common name for the new temporary type that can be used for other similar references. The form of this common name is as follows:

	_SeqOf<elementProdName>
 

So instead of this:

	SomePDU-addresses ::= SEQUENCE OF AliasAddress
 

The following equivalent type would be generated:

	_SeqOfAliasAddress ::= SEQUENCE OF AliasAddress
 

The advantage is that the new type can now be easily reused if "SEQUENCE OF AliasAddress" is used in any other element declarations. Note the (illegal) use of an underscore in the first position. This is to ensure that no name collisions occur with other ASN.1 productions defined within the specification.

An example of the savings of this optimization can be found in H.225. The above element reference is repeated 25 different times in different places. The result is the generation of one new temporary type that is referenced in 25 different places. Without this optimization, 25 unique types with the same definition would have been generated.