sync-wires.drl - iaml - Internet Application Modelling Language

Source path: svn/ trunk/ org.openiaml.model.drools/ rules/ sync-wires.drl

‹r3087

r3163

/**
 * Completes the functionality of {@model SyncWire}s.
 */
package org.openiaml.model.drools.rules.sync_wires

#list any import classes here.
import org.openiaml.model.drools.*;

import org.openiaml.model.inference.*;
import org.openiaml.model.model.*;
import org.openiaml.model.model.impl.*;
import org.openiaml.model.model.wires.*;
import org.openiaml.model.model.visual.*;
import org.openiaml.model.model.operations.*;
import org.openiaml.model.model.scopes.*;
import org.openiaml.model.model.domain.*;

import org.eclipse.emf.ecore.*;

#declare any global variables here
global OverridableCreateElementsHelper handler;
global DroolsInsertionQueue queue;
global DroolsHelperFunctions functions;

/**
 * @inference SyncWire,CanBeSynced
 *		A {@model SyncWire} connecting two objects will create sub-{@model SyncWire}s between
 *		every contained object within these parent objects which have matching {@model CanBeSynced#name names}.
 */
rule "Sync wires between objects should create sync wires between all elements inside each object that matches"
	when
		# source : SyncWire(, eval(connects(source, p1, p2)) )
		source : SyncWire( overriddenNames not contains "sync" )
		
		# we put in these to prevent multiple wires being generated for two connects
		p1 : CanBeSynced ( )
		p2 : CanBeSynced ( )
		eval ( functions.connectsSync1( source, p1, p2 ))

		eval (p1 != p2)
		
		e1 : CanBeSynced( eContainer == p1 )
		e2 : CanBeSynced( eContainer == p2 )

		eval(functions.nameMatches(e1, e2))
	
		not (sw : SyncWire( eContainer == source, eval(functions.connects( sw, e1, e2)) ))
		
		eval ( handler.veto( source ))
		
	then
		SyncWire sw = handler.generatedSyncWire(source, source, e1, e2);
		handler.setName(sw, "sync");
		handler.setExecuteOnInput(sw, source.isExecuteOnInput());
		queue.add(sw, drools);
		
end

/**
 * @inference SyncWire,CanBeSynced
 *		A {@model SyncWire} connecting an {@model DomainIterator} to a {@model CanBeSynced} object
 *		will create sub-{@model SyncWire}s between every contained object within the contained {@model DomainInstance}
 *		to every contained {@model CanBeSynced} object which have matching {@model CanBeSynced#name names}.
 */
rule "Sync wires to Domain Iterators should be copied to the contents of the Domain Iterator"
	when
		# source : SyncWire(, eval(connects(source, p1, p2)) )
		source : SyncWire( overriddenNames not contains "sync" )
		
		# we put in these to prevent multiple wires being generated for two connects
		p1 : CanBeSynced ( )
		p2_container : DomainIterator ( )
		p2 : DomainInstance ( eContainer == p2_container )
		eval ( functions.connects( source, p1, p2_container )) # can no longer rely on unidirectionality

		eval (p1 != p2)
		
		e1 : CanBeSynced( eContainer == p1 )
		e2 : CanBeSynced( eContainer == p2 )

		eval(functions.nameMatches(e1, e2))
	
		not (sw : SyncWire( eContainer == source, eval(functions.connects( sw, e1, e2)) ))
		
		eval ( handler.veto( source ))
		
	then
		SyncWire sw = handler.generatedSyncWire(source, source, e1, e2);
		handler.setName(sw, "sync");
		handler.setExecuteOnInput(sw, source.isExecuteOnInput());
		queue.add(sw, drools);
		
end

/**
 * @inference SyncWire
 *		When a {@model Changeable} is connected to a {@model ContainsOperations} by a
 *		{@model SyncWire}, the source element will {@model ECARule call} the 'update' {@model Operation} on the 
 *		target when the source {@model Changeable#onChange changes}.
 */
