CAST

About

• Introduction
• Platform overview
• Applications
• Download
• License

Platform development

• Development team
• Source code
• Mailing lists

CAST platform is built upon Eclipse RCP, which provides an environment for building stand-alone, extensible applications. The platform itself defines core elements, persistence layer as well as general-purpose mechanism and tools. On the top of the platform, various extensions can be defined such as editors for data visualization and editing, domain models and analysis tools. End-user applications are created by defining a product, which contains features included in the application and optional branding elements.

The below diagram shows a layer model of applications built upon the CAST platform.

CAST is built upon Eclipse Rich Client Platform (Eclipse RCP), which is a platform for creating modular Java applications built from components called Eclipse plug-ins. Current implementation implements OSGi core specification where components (called bundles) are provided in JAR files containing a descriptor specifying bundle details (e.g. name, version), executable code and other resources (e.g. images, localization files). Dependencies between components are realized at the level of Java packages -- a bundle can define imported packages (required to resolve the bundle and provided by other bundles), exported packages (provided for other bundles) and private packages (not visible outside the bundle). It is also possible to define dependencies at bundle level which means that a bundle requires all packages exported by the other one.

Eclipse Platform extends OSGi model by the idea of extension points and extensions that allows for avoiding tight dependencies between components. A plug-in (called host plug-in) by defining an extension point declares that its functionality can be extended in some place. On the other hand, the other plugin (called extender plugin) extends the functionality of the first one, by providing an extension. An extension point is identified by an id (by convention in Java package naming style) and usually contains data required to connect a specified extension (e.g. Java interface which specifies the API, some configuration data).

Eclipse Platform provides a set of standard extension points which are mainly connected to UI (e.g. the org.eclipse.ui plug-in defines org.eclipse.ui.editors extension point which allows for adding new editors). Indeed, the systems based on this architecture define a set of extension points where they can be extended by other plug-ins, usually provided by external vendors. Optional components supporting applications development and utilities for software upgrades and built-in help mechanism is provided in Eclipse Platform as well.

The platform itself provides a basic set of components which define main interfaces, provide access to the services and describe the main points of platform extensions. The platform is divided into: core elements, persistence layer and general-purpose mechanisms and tools.

The core elements provide elements required in all applications built based on the platform. The most important are:

• abstract data model, together with operators,
• services dedicated to core functionalities such as case management, data persistence, resources management,
• base CAST editor and other UI abstract classes and utilities,
• Eclipse-dependent classes to manage application life-cycle, perspectives, etc.

The persistence layer provides a storage mechanism designed for CAST data models. It provides object-relational mapping based on Java annotations. The default implementation utilizes SQLite data base engine and stores all data in one file in a current case. Therefore it does not require any other data base service. The layer defines also case compatibility mechanism, which allows for converting data stored in data base between different version of applications.

The last part of CAST Platform are general purpose mechanisms and tools, providing additional functionalities and utilities that can be used by extensions creators. Some of them can be used without any modifications, but most of them define extension points that allow for adjusting them to specific requirements. For example, a data importer mechanism introduce extension points that adjust the importer to a specific domain model.

Extensions are understood as components that provide domain-specific functionalities such as graph visualization or phone call billings tools. The following categories of extensions are distinguished:

• editors - define various data visualization techniques and editing tools such as schema editor, map editor or table editor. All of the editors display and/or edit data represented as data sets.
• domain models and tools - define data models that describe concrete domains such as phone call billings, money transfers, graphs (in general)
• analysis tools - define operators which perform various tranformations on data sets such as merging data sets, computing statistics of data sets elements, transforming one data set into another
• other elements such as external tools - also other extensions are expexted such as scripts converting data files to format complient with importers

Applications are end-user programs which are comprised of a set of Eclipse features that constitute the application functionalities. The applications are built using Eclipse PDE/Build that creates a stand-alone, ready-to-use application. Usually, the application configuration contains also branding elements such as logo, splash screen, custom localization messages, etc.

More information about applications developed based on CAST platform you will find in Applications.