UML generalization and realization

Question

I am pretty new to UML, so I have some questions about Generalization and Realization. I am modeling the behavior of an electronic microcontroller and I need to generate C++ code from the UML description.

As far as I know, a class realizes an interface, that means it may provide the implementation of an interface. A generalization relationship may exist between two classes. In that case the derived class inherits all the members of the base class and gains access to public and protected members.

Here is my question (I am using Visual Paradigm as modeling tool). Let us assume we have a module of a microcontroller, namely the Timer. We have a set of operations we can perform, say initTimer(), startTimer(), stopTimer() and so on. Actually these functions define a kind of API. We may have different classes of Timer, say TimerA, TimerB, TimerC that inherit (or implement?) all of the cited operations. The picture will make the scenario clearer, probably. [C] means classifier.

                        +----------------------------------+   
                        |              <<SW>>              |
                        |           <<Singleton>>          |
         +--------------|              TimerA              |
         |              +----------------------------------+
         |              | -instance : TimerA* = null [C]   |
         |              | -instanceFlag : bool = false [C] |
         |              | -moduleAddress const = 0x0010    |
         |              +----------------------------------+
         |              | -TimerA()                        |
         V              | +getInstance() : TimerA* [C]     |
+---------------+       +----------------------------------+
|    <<SW>>     |       
|     Timer     |
+---------------+
| +initTimer()  |     
| +startTimer() |<-----------------------+
| +stopTimer()  |                        |
+---------------+      +----------------------------------+ 
                       |              <<SW>>              |
                       |           <<Singleton>>          |
                       |              TimerB              |
                       +----------------------------------+
                       | -instance : TimerB* = null [C]   |
                       | -instanceFlag : bool = false [C] |
                       | -moduleAddress const = 0x0020    |
                       +----------------------------------+
                       | -TimerB()                        |
                       | +getInstance() : TimerB* [C]     |
                       +----------------------------------+

Visual Paradigm allows the user to put code iniside each function. I ask you which kind of relationship the arrows should be.

1) Generalization: Timer class with a set of operations. Each operation has its code implementation. Two derived classes TimerA and TimerB with generalization link inheriting the operations of class Timer.

2) Realization: Timer is an interface (not a class as shown) and two realizing classes TimerA and TimerB. The critical point is the following. Although Timer is an interface and its operations should not contain implementaion details, VP allows to write implementation code for the three operations. During code generation, an interface C++ class Timer is created: initTimer(), startTimer() and stopTimer() are virtual members of Timer with no code (as it should be). A C++ class TimerA is generated and this inherits class Timer members; in addition the three operations of Timer are copied among the memebers of TimerA with the code implementation that I wrote for the operations of the interface class. This happens for TimerB as well.

In your opinion which of the two descriptions is better? Is it correct to write code implementation for the operations of an interface even if I know that, after code generation, will be transferred towards the realizing classes?

score 5 · Accepted Answer · edited Apr 12 '17 at 07:31

In your opinion which of the two descriptions is better?

In my opinion option 3 sketched in the picture below is better. Timer would be reusable (conceptually final) universal class, it's instance only configured by the singleton wrappers and linked by usage dependency relationship

enter image description here

VP allows to write implementation code for the three operations. During code generation...Is it correct to write code implementation for the operations of an interface...?

I don't know how to correctly configure Visual Paradigm's code generator to produce what you want, but although C++ interface is just a class like any other and there's no special keyword for this concept, UML interface is meant to be only description of a contract with no coupled implementation. Some languages like C# or Java have special interface keyword for this purpose, with no-code rule hardcoded in the compiler.

Thus, although Visual Paradigm can perhaps generate the code which you want at the end, from UML perspective, modeling an interface with code is wrong

Make your choice. If you want just code that does The something, then go and hack it anyway which works (as @gilead-silvanas suggests). If you want to practice UML for use in your future projects using different languages, then don't.

Also there's a time when the initial generated code will depart from the initial design drawings and from the code generator and you'll edit it by hand, even if you'd use a tool like Quantum Leaps Modeler for embedded systems.

I'd reconsider (regularly) if fighting with the design tool over-weights the code generation benefits

Please, correct me if I am wrong. With your modelling, the single existence of classes `TimerA` and `TimerB` is ensured because the corresponding flag is set by any of the two singleton wrappers. What is actually instantiated is an object of class `Timer` for as many as Singleton wrappers available (this is done through `TimerA::getInstance()` and `TimerB::getInstance()` static members). So, in the end, the constructors `TimerA()` and `TimerB()` are unused? May I pass arguments to `Timer` class from `TimerA` and `TimerB`. I refer, specifically to the `moduleAddress`. Thanks. — Umberto D., Apr 02 '15 at 15:27
@UmbertoD. yes, that's what I meant, `TimerA()` and `TimerB()` might have class "static" constructors who would initialize the `instance` variables. But **dont' take it literally** as it would hold for `C#` where the timer's tick would be handled by function attached to the [timer's even handler](https://msdn.microsoft.com/en-us/library/system.timers.timer.elapsed(v=vs.110).aspx). I haven't been in the `C++` world actively for few years (and I'm glad). In `C++` you _may have to_ implement it by creating subclasses. So my answer may be quite misleading when it comes to the code generation — xmojmr, Apr 02 '15 at 15:50

score 2 · Answer 2 · answered Apr 02 '15 at 13:49

2

Probably this is just a shorthand for VP to make things quicker. As you said, upon code generation, it clears those codes anyway from the interface and put it in the realizing classes. I don't see anything wrong with that because what matters is the generated code, which in your case is correct.

answered Apr 02 '15 at 13:49

Gilead Silvanas

97
6

Thanks for answering. My initial opinion was that `Timer` actually represents an interface because it contains a set of methods (API) that each specific module (`TimerA`, `TimerB`, etc.) has to implement. I was dubious about the most conceptually acceptable solution from UML perspective. The other alarming point was to write down C++ code (in VP), hence implementation for operations that are part of an interface, not a class. – Umberto D. Apr 02 '15 at 14:40
2

In my opinion on a UML perspective, it would not be correct to write implementations in the interface if we are going to follow object oriented rules strictly. – Gilead Silvanas Apr 02 '15 at 14:45

UML generalization and realization

2 Answers2

Linked

Related