rule "Run instance wire from edit to update (onChange)"
	when
		sw : SyncWire( overriddenNames not contains "run" )
		source : Changeable( )
		target : ContainsOperations( )
		eval(functions.connects(sw, source, target))
		
		event : Event( source.onChange == event ) 
		operation : Operation( eContainer == target, name=="update" )
		
		not (ECARule( trigger == event, target == operation, name == "run", eContainer == sw ))
						
		eval ( handler.veto( sw ))
		
	then
		ECARule rw = handler.generatedECARule(sw, sw, event, operation);
		handler.setName(rw, "run");
		queue.add(rw, drools);

end

/**
 * @inference SyncWire
 *		When an {@model InputTextField} is connected to a {@model ContainsOperations} by a {@model SyncWire#executeOnInput instant}
 *		{@model SyncWire}, the source element will {@model ECARule call} the 'update' {@model Operation} on the 
 *		target when the source {@model InputTextField#onInput input changes}.
 */
rule "Run instance wire from edit to update, instant SyncWire (onInput)"
	when
		sw : SyncWire( executeOnInput == true, overriddenNames not contains "run" )
		source : InputTextField( )
		target : ContainsOperations( )
		eval(functions.connects(sw, source, target))
		
		event : Event( source.onInput == event ) 
		operation : Operation( eContainer == target, name=="update" )
		
		not (ECARule( trigger == event, target == operation, name == "run", eContainer == sw ))
						
		eval ( handler.veto( sw ))
		
	then
		ECARule rw = handler.generatedECARule(sw, sw, event, operation);
		handler.setName(rw, "run");
		queue.add(rw, drools);

end

/**
 * TODO Ideally, these two commands would be joined together into one
 *
 * @inference SyncWire,CanBeSynced,Parameter
 *		When a {@model CanBeSynced} element is connected to an {@model CanBeSynced} element by a
 *		{@model SyncWire}, the {@model CanBeSynced#fieldValue value} of the source element
 *		will be provided as a {@model Parameter} to the updating {@model ECARule}.
 */
rule "Connect parameter wire to: run instance wire from source.edit to target.update (onChange)"
	when
		sw : SyncWire( overriddenNames not contains "[sync] run instance parameter (source.edit)" )
		source : Changeable( )
		target : ContainsOperations( )
		eval( functions.connects(sw, source, target))
	
		event : Event( source.onChange == event )
		operation : Operation( eContainer == target, name=="update" )
		field : Value( source.fieldValue == field )
		wire : ECARule( trigger == event, target == operation, name == "run", eContainer == sw )
		
		not ( Parameter ( eContainer == sw, parameterValue == field, parameterTerm == wire )) 
						
		eval ( handler.veto( sw ))
		
	then
		Parameter pw = handler.generatedParameter(sw, sw, field, wire); 
		handler.setName(pw, "[sync] run instance parameter (source.edit)"); 
		queue.add(pw, drools);

end

/**
 * @inference SyncWire,InputTextField,CanBeSynced,Parameter
 *		When an {@model InputTextField} is connected to a {@model CanBeSynced} element by an {@model SyncWire#executeOnInput instant}
 *		{@model SyncWire}, the {@model CanBeSynced#fieldValue value} of the source element
 *		will be provided as a {@model Parameter} to the updating {@model ECARule}.
 */
rule "Connect parameter wire to: run instance wire from source.edit to target.update, instant SyncWire (onInput)"
	when
		sw : SyncWire( executeOnInput == true, overriddenNames not contains "[sync] run instance parameter instant (source.edit)" )
		source : InputTextField( )
		target : ContainsOperations( )
		eval( functions.connects(sw, source, target))
	
		event : Event( source.onInput == event ) 
		operation : Operation( eContainer == target, name=="update" )
		field : Value( source.currentInput == field )
		wire : ECARule( trigger == event, target == operation, name == "run", eContainer == sw )
		
		not ( Parameter ( eContainer == sw, parameterValue == field, parameterTerm == wire )) 
						
		eval ( handler.veto( sw ))
		
	then
		Parameter pw = handler.generatedParameter(sw, sw, field, wire); 
		handler.setName(pw, "[sync] run instance parameter instant (source.edit)"); 
		queue.add(pw, drools);

