Read Me

Xtu is a framework for implementing Platform specific models (PSM) using the xUML (Executabel UML) methodology. xUML is a formalized methodology for information systems design and development using Model based systems engineering (MBSE).

The targeted platform is single or multithreaded C/C++ environment, utilizing C++11 and STL. The Xtu PSM is implemented at a similar level of abstraction as the xUML Platform independent model (PIM). It is thus straight forward to convert a given PIM to its PSM counter part. The level of abstraction also helps to incorporate Xtu in a code generation solution. Extensive use of templates provides a high-level of type safety at compile time as well as optimizations.

Xtu is licensed under LGPL and distributed as source code only.



Release notes version 3.0.0
===========================
This version breaks compatibility with version 2.0.0

Changes since release 2.0.0
- Removed event wrappers used for queueing events to scheduler.
- Redesigned the handling of delayed events in the default scheduler.
- Moved processing of signals and operations outside the work queue in the scheduler.
- Fixed a off-by-one bug in the object pool template.
- Replaced home-grown array in object pool template with std::vector. Less code and better performance.
- Updated all tests and corrected them for the new event design.
- Replaced the future-based locking mechanism for operations with a simpler & faster mutex lock/conditional variable solution.
- Converted bridge interfaces to support locking as opposed to returning False when provider queue is full.
- Redesigned bridge operation template so that bridge::call() actually returns the return value of an operations, when such exists. 
- Added queue-is-full locking to multithreaded bridges. 
- Converted the XTU_INLINE macro to a more generic form that it also works with templates.
- Converted the Navigator example to be compatible with this release.
- Numerous minor performance improvements.


Release notes version 2.0.0
===========================
This version breaks compatibility with version 1.0.0

Changes since release 1.0.0
- Changed so that most public event handling interfaces deal with constant event instances.
- Fixed incorrect handling & cancelation of delayed events.
- Replaced all 'typedefs' with 'using' and added more type aliases in several places.
- Added an example project to show how a model can be implemented using Xtu.
- Simplified the relation between ClassT<> and EventT<> so that it's based on only EventIDs (not event class).
- Added 2 new methods to StateTableT<> for setting AllIgnore and AllIllegal for a specific state.
- Changed the type of text containers (state, event & rule names) in StateTableT<> to be of more simple array types. std::array<> and std::vector<> didn't play well with the early static initialization.
- Simplified StateTableT<> so that methods for setting up state-event rules are using state instances as method parameter as opposed to StateIDs. This reduces the amount of code the end user has to write and the rules are easier to read.
- Added event generator methods to ClassT<> in order to reduces code typing.
- Fixed a bug related to self-directed events (they were NOT properly released).
- Additional clean ups and optimizations. 


Release notes version 1.0.0
===========================

Implemented PIM components includes:
-Domains.
-Bridges, Signals and Operations.
-Life cycle class with Finite state machine, Events and Delayed events.

Implemenetd PSM components includes:
-Execution contexts (for main process and threads).
-Scheduler. Schedules processing of signals, operations and events/delayed events.	
-Object pools for state full signals, operations, events and wrapper classes.
-Automatic and efficient reuse of state less (non-payloaded) signals, operations, events.

Changes since release 0.9.0
-Removed the Xtu* prefix from all class names and replaced with the xtu name space..
-Implemenetd reusable signals, operations and events.
-Made domains and bridges pure static classes so that they can be directly accessed by their respective type name. I.o.w. the need for instantiation has been removed.
-Solved bugs and cleaned up subtle usage issues.
-Further reduced amount of typing needed by end user.
-Cleaned up, clarified and also tested the start-up and shut-down sequences.
-Improved performance and reduced the amount of code.