RPMN is a definition of diagrams and associated human readable file formats allowing regulatory experts to describe and collaborate on regulatory artefacts as a machine readable requirements document.

Associated with these file formats is a UML model. This model describes classes, their attributes and relationships.

Technical users can use this model to programmatically generate solution skeletons in an executable language of there choice.

The same model can be used by technical developers who wish to create tools for editing and visualising RPMN.

Generating Solution Skeletons

It is possible to create software to read RPMN files and build concrete solutions such as:
  • Database Schemas
  • Function outlines in any programming language such as Python or Java
  • Workflow logic
  • Executable test that can be run in existing automated testing frameworks
To make this easy for technical developers we have a UML model which can describe the artefacts of RPMN such as data model and workflow.

This is inspired by the approach used in the BPMN standard from the OMG standards group which has a UML model (described in a cmof file here , although the RPMN model is much simpler)

RPMN's UML model can store all the structured information represented in the RPMN text files. Similarly BPMN's UML model can store all the structured information stored in BPMN files, although BPMN files are not easily human readable.

As part of Eclipse Free BIRD tools we have code that converts to/from the text format into an in-memory object tree using the classes defined in the UML format.

Having this in-memory representation of the files, allows any kind of manipulation/navigation/query/transformation/visualisation of the artefacts to create the skeleton of executable solutions.

These executable solutions can therefore always stay in synch with the machine readable requirements document, and lineage can built in also if required from requirement to executable code.

Creating RPMN Tools

The UML model can be used to create software to build tool support for the standard such as
  • Text editors for the file formats with auto-completion
  • Auto-creation of diagrams from the text formats
  • Visual and textual navigation of the artefacts
As part of Eclipse Free BIRD tools we have an example of this which uses the Eclipse Modelling Frameworks and its Sirius visualisation component to create diagrams. It also includes tooling in Python.

The link between text and UML model

As a very technical note, there is a grammar associated with the text file formats of RPMN.

The UML model is complete enough to store the items of the abstract tree of any text file written which follows that grammar.

We indicate how a file in the grammar can be translated to an object tree made of objects which are instances of the classes in the UML diagram.

When we have an object tree, this is a great starting point for generating visualisations, or other structures such as database schemas or Python/Java/Django classes. A common way to do this is with templating frameworks.

Eclipse Free BIRD tools provides an implementation which translates between text files following the RPMN grammar, and object trees in Java or Python

The UML Class diagrams and their documentation

Group Name Class Diagram Documentation
RPMN Data Model UML Class Diagram Documentation
RPMN Workflow UML Class Diagram Documentation
RPMN Report Generation UML Class Diagram Documentation
RPMN Business Requirements/Regulations UML Class Diagram Documentation
RPMN Tests UML Class Diagram Documentation
RPMN Module Management UML Class Diagram Documentation