end

/**
 * TODO Ideally, these two commands would be joined together into one
 *
 * @inference SyncWire
 *		When a {@model ContainsOperations} element is connected to an {@model Accessible} element by a
 *		{@model SyncWire}, the source element will {@model ECARule call} the 'init' {@model Operation} on the 
 *		target when the target {@model Accessible#onAccess is accessed}.
 */
rule "Run instance wire from source.access to source.init, when we have a value to provide as a parameter (onAccess)"
	when
		sw : SyncWire( overriddenNames not contains "run" )
		source : Accessible( )  
		target : ContainsOperations( )
		eval ( functions.connects(sw, source, target ))
		
		event : Event( source.onAccess == event ) 
		operation : Operation( eContainer == source, name=="init" )
		field : Value( target.fieldValue == field )
		
		not (ECARule( trigger == event, target == operation, name == "run", eContainer == sw ))
						
		eval ( handler.veto( sw ))
		
	then
		ECARule rw = handler.generatedECARule(sw, sw, event, operation);
		handler.setName(rw, "run");
		queue.add(rw, drools);

end

/**
 * @inference SyncWire,SimpleCondition
 *		When a {@model ContainsOperations} element is connected to an {@model Accessible} element by a
 *		{@model SyncWire}, the target element will {@model SimpleCondition only} be initialised if the source value is set.
 */
rule "Run instance wire from source.access to source.init, adding SimpleCondition to check it is set (onAccess)"
	when
		sw : SyncWire()
		source : Accessible( )  
		target : ContainsOperations( )
		eval ( functions.connects(sw, source, target))
		
		event : Event( source.onAccess == event ) 
		operation : Operation( eContainer == source, name=="init" )
		field : Value( target.fieldValue == field )
		
		run : ECARule( trigger == event, target == operation, name == "run", eContainer == sw )
		
		# condition check
		condition : Function ( eContainer == target, name == "fieldValue is set" )
		
		not ( SimpleCondition ( function == condition, conditioned == run ))
					
		eval ( handler.veto( sw ))
	
	then
		SimpleCondition cw = handler.generatedSimpleCondition(sw, sw, condition, run);
		queue.add(cw, drools);
		
end	

/**
 * TODO Ideally, these two commands would be joined together into one
 *
 * @inference SyncWire,Parameter
 *		When a {@model CanBeSynced} element is connected to a {@model CanBeSynced} element by a
 *		{@model SyncWire}, the {@model CanBeSynced#fieldValue} of the source element will be used as a 
 *		{@model Parameter} to initialise the target through the 'init' {@model Operation}.
 */
rule "Connect parameter wire to: run instance wire from source.access to source.init"
	when
		sw : SyncWire( overriddenNames not contains "[sync] run instance parameter (source.access)" )
		source : Accessible( )
		target : ContainsOperations( )
		eval ( functions.connects(sw, source, target))
	
		event : Event( source.onAccess == event )
		operation : Operation( eContainer == source, name=="init" )
		field : Value( target.fieldValue == field )
		wire : ECARule( trigger == event, target == operation, name == "run", eContainer == sw )
		
		not ( Parameter ( eContainer == sw, parameterValue == field, parameterTerm == wire )) 
						
		eval ( handler.veto( sw ))
		
	then
		Parameter pw = handler.generatedParameter(sw, sw, field, wire); 
		handler.setName(pw, "[sync] run instance parameter (source.access)"); 
		queue.add(pw, drools);

end

/**
 * I think that chained SyncWires are generally impossible. Consider:
 * 
 *   page1 <--> page2 <--> unrelated
 *   condition on both SyncWires, matching (page1, page2)
 * 
 * If we allow for chaining, then the condition 
 *   condition[page2, unrelated]
 * will be copied onto
 *   condition[page1, page2]
 * which means the SyncWire will never satisfy all its conditions.
 *
 * --
 *
 * I think that chained SyncWires are only possible *when* each
 * SyncWire has identical Conditions, so we don't have to combine
 * the two conditions together into something impossible.
 *
 * However, trying to implement this did nothing. I think it is because
 * without adding more information to the model, you cannot chain.
 * The information you'd be adding is stuff like ChainedSyncWire, but
 * this defeats the purpose of having it in the model, because this should
 * be handled by the code generation instead.
 */

