1 OOAD Detailed Design From Design to Implementation ITV Modelbased Analysis and Design of Embedded Software Anders P. Ravn & Arne Skou Aalborg University February 2011
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
1
OOAD Detailed Design
From Design to Implementation
ITV Modelbased Analysis and Design of Embedded Software
Anders P. Ravn & Arne Skou
Aalborg University
February 2011
2
Purpose
• Give meaning to UML diagrams
• Link design to programs
Diagrams:• Class Diagrams with associations and dependencies• State Diagrams with events and actions
3
Basis from Design
• Architecture• Detailed Design for Model• Detailed Design for Functions• Detailed Design for Interface
We revisit the Architecture when we talk about Process Design
4
Architecture: Simple Layered System
«component»Interface
«component»Functions
«component»Model
”Interface” knows ”Functions”, not the converse
”Interface” to Problem Domain
Problem Domain ”Data”
Application Domain ”functions”
5
Simple Generic Architecture
«component» Interface
«component»Model
«component»UserInterface
«component»SystemInterface
«component» Platform
«component»OS
«component»FileSystem
«component»Function
...
6
A variation: Layer access via aggregation
7
A variation: Layer access via generalization
8
Strategy PatternContext
State s
«abstract»Strategy
operation(State)
Function1
functions
* 1
Functionn
...
9
Observer Pattern«abstract»
Subject
attach(Observer)
detach(Observer)
notify()
get(Object)
Model
State s
get(State)
«abstract»Observer
update()
ModelObserver
State observed
observers
1 *
subject
10
Simple Generic Architecture
«component» Interface
«component»Model
«component»UserInterface
«component»SystemInterface
«component» Platform
«component»OS
«component»FileSystem
«component»Function
...
11
Class implementation
class C {
public: char a;
public:
C(); // constructor
~C(); // destructor
}
12
Auto implementation (c.h file)//## class c class c {
//// Constructors and destructors ////public : //## auto_generated c(); ~c();//// Additional operations ////public : //## auto_generated char getA() const; void setA(char p_a);//// Attributes ////protected : char a; //## attribute a };
13
Auto implementation (c.cpp file)
#include "c.h"
//## class c
c::c() {
}
c::~c() {
}
void c::setA(char p_a) {
a = p_a;
}
char c::getA() const {
return a;
}
14
Class method
15
Auto implementation (c.h file)//## class c class c {
//// Constructors and destructors ////public : //## auto_generated c(); ~c();public : //## operation method(char) int method(char x);//// Additional operations ////public : //## auto_generated char getA() const; void setA(char p_a);//// Attributes ////protected : char a; //## attribute a };
16
Auto implementation (c.cpp file)#include "c.h"
//## class c
c::c() {
}
c::~c() {
}
int c::method(char x) {
//#[ operation method(char)
a=x; return 2;
//#]
void c::setA(char p_a) {
a = p_a;
}
char c::getA() const {
return a;
}
17
Class attributes public int getI() {
return i;
}
public void setI(int p_i) {
i = p_i;
}
//## class c public class c { protected int i; //## attribute i protected int j; //## attribute j protected int k; //## attribute k
protected int getJ() {
return j;
}
protected void setJ(int p_j) {
j = p_j;
}
private int getK() {
return k;
}
private void setK(int p_k) {
k = p_k;
}
18
Class generalization
Class d{…}
Class c: public d{…}
19
Class generalization by tool (c.h)
#include "d.h"
//## package Default
//---------------------// c.h //---------------------
//## class c class c : public d {…}
20
Component (package)
namespace HelloPackage {
class upper{ ... };
Class display{ ... };
Class helper{ ... };
...
}
21
Auto implementation// HelloPackage.hnamespace HelloPackage { class Display; class helper; class upper; }
// Display.h namespace HelloPackage { //## class Display class Display : public HelloPackage::upper {...} ...}
22
Aggregation
////whole.h//// Relations and components ////protected : c* itsC; //## link itsC d* itsD; //## link itsD public : //## auto_generated void __setItsC(c* p_c); //## auto_generated void __setItsD(d* p_d);
/**************************************
////c.h//// Relations and components protected : whole* itsWhole; //## link itsWhole
whole::~whole() { cleanUpRelations();}
void whole::cleanUpRelations() { if(itsC != NULL) { whole* p_whole = itsC->getItsWhole(); if(p_whole != NULL) { itsC->__setItsWhole(NULL); } itsC = NULL; } if(itsD != NULL) { whole* p_whole = itsD->getItsWhole(); if(p_whole != NULL) { itsD->__setItsWhole(NULL); } itsD = NULL; }}
23
Strong Aggregation
////whole.h//// Relations and components ////protected : c* itsC; //## link itsC d* itsD; //## link itsD public : //## auto_generated void __setItsC(c* p_c); //## auto_generated void __setItsD(d* p_d);
/**************************************
////c.h//// Relations and components protected : whole* itsWhole; //## link itsWhole
whole::whole(OMThread* p_thread) { setThread(p_thread, FALSE); initRelations();}void whole::initRelations() { itsC = newItsC(); itsD = newItsD();}void whole::cleanUpRelations() { { deleteItsD(); itsD = NULL; } { deleteItsC(); itsC = NULL; }}
24
Dependency //// Relations and components //// layer.hprotected : Display* itsDisplay;//## link itsDisplay
////layer.cppvoid layer::setItsDisplay(Display* p_Display) { itsDisplay = p_Display;}
void layer::cleanUpRelations() { if(itsDisplay != NULL) { itsDisplay = NULL; }}
void layer::test() { //#[ operation test() j=itsDisplay->getI() ; //#]}
25
Association
////c.h//// Relations and components protected : d* itsD; //## link itsD
// c.cpp //---------//## class c int c::method(int x) { //#[ operation method(int) i=x; return itsD->getJ(); //#]
26
Association with *-multiplicity////c.h#include <oxf/omcollec.h>//// Relations and components protected : OMCollection<d*> itsD;//## link itsD
// c.cpp void c::_addItsD(d* p_d) { itsD.add(p_d);}
void c::addItsD(d* p_d) { if(p_d != NULL) { p_d->_addItsC(this); } _addItsD(p_d);}
27
Simple State Machineint Display::rootState_dispatchEvent(short id) { int res = eventNotConsumed; switch (rootState_active) { case switchedOn: { if(IS_EVENT_TYPE_OF(off_system_id)) { rootState_subState = state_1; rootState_active = state_1; res = eventConsumed; } break; } default: break; } return res;}
void Display::initStatechart() { rootState_subState = OMNonState; rootState_active = OMNonState;}
28
Two - State Machineint Display::rootState_dispatchEvent(short id) { int res = eventNotConsumed; switch (rootState_active) { case switchedOn: { if(IS_EVENT_TYPE_OF(react_system_id)) { //#[ transition 2 i++; //#] rootState_subState = Activated; rootState_active = Activated; res = eventConsumed; } else if(IS_EVENT_TYPE_OF(off_system_id)) { rootState_subState = state_1; rootState_active = state_1; res = eventConsumed; } break; } case Activated: {
29
Hierarchical State Machinecase active: { if(IS_EVENT_TYPE_OF(suspT_system_id)) { Activated_subState = Tsuspend; rootState_active = Tsuspend; res = eventConsumed; } if(res == eventNotConsumed) { res = Activated_takeEvent(id); } break; }
int Display::Activated_takeEvent(short id) { int res = eventNotConsumed; if(IS_EVENT_TYPE_OF(susp_system_id)) { Activated_subState = OMNonState; switchedOn_subState = Psuspend; rootState_active = Psuspend; res = eventConsumed; } if(res == eventNotConsumed) { res = switchedOn_takeEvent(id); } return res;}
void Display::Activated_entDef() { switchedOn_subState = Activated; Activated_subState = active; rootState_active = active;}
30
History State Machine case active: { res = active_takeEvent(id); break; }
int Display::active_takeEvent(short id) { int res = eventNotConsumed; if(IS_EVENT_TYPE_OF(suspT_system_id)) { Activated_subState = Tsuspend; rootState_active = Tsuspend; res = eventConsumed; } if(res == eventNotConsumed) { res = Activated_takeEvent(id); } return res;}
31
History State Machineint Display::Activated_takeEvent(short id) { leaving activated if(IS_EVENT_TYPE_OF(susp_system_id)) { Activated_lastState = Activated_subState; switch (Activated_subState) { case active: { Activated_lastState = active; break; }………………Activated_subState = OMNonState; switchedOn_subState = Psuspend; rootState_active = Psuspend; res = eventConsumed; }----------------------------------------------------------------------------------------------------- case Psuspend: reentering activated { if(IS_EVENT_TYPE_OF(react_system_id)) {……………..Activated_subState = Activated_lastState; switch (Activated_subState) { case active: { Activated_subState = active; rootState_active = active; break; }
32
System implementation of component HelloWorld
#include "MainHelloWorld.h"#include "c.h"#include "d.h"#include "whole.h"//----------------------------------------------------------------------------// MainHelloWorld.cpp //----------------------------------------------------------------------------//## configuration HelloWorld::HelloWorld int main(int argc, char* argv[]) { if(OXF::init(argc, argv, 6423)) { c * p_c; d * p_d; whole * p_whole; HelloWorld initializer_HelloWorld; p_c = new c; p_d = new d; p_whole = new whole; //#[ configuration HelloWorld::HelloWorld //#] OXF::start(); delete p_c; delete p_d; delete p_whole; return 0; } else { return 1; }}
Optional
33
Overview of design implementationPurpose Realisation of the
component design
Concepts Patterns for component connection and UML diagram implementation
Principles •Evaluate component connections and change via patterns
•Generate code
•Keep consistency between design and implementation
Result A collection of component implementations
Toolsupport
is needed!
34
Exercise
• Consider your ”Model” component
• Implement selected classes and associations/aggregations
35
Auto implementation (d.h file)typedef struct d d;
/*## class d */
struct d { /*** User explicit entries ***/ char a; /*## attribute a */ };
/* Constructors and destructors:*/
/*## auto_generated */void d_Init(d* const me);void d_Cleanup(d* const me);d * d_Create();void d_Destroy(d* const me);
36
Auto implementation (d.c file)#include "d.h"
/*** Methods implementation ***/
d * d_Create() {
d* me = (d *) malloc(sizeof(d));
if(me!=NULL)
{
d_Init(me);
}
return me;
}
void d_Destroy(d* const me) {
if(me!=NULL)
{
d_Cleanup(me);
}
free(me);
}
Related Documents
![Approximating Markov Processes By Averaging · 2012. 8. 29. · 2 · Philippe Chaput et al. Skou [Larsen and Skou 1991]. The continuous case, however, was neglected for a time. For](https://static.cupdf.com/doc/110x72/6127abfa523dd849a57f7e3d/approximating-markov-processes-by-averaging-2012-8-29-2-philippe-chaput-et.jpg)
