Eclipse Community Forums
Forum Search:

Search      Help    Register    Login    Home
Home » Modeling » ATL » does lazy rules from clause works?(it can be used to match some pattern when the rule is applyed?)
does lazy rules from clause works? [message #987893] Wed, 28 November 2012 15:01 Go to next message
Alessandro Ranieri is currently offline Alessandro RanieriFriend
Messages: 16
Registered: November 2012
Junior Member
Hello to everyone,

I have a question about lazy rules, because the manual is quite synthetic about them.
I would like to know when the from clause is evaluated.
i.e. I make a call to a lazy rule in a matched rule in this way:


rule main {
	
from 
	m: UML!Model, 
	s: UML!Class ( m.name = 'model')
to 
	container1 : UML!Model 
	(
		name<- 'graphModel',
		packagedElement <- thisModule.host(s) 
	)	
}


lazy rule host {

from
	source : UML!Class (source.hasStereotype('lanprofile::Router'))

to
	target : UML!Class 
	(
		name <- 'nodo_router' 
	)
}



why the from clause in the lazy is not evaluated? (it was created target UML!Classes also for that source Classes that don't respect the condition in the round brackets) And, if this behaviour is correct, in which case the from clause make sense for lazy rules?


Thanks in advance,

Alessandro
Re: does lazy rules from clause works? [message #987929 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:
packagedElement <- if s.hasStereotype('lanprofile::Router') then
                         thisModule.host(s)
                   else
                         OclUndefined -- or somethin else...
                   endif

Hugo


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987931 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:
packagedElement <- if s.hasStereotype('lanprofile::Router') then
                         thisModule.host(s) 
                   else
                         OclUndefined -- or something else
                   endif

Hugo


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987932 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:
packagedElement <- if s.hasStereotype('lanprofile::Router') then
                         thisModule.host(s) 
                   else
                         OclUndefined -- or something else
                   endif

Hugo


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987934 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987936 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987937 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987938 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987939 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987943 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987944 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987945 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987946 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987952 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987953 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987954 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987955 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987961 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987962 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987963 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987964 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987973 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987974 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987975 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987976 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987986 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987987 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987988 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #987989 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988002 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988003 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988004 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988005 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988017 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988018 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988019 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988020 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988034 is a reply to message #987893] Wed, 28 November 2012 17:03 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy of lazy rules is to be able to specify explicitly on which elements you call them.
Thus a lazy rule should not have a guard and the filtering should be made on the call, e.g.:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or somethin else...
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988035 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Re: does lazy rules from clause works? [message #988036 is a reply to message #987893] Wed, 28 November 2012 17:08 Go to previous messageGo to previous message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 612
Registered: July 2009
Senior Member
Hello,

The initial philosophy behind lazy (matched) rules is to be able to specify when matched rules are actually called.
Thus lazy rules should not have guard conditions, and the filtering should be done on the call:

packagedElement <- if s.hasStereotype('lanprofile::Router') then
thisModule.host(s)
else
OclUndefined -- or something else
endif

Hugo
--
------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------


------------------------------------------
Hugo Bruneliere - R&D Engineer
AtlanMod research team (Inria, EMN & LINA)
Ecole des Mines de Nantes
Nantes - France
------------------------------------------
Previous Topic:Trasfrom many source elements to one target element
Next Topic:Accessing Data Type Converters
Goto Forum:
  


Current Time: Tue Nov 25 22:27:37 GMT 2014

Powered by FUDForum. Page generated in 0.04485 seconds
.:: Contact :: Home ::.

Powered by: FUDforum 3.0.2.
Copyright ©2001-2010 FUDforum Bulletin Board Software