When you have input metadata in which the first two fields are firstname and lastname, each of these two fields is mapped to its counterpart on the output. Such output firstname field may even be the fifth and lastname field be the third, but those two fields of the input will be mapped to these two output fields .

Even if input metadata had more fields and output metadata had more fields, such fields would not be mapped to each other if there did not exist a field with the same name as one of the input fields (independently on the mutual position of the fields in corresponding metadata).

The mapping must be defined at the end of a function (the transform() function, in this case) and it may only be followed by one return statement.

Since we need that the return statement return the number of output port for each record, we must assign it the corresponding value before the mapping is defined.

Note that the mappings will be performed for all records. In other words, even when the record will go to the output port 1, also the mapping for output port 0 will be performed, and vice versa.

Moreover, mapping consists of individual fields, which may be complicated in case there are many fields in a record. In the next examples, we will see how this can be solved in a better way.

//#TL
          
// declare variable for returned value (number of output port) 
int retInt;

function transform() {	
     // create returned value whose meaning is the number of output port.
     if ($0.field3 < 5) retInt = 0; else retInt = 1;

     // define mapping for all ports and for each field 
     // (each field is mapped separately)
     $0.field1 := uppercase($0.field1);
     $0.field2 := $0.field2;
     $0.field3 := $0.field3;	
     $1.field1 := uppercase($0.field1);	
     $1.field2 := $0.field2;
     $1.field3 := $0.field3;	

     // return the number of output port
     return retInt
}

The mapping must also be defined at the end of a function (the transform() function, in this case) and it may only be followed by one return statement.

Since we need that return statement returns the number of output port for each record, we must assign it the corresponding value before the mapping is defined.

Note that mappings will be performed for all records. In other words, even when the record will go to the output port 1, also the mapping for output port 0 will be performed, and vice versa.

However, now the mapping uses wild cards at first, which passes the records unchanged to the output, but the first field is changed below the mapping with wild cards.

This is useful when there are many unchanged fields and a few that will be changed.

//#TL
          
// declare variable for returned value (number of output port) 
int retInt;

function transform() {	
     // create returned value whose meaning is the number of output port.
     if ($0.field3 < 5) retInt = 0; else retInt = 1;

     // define mapping for all ports and for each field 
     // (using wild cards and overwriting one selected field)	
     $0.* := $0.*;
     $0.field1 := uppercase($0.field1);
     $1.* := $0.*;
     $1.field1 := uppercase($0.field1);	

     // return the number of output port
     return retInt
}

The mappings must be defined at the end of a function (two separate functions, by one for each output port).

Moreover, mapping uses wild cards at first, which passes the records unchanged to the output, but the first field is changed below the mapping with wild card. This is of use when there are many unchanged fields and a few that will be changed.

//#TL
          
// define mapping for each port and for each field 
// (using wild cards and overwriting one selected field) 
// inside separate functions
function mapToPort0 () { 
     $0.* := $0.*;
     $0.field1 := uppercase($0.field1);
}

function mapToPort1 () { 
     $1.* := $0.*;
     $1.field1 := uppercase($0.field1);
}

// use mapping functions for all ports in the if statement
function transform() {
     if ($0.field3 < 5) { 
          mapToPort0(); 
          return 0
     }
     else {
          mapToPort1();
          return 1
     }
}

Mapping is defined in two separate user-defined functions. The first of them maps the first input field to both output ports. The second maps the other fields to both output fields.

Note that these functions now accept one input parameter of string data type - valueString.

In the transformation, a CTL record varibale is declared. Input record is mapped to it and the record is used in the foreach loop.

Remember that the number of output port is defined in the if that follows the code with the mapping functions.

//#TL
          
string myString;
string newString;
string valueString;

// declare the count variable for counting string fields
int count;

// declare CTL record for the foreach loop
record (@0) CTLRecord;

// declare mapping for field 1
function mappingOfField1 (valueString) { 
     $0.field1 := valueString;
     $1.field1 := valueString;
}

// declare mapping for field 2 and 3
function mappingOfField2and3 (valueString) { 
     $0.field2 := valueString;
     $1.field2 := valueString;
     $0.field3 := $0.field3;
     $1.field3 := $0.field3;
}

function transform() {

     // count is initialized for each record
     count = 0;

     // input record is assigned to CTL record
     CTLRecord = @0;

     // value of each string field is changed to upper case letters
     foreach (myString : CTLRecord) {
          newString = uppercase(myString);
          // count variable counts the string fields in the record
          count++;

          // mapping is used for fields 1 and the other fields - 2 and 3
          switch (count) {
               case 1 : mappingOfField1(newString); 
               case 2 : mappingOfField2and3(newString); 
          }
     }

     // output port is selected based on the return value
     if($0.field3 < 5) return 0 else return 1
}