<cartridge/>

The <cartridge/> element is the root of the cartridge descriptor and also gives a name to the cartridge.

<property/>

The <property/> element is used to specify property references for a cartridge. The values of these references are defined within the AndroMDA Configuration namespace elements. For example, if you have the property reference securityEnabled defined (i.e. <property reference="securityEnabled"/>), then the framework will expect the client to define a namespace property named securityEnabled when this cartridge is run. This property (and it's value) will then be made available to the template during processing.

<templateObject/>

The <templateObject/> element is used to specify helper objects within your cartridge. These must have a default constructor and must be a class available to your cartridge (either internally or externally).

You can also define property references within your template objects. In order to do this, you'll need to make sure you have a java bean setter matching each reference name. For example:

<templateObject name="hibernateUtils" className="org.andromda.cartridges.hibernate.HibernateUtils">
    <property reference="hibernateVersion"/>
</templateObject>
          

<template/>

The <template/> element is used to describe the template that will be used to generate source code.

<modelElements/>

The <modelElements/> element is nested directly within the <template/> element, it is used to instruct each <template/> on which model elements it should process. The <modelElements/> encloses the <modelElement/>.

<modelElement/>

The <modelElement/> is nested directly within the <modelElements/>, it is used to within the <modelElements/> to instruct each <template/> on which model elements it should process. For example, using this element you can specify both stereotypes and or metafacade types (and optionally the metafacade's properties).

...
<template
    path="templates/ejb-jar.xml.vsl"
    outputPattern="ejb-jar.xml"
    outlet="ejb-jar-descriptor"
    overwrite="true"
    outputToSingleFile="true">
    <modelElements variable="ejbs">
        <modelElement stereotype="Entity" variable="entityEjbs"/>
        <modelElement stereotype="Service" variable="sessionEjbs"/>
    </modelElements>
</template>
...
             

<type/>

The <type/> element is nested directly within a <modelElement/>, it is used to specify in what metafacade type the meta model element MUST be wrapped in order to be made available to a <template/>. For example, this could make each metafacade of type org.andromda.cartridges.webservice.metafacades.WebService available to a template:

...
<template
    path="templates/webservice/wsdl/wrapped-wsdl.vsl"
    outputPattern="{0}/{1}.wsdl"
    outlet="wsdls"
    overwrite="true">
    <modelElements variable="service">
        <modelElement>
            <type name="org.andromda.cartridges.webservice.metafacades.WebService"/>
        </modelElement>
    </modelElements>
</template>
...

<property/>

There are optional nested <property/> elements that may be placed directly within a <type/>. These properties are used for two purposes:

1. They are used to specify what valid properties the metafacade type must have (meaning non-null in case of a non-collection property or having at least one value in case of a collection property) or be equal to, in order for the model element to be made available to a <template/>
2. They're used to define additional elements that should be processed by a template.

Here's an example of the first and most common use, the following would make each model element with a metafacade of type org.andromda.core.uml.ClassifierFacade with the property enumeration equal to true available to a template:

...
<modelElements variable="enumeration">
    <modelElement>
        <type name="org.andromda.metafacades.uml.ClassifierFacade">
            <property name="enumeration">true</property>
        </type>
    </modelElement>
</modelElements>
...

Here's example of the second use (note that the property still must be valid in order to be made available to the template, in the case of this example that would mean the navigableConnectingEnds collection has at least one or more elements). The following would process a template for each associationEnd in the collection of navigableConnectingEnds on the entity. It will also make the entity variable (in addition to the associationEnd variable) available to each processed template. This is useful in cases where you have a property on your metafacade that is something other than one or more metafacade instances; doing something like this allows you to process those related objects within a template.

...
<modelElements variable="entity">
    <modelElement>
        <type name="org.andromda.metafacades.uml.Entity">
            <property name="navigibleConnectingEnds" variable="associationEnd"/>
        </type>
    </modelElement>
</modelElements>
...

Another VERY useful application of these properties, is to determine when and when not to output a file (for example you may only want to output a WSDL for a web service that has at least one exposed operation), so in that case you'd map a nested property checking for the exposed operations like the example directly below:

...
<modelElements variable="services">
    <modelElement>
        <type name="org.andromda.cartridges.webservice.metafacades.WebService">
            <property name="exposedOperations"/>
        </type>
    </modelElement>
</modelElements>
...

Its important to note that you are NOT required to specify a property's value when using the nested <property/>, if you do not specify the value attribute, then the properties needs to be valid, meaning the following things: it's non-null, it has one or more elements if its a collection type property, or has a value of true if a boolean type.

<resource/>

The <resource/> element is used to process files inside the cartridge without passing them through any template engine. They will simply be copied.

This example would copy all .jar files to the location defined by the resource outlet within the lib directory.

<resource
    path="**/*.jar"
    outputPattern="lib/{0}"
    outlet="resources"
    overwrite="false"/>