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.

  • What do yout try to do? A 4CASE development environment (aka executable uml and friends), or do you you have an actual system which you have to model in order to reach a particular goal or understanding?
    – Aadaam
    Jul 30, 2012 at 13:47
  • Aadaam 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 Jul 30, 2012 at 15:25

1 Answer 1


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:

This is not how it works in real life (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).

  • Aadaam thank you, your answer is quite descriptive and say correct things. I should have used the class (not classifier) term. However the rest of the question is correct as a class may own receptions and may have behaviors described by activities that may have accept event actions (AEA). I haven't said AEA should have incoming flow. However there could be to express an flow stops and waiting for the reception of a signal to continue. In my question I was just wondering whether there could be behaviors with AEA waiting on signals for which the class has no receptions and viceversa. Jul 31, 2012 at 5:33
  • Each AEA should only wait for exactly one class of signals, at least, this is how it works with SDL. Also, an AEA solely exists to denote the arrival of this particular signal, therefore it cannot wait for any other signal, as it is de facto the representation of the signal itself.
    – Aadaam
    Jul 31, 2012 at 5:40
  • Aadaam, I have never said AEA should wait for more than one signal... I am just asking whethere there could be behaviors with AEAs waiting on signals for which the class has no receptions and viceversa. I do not know SDL I am interested in the UML meta-model Jul 31, 2012 at 6:58
  • okay, okay, but which class are we talking about? The class of an AEA? It waits for exactly one class of signal, if it never comes, it never executes, just like girls in some idealistic old times. And it's not interested in any other class of signals of the world, no matter how much methods or properties might they bear...
    – Aadaam
    Jul 31, 2012 at 7:21
  • Aadamm a class may have many receptions each related to a type of signal. It may then have a number of behaviors containing AEAs related to ReceiveSignalEvent which are the runtime occurrences of signals. My Question is... do these ReceiveSignalEvents have to relate to signal types for which the class has receptions? Jul 31, 2012 at 7:41

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.