Question

What are parameter maps and how do I use them.

Answer 1

Parameter maps are objects that store key-value pairs.

Example

In QIE we use them most commonly to combine like items. (OBX-5 values for  like segments)

Below is a list of basic commands:

// Create parameterMap

var parameterMap = qie.newParameterMap();

 

//Add or update a value in a parameter map

parameterMap.put('key', 'value');

 

//Get a value from a parameter map

parameterMap.get('key');

 

//Check if a value is in the paramter map

if (parameterMap.get('key') === null) {

   //value is not in parameterMap

   qie.debug('do something if the value is not in the map');

} else {

   //value is in parameterMap

   qie.debug('do something if the value is in the map');

}

Answer 2

Just as an example here is a sample JSON message that I will use to create a parameter map and then debug the parameter map keys and values.

Sample JSON:

{
  "attachments": [
    {
      "id": "111",
      "myDoc": "My first document"
    },
    {
      "id": "222",
      "myDoc": "My second document"
    },
    {
      "id": "333",
      "myDoc": "My third document"
    }
  ]
}

Sample Mapping Function:

// Initialize your map
var attachments = qie.newParameterMap();

var docId, myDoc;
// Add keys and values to your map
for (var i=1 ; i <= message.getCount('/attachments') ; i++) {
   docId = message.getNode('/attachments/['+i+']/id');
   myDoc = message.getNode('/attachments/['+i+']/myDoc');
   attachments.put(docId, myDoc);
}

qie.debug('attachments.size(): ' + attachments.size());

// Pull the data we just added back out from your map
var iterator = attachments.keySet().iterator();
while (iterator.hasNext()) {
   var docIdKey = iterator.next();
   qie.debug('docIdKey: ' + docIdKey);

   var myDocValue = attachments.get(docIdKey);
   qie.debug('myDocValue: ' + myDocValue);
}

Answer 3

ParameterMaps, channelCache, and messageCache in QIE are all key-value variables that let you store and retrieve data using a unique key name. The main difference between them is scope and syntax. channelCache stores values shared across the entire channel and is accessible throughout the interface; messageCache stores data specific values for a single message as it moves through the channel; and parameterMaps typically hold named key-value values within a given script or step. While channelCache and messageCache use function-style access like getValue(key) and setValue(key, value), parameterMaps use Java-style methods such as get(key) and put(key, value). Despite the differences in how they're accessed, all three are used to temporarily manage data in the form of key-value pairs during interface execution.

For a list a parameterMap Methods see Java Docs HashMap methods: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html?utm_source=chatgpt.com

Here is a table listing the popular HashMap (parameterMap) methods along with the QIE channelCache and messageCache functions.

Operation	parameterMaps (Methods)	channelCache & messageCache (Functions)
Check if key exists	map.containsKey("key")	channelCache.checkValueExists("key") messageCache.checkValueExists("key")
Get value	map.get("key")	channelCache.getValue("key") messageCache.getValue("key")
Set value	map.put("key", "value")	channelCache.setValue("key", "value") messageCache.setValue("key", "value")
Remove value	map.remove("key")	channelCache.removeValue("key")
Get as boolean	(Use cast or comparison logic)	channelCache.getBoolean("key", defaultValue)
Get as number	Number(map.get("key"))	channelCache.getNumber("key", defaultValue)
Get as date	Use map.get then parse with QIE date functions	channelCache.getDate("key", defaultValue)
Iterate over keys	map.keySet().toArray()
Get size	map.size()
Clear all entries	map.clear()
Contains a Key	map.containsKey(Object key)
Contains a Value	map.containsValue(Object value)
Remove All entries	map.clear()
Returns all key entries	map.keySet()
Returns all Value entries	map.valueSet()
Returns all keys and entries	map.entrySet()