View source for Datainterchange DSL

A general introduction and some high-level concepts for OSBP DSLs can be found in [[OSBP DSL Documentation]].

Please note that you can only make use of the Datainterchange DSL by downloading its packages (shown below on both Figure 1 and 2) from the [http://dev.osbee.org/free-download/ download section] of our [http://dev.osbee.org/home/ website].

==Purpose==

The Data Interchange DSL (datainterchange for short) is made for defining data exchange models that can be used to import data from various formats (CSV, XML, EDI, etc.), map the data to entities, store them into database, or export them back into other formats.

You only need to define the ''relationship'' between the file and the bean, not the import / export process themselves. Once defined, these models can be used in e.g. action DSL to define actions which, when triggered, execute the actual import / export process, which are generated automatically by the OSBP based on the model.

==Overview==

The Datainterchange DSL is currently to be found under both packages <code>org.eclipse.osbp.datainterchange.api</code> and <code>org.osbee.datainterchange</code>. While all the basic interfaces are defined inside the API package, in the latter one are all commercial features and components implemented such as configuration files and artifacts based on the Smooks framework.

[[File:DatainterchangeAPI.jpg|left|frame|''Figure 1: - Data Interchange API Project Structure.'']][[File:DatainterchangeCORE.jpg|center|frame|''Figure 2: - Data Interchange CORE Project Structure.'']]


As shown in Figure 3, the [DSL Inferrer] will generate various views and In/Export component according to model described by datainterchange DSL (and action DSL, in the case of ActionButtons). The action buttons, when clicked, will trigger their corresponding In/Export processes by putting [http://download.osbee.org/downloads/javadoc/osbee-master-clean/org.eclipse.osbp.xtext.datainterchange.feature/apidocs/ WorkerThread (Runnable)] jobs into the executor job pool within the TriggerView (prefixed with datainterchang name), buttons (and toolbar / menus containing them) are further included in the perspective.


[[File:Datainterchange.png|center|frame|''Figure 3: - Data Interchange Structure.'']]

==Data Interchange Grammar Definition==
[[File:SyntaxGraphDataInterchangeDSL.png|center|''Figure 4: - Syntax Graph Data Interchange DSL''|thumbnail|800px]]

==Data Interchange Model File==

Datainterchange DSL model files end with the <code>.data</code> extension. Data Interchange models may be split into several <code>.data</code> files, as long as they have the same package declaration.


===Reserved Keywords===
In the following we’ll dive deeper into the description and the usage of Datainterchange related and reserved keywords.

====import====
In the import section are all entities to be found - as full qualified names – that are currently used in the DSL.

<syntaxhighlight lang="java">

import ns net.osbee.sample.foodmart.entities.Mstore
import ns net.osbee.sample.foodmart.entities.Mwarehouse
import ns net.osbee.sample.foodmart.entities.Mregion

</syntaxhighlight>

Note that <code>ns</code> is a mandatory keyword (stands for "namespace") that comes after import for distinguishing the OS.bee internal namespaces and Java library namespaces. Wildcards are not supported, all names should be imported separately. Note that the import section will be imported/added automatically if they are used in the package, so you don't have to manually manage this section.

====package====

Datainterchange DSL model files must start with a package declaration. Packages are the root element of the DSL and should be defined as <code><ApplicationName>.datainterchange</code>, for example:

<syntaxhighlight lang="java">package net.osbee.sample.foodmart.datainterchanges { }</syntaxhighlight>

Data Interchange models may be split into several .data files, as long as they have the same package declaration, the interchanges will be available under this package name.

====titel====
With the keyword title you can give a name to the corresponding TriggerView dialog inside your application. For example, the definition of the same datainterchanges package from above with title "Data Interchange Example":

<syntaxhighlight lang="java">package net.osbee.sample.foodmart.datainterchanges title "Data Interchange Example" {}</syntaxhighlight>

This title will be translated based on locale.

You can get more details about the TriggerView in the section below.

====interchange====
The <code>interchange</code> keyword defines interchange units for entities in the package, it should be in the form of:

<syntaxhighlight lang="java">

interchange <InterchangeUnitName> [describedBy <description>] <EntityManagerMode> file <FileType> [<FileDetails>] beans {
  ...
}

</syntaxhighlight>

Where <code>InterchangeUnitName</code> being the name of the interchange unit; <code>describedBy</code> (optional) can be used to provide a short description string. <code>EntityManagerMode</code> being how the file should be handled (see section "persist, merge, remove" below), and after <code>file</code> keyword, you should specify the type of the source / target data file you would like to import from or export to, then the file path, and other details depends on the type.

The following example specifies an interchange that reads a CSV file under the specified path (note the forward slash as the path separator), delimited by semicolon, skip one line (the header), and treat the content as encoded in UTF-8:

<syntaxhighlight lang="java">

interchange CurrencyNames persist file
CSV "C:/data/ISOCurrencyCode20170101.csv" delimiter ";" skipLines 1 encoding "UTF-8"
beans {
  ...
}

</syntaxhighlight>

The <code>beans</code> keyword comes after all the file specification and starts a block of entity definitions, which will be covered in section "entity".

====describedBy====
With this keyword you can the optional description of an interchange unit as shown below. 

<syntaxhighlight lang="java">
interchange Currencies describedBy "european central bank currency exchange rates based on euro" persist … {

}
</syntaxhighlight>


====vectorName====
With the <code>vectorName</code> keyword followed by a string value you are able to define the name of the root element of both XML configuration files needed by Smooks. Please note that it also means that the first (root-)element of an XML-File filled with real data you would have exported via the application will be of the same name. 

Example:

<syntaxhighlight lang="java">

interchange Stores remove vectorName "stores" elementSize 83 file
	XML "C:/.../net.osbee.sample.foodmart/net.osbee.sample.foodmart.datainterchange/smooks-resources/stores.xml" beans {
		entity Mregion
		entity Mstore nodeName     "store"
		entity Mwarehouse
	}

</syntaxhighlight>


[[File:WithFreeMarkerJOMStoreImportVector.png|''Figure 11: Stores Tag - Import File'']]
[[File:WithFreeMarkerJOMStoreExportVector.png|''Figure 12: Stores Tag - Export File'']]
[[File:SampleStoreVectorData.png|''Stores Tag - Data File'']]

====persist, merge, remove====
These keywords define the purpose of the datainterchange unit and has a similar meaning as in the JPA's EntityManager class. Basically, <code>persist</code> will insert the data records into database, <code>merge</code> will update existing data record, or insert new one if necessary, <code>remove</code> will remove the record if it could be found in database.

Example persist:
<syntaxhighlight lang="java">
interchange EDIOrders describedBy "Orders" persist file
XML "C:/data/orders.xml"
beans {
  ...
}
</syntaxhighlight>

Example merge:
<syntaxhighlight lang="java">
interchange Stores merge file
XML "C:/data/stores.xml"
beans {
  ...
}

</syntaxhighlight>

Example remove:
<syntaxhighlight lang="java">
interchange Storesremove remove file
XML "C:/data/stores_remove.xml"
beans {
  ...
}
</syntaxhighlight>

====file====
With the keyword file you are able to set the file format of the files you intent to process with you interchange unit.

<syntaxhighlight lang="java">interchange <SampleInterchangeUnitName> <EntityManagerMode> file <FileNameFormat> {}</syntaxhighlight>


The current supported file formats are CSV, EDI and XML followed by the name of the file you want to process, given its full path location in the system.
Example 1:   <syntaxhighlight lang="java">interchange SampleInterchangeUnit1 merge file CSV "C:/temp/testFile.csv" {}</syntaxhighlight>
Example 2:   <syntaxhighlight lang="java">interchange SampleInterchangeUnit2 persist file XML "C:/temp/testFile.xml" {}</syntaxhighlight>
Example 3:   <syntaxhighlight lang="java">interchange SampleInterchangeUnit3 merge file EDI "C:/temp/testFile.edi" {}</syntaxhighlight>

After choosing the file format you can either give the file name as a String value in a double quote "..." as shown here above, or press Ctrl+Space to get via the content assist the option of opening a File Chooser/Picker to specify the file you want to work with.

[[File:FileChooser.jpg|center|frame|''Figure 5: File Chooser'']]


Please note that you can also change the path(?) of the file to process on runtime by selecting a new file.

====mapByAttribute====

The <code>mapByAttribute</code> keyword is an XML-specific keyword that turns on the automatic attribute mapping. When enabled, datainterchange will detect if the value being mapped is from an attribute. For example, the 'USD' value in the following XML file comes from the attribute 'currency' of the element 'Cube':

<syntaxhighlight lang="xml">

<Cube currency='USD' rate='1.3759'/>

</syntaxhighlight>

while in the following XML file, the same value is encapsulated in the element 'currency':

<syntaxhighlight lang="xml">

<Cube>
 <currency>USD</currency>
 <rate>1.3759</rate>
</Cube>

</syntaxhighlight>

When <code>mapByAttribute</code> is present, datainterchange will automatically decide that a query in the form like <code>'/Cube/currency'</code> will also catch the value from attribute. Without it, the query will have to put an <code>'@'</code> symbol in front of the attribute name, i.e. <code>'/Cube/@currency'</code>.

====elementSize====
With the keyword <code>elementSize</code> followed by an integer, the user can set the estimated average size of the elements in bytes. Since the underlying API can not know the size of an element before it is processed, this value can be supplied as a guide value to be used for estimating the import / output progress based on how much bytes have been processed.

Example:

<syntaxhighlight lang="java">
interchange EDIOrders describedBy "edi orders" persist elementSize 50 file EDI "C:/data/orders.edi" beans {
  ...
}
</syntaxhighlight>

Defines an average estimated element size of 50 bytes.

====delimiter====

The <code>delimiter</code> is a CSV format-specific keyword, which defines the character to use in the CSV file to set the delimiter/separation character between different values. Default value is "," (comma).

Example:

<syntaxhighlight lang="java">
interchange CurrencyNames persist file
CSV "C:/data/ISOCurrencyCodes081507.csv" delimiter ";" ... {
  ...
}
</syntaxhighlight>

will set the delimiter of the CSV file to ";".

====skipLines====
This is a CSV format-specific keyword. Using <code>skipLines</code> followed by an integer, the user can specify the number of lines to be skipped from the beginning in the processing of the selected file, this can be used to skip headers.

Example:

<syntaxhighlight lang="java">

interchange CurrencyNames persist file CSV "C:/data/ISOCurrencyCodes081507.csv" ... skipLines 1 encoding "UTF-8" {
   ...
}

</syntaxhighlight>

will skip the first line of the CSV file.

====report====

If a datainterchange unit is defined with the <code>report</code> keyword, a report will be generated for data conversions. The report file is generated by Smooks, lies under <code>/smooks</code> output directory of the datainterchange bundle, and has a name in the form like <code><DataInterChangeName>-input.xml</code> for input processes, and <code><DataInterChangeName>-output.xml</code> for output processes. '''Note: turn on report will have an impact performance.'''

====indent====

The <code>indent</code> is a CSV-format specified keyword which adds indentation character data to the generated event stream. This simply makes the generated event stream easier to read in its serialized form and generally should only be used in testing.

====quoteCharacter====

The <code>quoteCharacter</code> is a CSV format-specific keyword, which defines the character to use in the CSV file to identify values.

====encoding====
With the keyword '''enconding''' followed by the encoding name as a string value you are able to specify the valid encoding of the file content.

Example 1:   <syntaxhighlight lang="java">interchange SampleInterchangeUnitName merge elementSize 50 file CSV "C:/temp/testFile.csv" delimiter ";" skipLines 1 encoding "UTF-8"{}</syntaxhighlight>
Example 2:   <syntaxhighlight lang="java">interchange SampleInterchangeUnitName remove elementSize 50 file CSV "C:/temp/testFile.csv" delimiter ";" skipLines 1 encoding "GB18030"{}</syntaxhighlight>
Example 3:   <syntaxhighlight lang="java">interchange SampleInterchangeUnitName persistelementSize 50 file CSV "C:/temp/testFile.csv" delimiter ";" skipLines 1 encoding "ISO-2022-JP"{}</syntaxhighlight>

====beans====

The keyword <code>beans</code> starts the series of entities, see example below. The name "bean" comes from the internal entities called JavaBean, which act as data containers.

====entity====
With the keyword '''entity''' the user can specify the entity on which the interchange unit is based on.

Example:

<syntaxhighlight lang="java">

interchange Stores merge elementSize 83 file
XML "C:/data/stores.xml" beans {
	entity Mregion
	entity Mstore
	entity Mwarehouse
}

</syntaxhighlight>

For more information about the entities, review the corresponding section below.

====Entity====

With the <code>entity</code> keyword followed by a fully qualified name, the user can specify the mapping between a source data file and a data-containing entity. The behavior of the mapping can be further fine-tuned with the keywords discussed below. While these keywords can theoretically be combined all together and create very complicated behavior, they are normally used in a simple and straight forward way.

The general form of <code>entity</code> keywords is:

<syntaxhighlight>
entity <ID>
    [nodeName <node-name>]
    [createOn <element-map>]
    [marker <property-name>]
    [expression '{' <expressions> '}'] 
    [lookup '{' <lookup-rules> '}']
    [format '{' <formats> '}']
    [mapping '{' <mappings> '}']
    [keys '{' <lookup-keys> '}']
;
</syntaxhighlight>

The order of the keywords is fixed, i.e. they are all optional, but must appear in the given order.

=====nodeName=====

The <code>nodeName</code> keyword followed by a string specifies the name (alias) of its corresponding element inside an (XML) input/output configuration file. This name is used to identify entities within an XML file using the [http://freemarker.org/docs/pgui_datamodel.html NodeModel of Freemarker] instead of using the standard Java Object Model name. For example:

<syntaxhighlight lang="java">

interchange Stores remove vectorName "stores" elementSize 83 file
	XML "C:/.../net.osbee.sample.foodmart/net.osbee.sample.foodmart.datainterchange/smooks-resources/stores.xml" beans {
		entity Mregion nodeName    "region"
		entity Mstore nodeName     "store"
		entity Mwarehouse nodeName "warehouse" 
	}

</syntaxhighlight>

will create a Smooks configuration file in which the structure of the output data file (XML) to be generated will be the same as declared inside the beans expression, but also
will also contain the string sprecified  after the keywords.


[[File:WithFreeMarkerNodeModelStoreImport.png|600px|thumb|left|''Figure 6: Store-import.xml with NodeModel'']] 

[[File:WithFreeMarkerNodeModelStoreExport.png|900px|thumb|center|''Figure 7: Store-export.xml with NodeModel'']]


The use of this keyword gives you the flexibility of naming entities using aliases in order to match each third part system descriptions. The main difference here with the latter is that the names of the entities are used inside both configuration files. By omitting the definition of both aliases ''region'' and ''warehouse'' like shown below, we obtain slightly divergent but very different contents than the ones from above.

For example:

<syntaxhighlight lang="java">

interchange Stores remove vectorName "stores" elementSize 83 file
	XML "C:/.../net.osbee.sample.foodmart/net.osbee.sample.foodmart.datainterchange/smooks-resources/stores.xml" beans {
		entity Mregion
		entity Mstore nodeName     "store"
		entity Mwarehouse
	}

</syntaxhighlight>


[[File:WithFreeMarkerJavaObjectModelStoreImport.png|700px|thumb|left|''Figure 8: Store-import.xml (normal) with Java Object Model'']] 
[[File:WithFreeMarkerJavaObjectModelStoreExport.png|900px|thumb|center|''Figure 9: Store-export.xml (normal) with Java Object Model'']]



Please note that the declaration order of each node names matters and has to be compliant with the designated entities structures.

=====createOn=====

The <code>createOn</code> keyword followed by a string specifies on which input element should an entity to be created. For example:

<syntaxhighlight lang="java">

entity Mcurrency createOn "/Envelope/Cube/Cube/Cube" ... {
    ...
}

</syntaxhighlight>

will create an <code>Mcurrency</code> entity when encountering <code>/Envelope/Cube/Cube</code> in the source data file.

=====marker=====

With <code>marker</code> keyword optionally followed by a property-name, the user can set the data to be imported to have an additional property under the given name whose value set to 1, while updating the existing data to have this property having value 0. This could be useful to identify the most recent import of some periodically updated data. For example:

<syntaxhighlight lang="java">

entity McurrencyStream createOn "/Envelope/Cube" marker latest expression {
	...
}

</syntaxhighlight>

will make the entity <code>McurrencyStream</code> to have a property "<code>latest</code>", which is to be set to 1 for the most recently imported data.

=====expression=====

With an <code>expression { ... }</code> block, the user can define expressions that assign certain value to an entity property. These expressions are of two types, the first one is:

<syntaxhighlight lang="java">

  assign <id> with <value> as <type>

</syntaxhighlight>

this will assign the property <code>id</code> with the value of <code>value</code>, in type of <code>type</code>. The <code>value</code> may be one of the following:

* <code>NowDate</code>: the date of now (the time point of action)
* <code>StartDate</code>: the date when the process started
* <code>UniversallyUniqueIdentifier</code>: an UUID

and <code>type</code> may be one of the following:

* <code>Date</code>: the value of NowDate or StartDate will be in date format
* <code>Milliseconds</code>: the value of NowDate or StartDate will be in millisecond
* <code>Nanoseconds</code>: the value of NowDate or StartDate will be in nanosconds
* <code>Random</code>: the value of UUID will be random
* <code>ExecuteContext</code>: the value of UUID will be unique for the execute context

Note that the <code>Random</code> and <code>ExecuteContext</code> should be only combined with <code>UniversallyUniqueIdentifier</code>, while the other types should be only combined with <code>NowDate</code> or <code>StartDate</code>.

Example:

<syntaxhighlight lang="java">
  entity McurrencyStream createOn "/Envelope/Cube" marker latest expression {
      assign importDate with NowDate as Date
  }
</syntaxhighlight>

will assign the <code>importDate</code> as the current date in <code>Date</code> format.

The other type of expression has the form:

<syntaxhighlight lang="java">

  copy <target-property> from <entity-name> property <from-property>

</syntaxhighlight>

which will copy the value of <code>from-property</code> from the <code>entity-name</code> to <code>target-property</code>.

Example:

<syntaxhighlight lang="java">

  entity Mcurrency createOn "/Envelope/Cube/Cube/Cube" expression {
      copy currencyDate from McurrencyDay property ratingDate
  }

</syntaxhighlight>

will copy the value of <code>ratingDate</code> from <code>McurrencyDay</code> entity to <code>currencyDate</code>.

=====format=====

With a <code>format { ... }</code> block, the user can define the format of the entity property being converted. A <code>format</code> block can have more than one format definitions, in the following format:

<syntaxhighlight lang="java">

    format {
        for <property> coding <format-string> [locale <locale-string>]
        ...
    }

</syntaxhighlight>

For example,

<syntaxhighlight lang="java">

    entity McurrencyDay createOn "/Envelope/Cube/Cube" format {
        for ratingDate coding "yyyy-MM-dd"
    }

</syntaxhighlight>

will convert the <code>"/Envelope/Cube/Cube"</code> data to <code>ratingDate</code> property of <code>McurrencyDay</code> in format <code>"yyyy-MM-dd"</code>, where

<syntaxhighlight lang="java">

    entity EDIOrderHeader createOn "/Order/header" format {
        for hdrDate coding "EEE MMM dd HH:mm:ss zzz yyyy" locale "en_US"
    }

</syntaxhighlight>

will format the <code>hdrDate</code> in format <code>"EEE MMM dd HH:mm:ss zzz yyyy"</code> with English locale, i.e. the month and weekday names will be in English.

====keys -> key====

With a <code>key { ... }</code> block, the user can define the keys needed for entity lookup.

====mapping -> map...to====

====lookup -> for...on...createOn...with...cacheSize...mapTo====

====marker -> makerPath -> markerEntity | markedBy ====

==Enums==

'''Enums''' are an abstraction of the Java <code>enum</code>. They compile to <code>enum</code> classes and can be used as properties in entities and beans.

[[File:Entity-18.png|center|frame|''Figure 10: Defining <code>enums</code> allows using them as variables in entities and beans.'']]

The Datainterchange DSL provides 3 Enum types that can be used: ''PredefinedBeanEnum'', ''PredefinedBeanTypeEnum'', ''ProgessBarStyleEnum'' and the ''EntityManagerMode''.


===PredefinedBeanEnum===
Contains the definition of the values '''<code>now(NowDate) | start(StartDate) | UUID(UniversallyUniqueIdentifier)</code>''' used for ...
===PredefinedBeanTypeEnum===
Contains the definition of the values '''<code>Date(Date) | Millis(Milliseconds) | Nanos(Nanoseconds) | random(Random) | execContext(ExecuteContext)</code>''' used for ...
===ProgessBarStyleEnum===
Contains the definition of the values '''<code>none(none) | normal(normal) | important(important)</code>''' used for setting the style of a progressbar.
===EntityManagerMode===
Contains the definition of the values '''<code>persist(persist) | merge(merge) | remove(remove)</code>''' used for specifying the Entity Manager Mode in order to decide how to manage data inside a database before committing any changes.

==Smooks Configuration and Settings File==

Whenever the model is saved, the IDE will do three things:

* generate Java classes,
* generate Smooks configuration files for both import and export, and
* generate a config file to modify the import and export paths.

===Smooks Configuration File===

The OS.bee implementation of Data Interchange interface is based on Smooks. Smooks is a Java framework for processing XML and non XML data (CSV, EDI, Java etc) by mapping data to JavaBeans, which can later be persisted, enriched (merge with existing data from other source), or converted and exported into other formats.

Smooks relies on a proper configuration file for the import / export processes. These configuration files are generated by the Datainterchange DSL automatically. Here is a brief introduction of how the generated Smooks configuration files work.

When a data import / export Smooks instance is initiated, it will be supplied with the generated config file. This file defines the actions to be performed upon certain events during the SAX parsing process. Here is an example:
<syntaxhighlight lang="xml" line='line'>
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd" xmlns:csv="http://www.milyn.org/xsd/smooks/csv-1.2.xsd" xmlns:dao="http://www.milyn.org/xsd/smooks/persistence-1.2.xsd" xmlns:jb="http://www.milyn.org/xsd/smooks/javabean-1.2.xsd">
    <jb:bean beanId="McurrencyNameStream" class="net.osbee.sample.foodmart.entities.McurrencyNameStream" createOnElement="/csv-set">
        <jb:expression property="importDate">PTIME.nowDate</jb:expression>
        <jb:wiring beanIdRef="McurrencyName" setterMethod="addToCurrencyNames"/>
    </jb:bean>
    <jb:bean beanId="McurrencyName" class="net.osbee.sample.foodmart.entities.McurrencyName" createOnElement="/csv-set/csv-record">
        <jb:value data="/csv-set/csv-record/isoCode" decoder="String" property="isoCode"/>
        <jb:value data="/csv-set/csv-record/name" decoder="String" property="name"/>
        <jb:value data="/csv-set/csv-record/countries" decoder="String" property="countries"/>
    </jb:bean>
    <csv:reader fields="isoCode,name,countries" indent="false" separator=";" skipLines="1"/>
    <params>
        <param name="stream.filter.type">SAX</param>
        <param name="inputType">input.csv</param>
        <param name="smooks.visitors.sort">false</param>
        <param name="input.csv" type="input.type.actived">C:/git/net.osbee.sample.foodmart/net.osbee.sample.foodmart.datainterchange/smooks-resources/ISOCurrencyCodes081507.csv</param>
    </params>
</smooks-resource-list>
</syntaxhighlight>

Further informations on the Smoooks framework are available and can be reviewed in its [http://www.smooks.org/guide documentation] you will find on the [http://www.smooks.org/index official website].

===Path Config File===

The file is interpreted using the Properties xml im- and export method and looks like this:

<syntaxhighlight lang="java">

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>dataInterchange file URLs</comment>
<entry key="EmployeesDepartment-import">C:/myimports/employeesdepartment.xml</entry>
<entry key="EmployeesDepartment-export">C:/myexports/employeesdepartment.xml</entry>
</properties>

</syntaxhighlight>

By default this file is named like the title in the dataInterchange package and extended by "Config" and has the extension "xml":

<code>package net.osbee.sample.foodmart.datainterchanges title "DataInterchange" {</code>

leads to the filename:

<code>DataInterchangeConfig.xml</code>

and is stored platform independently in the current user's home directory under the subdirectory ".osbee".

An administrator must receive this configuration file with the application, modify it and place it somewhere on the application server. The path to this configuration file must be supplied in the product's preferences (<code>org.eclipse.osbp.production.prefs</code>):

<code>datainterchange/datainterchangeConfiguration=c\:\\DataInterchangeConfig.xml</code>

The path value obviously depends on the operating system.

==TriggerView & Executorservice==

==Annotations==

==Comments==

== Copyright Notice ==
{{Copyright Notice}}