/**
 * @inference SyncWire,SimpleCondition
 *		A sub-{@model SyncWire} generated for a parent {@model SyncWire}
 *		will also be restricted with all of the {@model SimpleCondition}s of the parent wire.
 */
rule "Cascaded SyncWires: Conditions from parent to child"
	when

		# the containing elements	
		sw : SyncWire ( )
		source : CanBeSynced( )  
		// cannot use 'sw.to == target, target != source'
		// can NOT use 'sw.to == target, this != source'
		// can NOT use 'sw.to == this, this != source'
		target : CanBeSynced( )
		eval ( target != source )
		
		eval ( functions.connectsSync1(sw, source, target ))
				
		# the elements contained
		e1 : CanBeSynced( eContainer == source )
		e2 : CanBeSynced( eContainer == target, eval(functions.nameMatches(e1, e2)) )
		esw : SyncWire( name == "sync", eval(functions.connects(esw, e1, e2)) )
		
		# there is a condition on the containing sync wire
		condition : Function ( )
		cw : SimpleCondition( function == condition, conditioned == sw )

		# and there isn't one on the element sync wire
		not (ecw : SimpleCondition( function == condition, conditioned == esw )) 
						
		eval ( handler.veto( cw ))
		
	then
		SimpleCondition ecw = handler.generatedSimpleCondition( cw, sw, condition, esw );
		handler.setName(ecw, "[copied] from: " + cw.getId());
		queue.add(ecw, drools);

end

/**
 * @inference SyncWire,SimpleCondition
 *		A sub-{@model SyncWire} generated for a parent {@model SyncWire} connected to a {@model DomainIterator}
 *		will also be restricted with all of the {@model SimpleCondition}s of the parent wire.
 */
rule "Cascaded SyncWires: Conditions from parent to child (Domain Instances)"
	when

		# the containing elements	
		sw : SyncWire ( )
		source : CanBeSynced( )  
		// cannot use 'sw.to == target, target != source'
		// can NOT use 'sw.to == target, this != source'
		// can NOT use 'sw.to == this, this != source'
		target_container : DomainIterator ( )
		target : DomainInstance( eContainer == target_container )
		
		eval ( target != source )
		
		eval ( functions.connects(sw, source, target_container )) # can no longer rely on unidirectionality
				
		# the elements contained
		e1 : CanBeSynced( eContainer == source )
		e2 : CanBeSynced( eContainer == target, eval(functions.nameMatches(e1, e2)) )
		esw : SyncWire( name == "sync", eval(functions.connects(esw, e1, e2)) )
		
		# there is a condition on the containing sync wire
		condition : Function ( )
		cw : SimpleCondition( function == condition, conditioned == sw )

		# and there isn't one on the element sync wire
		not (ecw : SimpleCondition( function == condition, conditioned == esw )) 
						
		eval ( handler.veto( cw ))
		
	then
		SimpleCondition ecw = handler.generatedSimpleCondition( cw, sw, condition, esw );
		handler.setName(ecw, "[copied] from: " + cw.getId());
		queue.add(ecw, drools);

end

/**
 * @inference SyncWire,SimpleCondition
 *		All restrictions derived by copying the {@model SimpleCondition}s of parent {@model SyncWire}s
 *		to their sub-{@model SyncWire}s will also be provided with the same {@model Parameter}s.
 */
