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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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: 632
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 next message
Hugo Bruneliere is currently offline Hugo BruneliereFriend
Messages: 632
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 #988037 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: 632
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 #988051 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: 632
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 #988052 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: 632
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 #988053 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: 632
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 #988054 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: 632
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 #988059 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988069 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: 632
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 #988070 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: 632
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 #988071 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: 632
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 #988072 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: 632
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 #988087 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: 632
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 #988088 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: 632
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 #988089 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: 632
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 #988090 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: 632
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 #988091 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988107 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: 632
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 #988108 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: 632
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 #988109 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: 632
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 #988110 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: 632
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 #988111 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988129 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: 632
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 #988130 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: 632
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 #988131 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: 632
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 #988132 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: 632
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 #988133 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988153 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: 632
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 #988154 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: 632
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 #988155 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: 632
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 #988156 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988176 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988187 is a reply to message #987893] Wed, 28 November 2012 18:01 Go to previous messageGo to next message
Sylvain EVEILLARD is currently offline Sylvain EVEILLARDFriend
Messages: 531
Registered: July 2009
Senior Member
lazy rules don't evaluate the filter, you'll have to do that where you call the lazy rule
Re: does lazy rules from clause works? [message #988754 is a reply to message #988129] Sun, 02 December 2012 19:05 Go to previous message
Dennis Wagelaar is currently offline Dennis WagelaarFriend
Messages: 218
Registered: September 2012
Senior Member

Op 28-11-12 18:03, Hugo Bruneliere schreef:
> 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

The new EMFTVM research VM *does* evaluate guards on lazy rules, as well as
the input element types. EMFTVM also allows rule inheritance on lazy rules. In
EMFTVM, a lazy rule that does not match will return OclUndefined.

This opens the door for experimentation with virtual rule invocation, where
matching sub-rules of a lazy rule are automatically invoked. Note that this is
currently *not* (yet) implemented in EMFTVM, and invocation of a lazy rule
just invokes that rule and its super-rules.

Regards,
Dennis


Cheers,
Dennis
Previous Topic:Trasfrom many source elements to one target element
Next Topic:Accessing Data Type Converters
Goto Forum:
  


Current Time: Mon Aug 31 19:54:12 GMT 2015

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

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