UML Receptions and AcceptEventActions

What shall be the relationship between the receptions of a class (was classifier before Aadaam correction) and the AcceptEventActions in the activity describing the behavior of its instances?

I understand the former is related to signals reception of the type while the latter is related to runtime ReceiveSignalEvent events of the class instances (objects). But it is not totally clear to me how to express consistency among these constructs.

_{I am defining a set of M2M and M2T Transformations (by means of QVT and MOFM2T). However independently of what I am trying to do I am curious to know what is the correct syntax for such models.}

Bit of a background: UML is the Universal Modeling Language. The aim for version 2.0 was to grab all the different diagramming / modeling standards that exists in IT, and meta-standardize them, whilst trying to help static analysis on models. That way they could’ve created the true lingua franca of IT.

That’s why MOF has about 400 classifiers. The only thing you can say to that is OMG.

One of such brought in modeling standard was the SDL from telecommunications. That is where AcceptEventActions come from: basically there are two parallel universes, with a parallel set of tokens, and AcceptEventActions are the “sensors” who “sense” this parallel universe and trigger themselves on accepting a token from it.

It’s like when a phone call is coming in to your landline: it’s not your phone who has the event, the event comes from the outside world.

Now a classifier is anything which has a classifier attribute, that is, a class is something which constitutes a set: for everything in the world, you can say that it belongs to the class, while the other does not. It’s a pretty broad thing.

Therefore, a classifier doesn’t have any receptions – it might have, it might not have, well, those who have something called reception constitute a class.

In a broad sense, a classifier is a set of common features which the members (instances) of the class share, or rather, in which these are interestingly different. That is, if I say, that a cat is classified by its eye color, age, breed and color of fur, that means, that I expect the instances of the cat class to be different in these properties, but I don’t expect any of them to have milk allergy: the love of milk is common to the set, and as long as I don’t have to define this class against the class of dogs for example, we don’t care, and we don’t model it.

What you might talk about is object nodes. An object node represents an instance of a class (not a classifier, who was that who wrote that…), which exists at a given moment of time. It’s used simply to classify the message traveling between two nodes, that is, it tells you that function A returns with an object of class C, which will be an input to function B. It can also be, that both of these functions have a much more restricted interface (eg, A returns an object with interface I while B expects something with interface F, both implemented by all members of class C), it’s just a note that hey, we will have an object sometime, which is an instance of class C.

It’s basically a shiny label. It’s like writing on a tube: “cold water”: the washing machine expects cold water, the water tower provides cold water, so the condition is satisfied (well, except for some parts of London and England in general, but let’s not get into that)

Now this label, this pipe is part of the system. It doesn’t come from the air, it has to be defined in other parts of the system, somehow, you have to care about it, you have to create it somewhere, you have to make sure it reaches all its intended recipients, etc.

However, a phone call does come “from the air”. You don’t care about how it was made, how it was created, you only realize that it’s a phone call and it’s there. That’s an event. It’s from the outside world.

Therefore, there is no incoming control flow of an AcceptEventAction, (as it’s basically a start sign, but there is an outgoing control flow in case control flows are modeled (it triggers the system)

I guess this is just plainly stupid:

(Image credit: Gentleware / Poseidon. Reproduced in belief of fair use)

That’s because an AcceptEventAction is a start sign. It doesn’t have any control reception from the system. The control is lost after the payment request, and it is regained after the confirmation comes, as anyone who has ever built a payment gateway client or an SSO gateway client knows.

I guess it could have an incoming object flow, or an outgoing object flow (that is, a parameterized event, like a caller id).

However, an object node always has an incoming object flow and an outgoing object flow (as it’s inside the system, I mean, does an object appear and then gets immediately garbage collected? Then why did we create it), but no control flow (as it’s just a label).

Filed under: softwareengineering - @ 13:21

Thẻ: modeling, uml

Thiết kế website giá rẻ

Danh mục

UML Receptions and AcceptEventActions