rule "Cascaded SyncWires: Parameters from parent to child"
	when

		# the containing elements
		sw : SyncWire ( )
		source : CanBeSynced( )  
		target : CanBeSynced( )
		eval ( target != source )

		eval ( functions.connectsSync1(sw, source, target ))
		
		# the elements contained
		e1 : CanBeSynced( eContainer == source )
		e2 : CanBeSynced( eContainer == target, eval(functions.nameMatches(e1, e2)) )
		esw : SyncWire( name == "sync", eval(functions.connects(esw, e1, e2)) )
		
		# there is a condition on the containing sync wire
		condition : Function ( )
		cw : SimpleCondition( function == condition, conditioned == sw )
		
		# the generated condition wire
		ecw : SimpleCondition( function == condition, conditioned == esw )
		
		# there is a parameter on the condition wire
		parameter : ParameterEdgesSource( )
		pw : Parameter( parameterValue == parameter, parameterTerm == cw )

		# and there isn't one on the element sync wire
		not (epw : Parameter( parameterValue == parameter, parameterTerm == ecw )) 
						
		eval ( handler.veto( cw ))
		
	then
		# create it
		Parameter epw = handler.generatedParameter( cw, sw, parameter, ecw );
		handler.setName(epw, "[copied] from: " + pw.getId());
		queue.add(epw, drools);

end

/**
 * @inference SyncWire,SimpleCondition
 *		All restrictions derived by copying the {@model SimpleCondition}s of parent {@model SyncWire}s involving a {@model DomainIterator}
 *		to their sub-{@model SyncWire}s will also be provided with the same {@model Parameter}s.
 */
rule "Cascaded SyncWires: Parameters from parent to child (Domain Instances)"
	when

		# the containing elements	
		sw : SyncWire ( )
		source : CanBeSynced( )  
		// cannot use 'sw.to == target, target != source'
		// can NOT use 'sw.to == target, this != source'
		// can NOT use 'sw.to == this, this != source'
		target_container : DomainIterator ( )
		target : DomainInstance( eContainer == target_container )
		
		eval ( target != source )

		eval ( functions.connectsSync1(sw, source, target ))
		
		# the elements contained
		e1 : CanBeSynced( eContainer == source )
		e2 : CanBeSynced( eContainer == target, eval(functions.nameMatches(e1, e2)) )
		esw : SyncWire( name == "sync", eval(functions.connects(esw, e1, e2)) )
		
		# there is a condition on the containing sync wire
		condition : Function ( )
		cw : SimpleCondition( function == condition, conditioned == sw )
		
		# the generated condition wire
		ecw : SimpleCondition( function == condition, conditioned == esw )
		
		# there is a parameter on the condition wire
		parameter : ParameterEdgesSource( )
		pw : Parameter( parameterValue == parameter, parameterTerm == cw )

		# and there isn't one on the element sync wire
		not (epw : Parameter( parameterValue == parameter, parameterTerm == ecw )) 
						
		eval ( handler.veto( cw ))
		
	then
		# create it
		Parameter epw = handler.generatedParameter( cw, sw, parameter, ecw );
		handler.setName(epw, "[copied] from: " + pw.getId());
		queue.add(epw, drools);

end

/**
 * SyncWires do not just connect the fields together; they can _also_
 * connect the Frames together.
 *
 * @inference SyncWire,Session
 *		A parent {@model SyncWire} connecting a {@model Session}-contained {@model VisibleThing} to a {@model ContainsOperations} element
 *		outside of that {@model Session}, will {@model ECARule call} the 'init' {@model Operation} generated by each sub-{@model SyncWire}
 *		when the {@model Session} is {@model Session#onInit initialised}.
 */
rule "Connect Session.init to incoming SyncWires (contained in Frames) (onChange 2)"
	when
		session : Session (  )
		sw : SyncWire( )
		sourceFrame : VisibleThing( eval(!functions.containingSessionEquals(sourceFrame, session)) )  
		targetFrame : ContainsOperations( eval(functions.containingSessionEquals(targetFrame, session)) )
		eval( functions.connects(sw, sourceFrame, targetFrame ))

		sw2 : SyncWire ( eContainer == sw, overriddenNames not contains "run" )
		sourceElement : Changeable( eContainer == sourceFrame )
		targetElement : ContainsOperations( eContainer == targetFrame )
		eval( functions.connects(sw2, sourceElement, targetElement ))

		event : Event( sourceElement.onChange == event ) 
		operation : Operation( eContainer == targetElement, name == "update" )

		rw : ECARule( eContainer == sw2, trigger == event, target == operation, name == "run" )
		inite : Event (eContainer == session, session.onInit == inite )
		
		not (ECARule( eContainer == sw2, trigger == inite, target == operation, name == "run" ))
						
		eval ( handler.veto( sw2 ))
		
	then
		ECARule rw2 = handler.generatedECARule(sw2, sw2, inite, operation);
		handler.setName(rw2, "run");
		queue.add(rw2, drools);
		
end

/**
 * VisibleThing != Frame
 *
 * @inference SyncWire,Session
 *		A parent {@model SyncWire} connecting a {@model Session}-contained {@model Frame} to a {@model ContainsOperations} element
 *		outside of that {@model Session}, will {@model ECARule call} the 'init' {@model Operation} generated by each sub-{@model SyncWire}
 *		when the {@model Session} is {@model Session#onInit initialised}.
 */
rule "Connect Session.init to incoming SyncWires (contained in Frames) (onChange 3)"
	when
		session : Session (  )
		sw : SyncWire( )
		sourceFrame : Frame( eval(!functions.containingSessionEquals(sourceFrame, session)) )  
		targetFrame : ContainsOperations( eval(functions.containingSessionEquals(targetFrame, session)) )
		eval( functions.connects(sw, sourceFrame, targetFrame ))

		sw2 : SyncWire ( eContainer == sw, overriddenNames not contains "run" )
		sourceElement : Changeable( eContainer == sourceFrame )
		targetElement : ContainsOperations( eContainer == targetFrame )
		eval( functions.connects(sw2, sourceElement, targetElement ))

		event : Event( sourceElement.onChange == event ) 
		operation : Operation( eContainer == targetElement, name == "update" )

		rw : ECARule( eContainer == sw2, trigger == event, target == operation, name == "run" )
		inite : Event (eContainer == session, session.onInit == inite )
		
		not (ECARule( eContainer == sw2, trigger == inite, target == operation, name == "run" ))
						
		eval ( handler.veto( sw2 ))
		
	then
		ECARule rw2 = handler.generatedECARule(sw2, sw2, inite, operation);
		handler.setName(rw2, "run");
		queue.add(rw2, drools);
		
end

/**
 * @inference SyncWire,Session,Parameter
 *		Every 'init' {@model Operation} executed when a {@model Session} is {@model Session#onInit initialised} due to
 *		a {@model SyncWire} between a {@model VisibleThing} within that session, to {@model ContainsOperations another element}
 *		outside of that session, will be provided the {@model Changeable#fieldValue} of the source element as a {@model Parameter}.
 */
rule "Connect parameter for Session.init to incoming SyncWires (contained in Frames) (onChange) (2)"
	when
		session : Session (  )
		sw : SyncWire ( )
		sourceFrame : VisibleThing( eval(!functions.containingSessionEquals(sourceFrame, session)) )  
		targetFrame : ContainsOperations( eval(functions.containingSessionEquals(targetFrame, session)) )
		eval( functions.connects(sw, sourceFrame, targetFrame ))

		sw2 : SyncWire ( eContainer == sw)
		sourceElement : Changeable( eContainer == sourceFrame )
		targetElement : ContainsOperations( eContainer == targetFrame )
		eval( functions.connects(sw2, sourceElement, targetElement ))

		event : Event( sourceElement.onChange == event ) 
		operation : Operation( eContainer == targetElement, name == "update" )

		rw : ECARule( eContainer == sw2, trigger == event, target == operation, name == "run" )
		inite : Event (eContainer == session, session.onInit == inite )

		initrw : ECARule( eContainer == sw2, trigger == inite, target == operation, name == "run" )
		
		field : Value( sourceElement.fieldValue == field )
		pw : Parameter( eContainer == sw2, parameterValue == field, parameterTerm == rw ) 

		not( Parameter ( eContainer == sw2, parameterValue == field, parameterTerm == initrw ))  
						
		eval ( handler.veto( sw ))
		
	then
		Parameter pw2 = handler.generatedParameter(sw, sw, field, initrw);
		queue.add(pw2, drools);		
end

/**
 * @inference SyncWire,Session,Parameter
 *		Every 'init' {@model Operation} executed when a {@model Session} is {@model Session#onInit initialised} due to
 *		a {@model SyncWire} between a {@model Frame} within that session, to {@model ContainsOperations another element}
 *		outside of that session, will be provided the {@model Changeable#fieldValue} of the source element as a {@model Parameter}.
 */
rule "Connect parameter for Session.init to incoming SyncWires (contained in Frames) (onChange) (3)"
	when
		session : Session (  )
		sw : SyncWire(  )
		sourceFrame : Frame( eval(!functions.containingSessionEquals(sourceFrame, session)) )  
		targetFrame : ContainsOperations( eval(functions.containingSessionEquals(targetFrame, session)) )
		eval( functions.connects(sw, sourceFrame, targetFrame ))

		sw2 : SyncWire ( eContainer == sw)
		sourceElement : Changeable( eContainer == sourceFrame )
		targetElement : ContainsOperations( eContainer == targetFrame )
		eval( functions.connects(sw2, sourceElement, targetElement ))

		event : Event( sourceElement.onChange == event ) 
		operation : Operation( eContainer == targetElement, name == "update" )

		rw : ECARule( eContainer == sw2, trigger == event, target == operation, name == "run" )
		inite : Event (eContainer == session, session.onInit == inite )

		initrw : ECARule( eContainer == sw2, trigger == inite, target == operation, name == "run" )
		
		field : Value( sourceElement.fieldValue == field )
		pw : Parameter( eContainer == sw2, parameterValue == field, parameterTerm == rw ) 

		not( Parameter ( eContainer == sw2, parameterValue == field, parameterTerm == initrw ))  
						
		eval ( handler.veto( sw ))
		
	then
		Parameter pw2 = handler.generatedParameter(sw, sw, field, initrw);
		queue.add(pw2, drools);		
end

/**
 * @inference SyncWire,DomainInstance
 *		An empty {@model InputForm} connected to a {@model DomainIterator} with a {@model SyncWire}
 *		will create an {@model InputTextField} in that form for every {@model DomainAttributeInstance}
 *		that is not a {@model DomainAttribute#primaryKey primary key} or {@model ExtendsEdge foreign key}.
 * @implementation DomainAttributeInstance
 *		Currently, it is not possible to modify a {@model DomainAttributeInstance}
 *		that is {@model ExtendsEdge derived} or directly a {@model DomainAttribute#primaryKey primary key}.
 */
rule "Refresh New Instance Object mappings (except for generated primary keys) when sync connected to Forms: create text fields"
	when
		sync : SyncWire(  )
		form : InputForm (  )
		iterator : DomainIterator ( )
		instance : DomainInstance ( iterator.currentInstance == instance )
		
		eval(functions.connects(sync, form, iterator))
		
		originalAttribute : DomainAttribute ( )
		attribute : DomainAttributeInstance( eContainer == instance )
		ExtendsEdge ( from == attribute, to == originalAttribute )
		
		# at the top of the attribute inheritance heirarchy, not
		# a generated primary key
		eval( functions.notExtendingGeneratedPrimaryKey( originalAttribute ) )

		# or ANY type of primary key
		eval( functions.notExtendingPrimaryKey( originalAttribute ) )
		
		not ( tf : VisibleThing( eContainer == form, eval(functions.nameMatches( attribute, tf )) ) )
		
		eval ( !form.getOverriddenNames().contains(attribute.getName()) )
						
		eval ( handler.veto( sync ))
		
	then
		# create a new one
		InputTextField text = handler.generatedInputTextField(sync, form);
		handler.setName(text, attribute.getName());
		handler.setType(text, attribute.getType());
		queue.add(text, drools);

end

/**
 * @inference SyncWire,InputForm,InputTextField
 *		An {@model InputForm} connected to another {@model InputForm} with a {@model SyncWire}
 *		will create an {@model InputTextField} in the target form for every {@model InputTextField} in the
 *		source form with the same {@model InputTextField#name}.
 */
rule "Refresh mappings between InputForms connected to InputForms containing InputTextFields"
	when
		sync : SyncWire( )
		source : InputForm ( )
		target : InputForm ( )
		
		eval(functions.connects(sync, source, target))
		
		sf : InputTextField ( eContainer == source )
		not ( tf : VisibleThing ( eContainer == target, eval(functions.nameMatches( sf, tf ))) )
						
		eval ( !target.getOverriddenNames().contains(sf.getName()) )
						
		eval ( handler.veto( sync ))
		
	then
		# create a new one
		InputTextField tf = handler.generatedInputTextField(sync, target);
		handler.setName(tf, sf.getName());
		queue.add(tf, drools);

end

/**
 * @inference SyncWire,InputForm,Label
 *		An {@model InputForm} connected to another {@model InputForm} with a {@model SyncWire}
 *		will create a {@model Label} in the target form for every {@model Label} in the
 *		source form with the same {@model Label#name}.
 */
rule "Refresh mappings between InputForms connected to InputForms containing Labels"
	when
		sync : SyncWire( )
		source : InputForm ( )
		target : InputForm ( )
		
		eval(functions.connects(sync, source, target))
		
		sf : Label ( eContainer == source )
		not ( tf : VisibleThing ( eContainer == target, eval(functions.nameMatches( sf, tf ))) )

		eval ( !target.getOverriddenNames().contains(sf.getName()) )
						
		eval ( handler.veto( sync ))
		
	then
		# create a new one
		Label tf = handler.generatedLabel(sync, target);
		handler.setName(tf, sf.getName());
		queue.add(tf, drools);

end

/**
 * @inference SyncWire,DomainIterator
 *		A {@model SyncWire} connecting a {@model DomainIterator#query 'new'} {@model DomainIterator} to an {@model InputForm} should only
 *		execute the 'init' {@model Operation} on the created {@model Label}s when the label is {@model Label#onAccess accessed}
 *		if the {@model DomainInstance} is {@model Function not empty}. 
 */
rule "A SyncWire between Attributes selected from a NewInstanceWire need to check that the attribute exists before initialising"
	when
		sync : SyncWire( )
		form : InputForm ( )
		iterator : DomainIterator ( query == "new" )
		instance : DomainInstance ( iterator.currentInstance == instance )
		
		eval(functions.connects(sync, form, iterator))
		
		# contained attribute/field
		attribute : DomainAttributeInstance( eContainer == instance )
		tf : InputTextField ( eContainer == form )
		sync2 : SyncWire ( overriddenNames not contains "check new instance exists" )
		
		eval(functions.connects(sync2, tf, attribute))
		
		# text field access/init events
		access : Event ( tf.onAccess == access ) 
		initOp : Operation ( eContainer == tf, name == "init" )
		run : ECARule ( trigger == access, target == initOp )
		
		attributeValue : Value ( attribute.fieldValue == attributeValue )
		
		param : Parameter ( parameterValue == attributeValue, parameterTerm == run )  
		
		# 'not empty' condition in the iterator
		# TODO this could also be part of the DomainInstance
		existsCondition : Function ( eContainer == iterator, name == "not empty" )
		
		# but not connected		
		not (SimpleCondition ( function == existsCondition, conditioned == run ))
						
		eval ( handler.veto( sync2 ))
		
	then
		# connect it
		SimpleCondition cw = handler.generatedSimpleCondition(sync2, sync2, existsCondition, run);
		handler.setName(cw, "check new instance exists");
		queue.add(cw, drools);

end

Show details Hide details

Change log

r3151 by soundasleep on Oct 13, 2011 Diff

additional model completion documentation
fixes

Go to:

Project members, sign in to write a code review

Older revisions

r3087 by soundasleep on Sep 15, 2011 Diff

improving the grammar and structure of
the model completion rules
documentation

r2962 by soundasleep on May 23, 2011 Diff

 issue 261 : removing unused SetWire and
SyncWire rules

r2952 by soundasleep on May 22, 2011 Diff

 issue 240 : updating more rule packages
with inference modeldoc

All revisions of this file

File info

Size: 31128 bytes, 807 lines

View raw file