intersect

Short summary

overwrites the content of this set with the intersection of this set and the given set Set intersection: Common elements between two sets.

Example: Set A = 4 Set B = 4

Intersection of A and B: 4

Return: SUCCESS: if intersect is complete ABORTED: execute has a falling edge during intersect, BUSY: Intersect is in Progress ERROR: the passed collection was not valid or contained invalid Elements or the collection changed during intersect IDLE: Currently no intersect in progress

• Return type: CNM_ReturnTypes.SingleExecutionState

Parameters

Name	Type	Comment	Kind
set	CNM_CollectionInterfaces.ISet	foreign set to intersect with	input
execute	BOOL	If intersect should be processed	input

Code

Declaration

METHOD INTERNAL intersect :CNM_ReturnTypes.SingleExecutionState
VAR_INPUT
	(*foreign set to intersect with*)
	set :CNM_CollectionInterfaces.ISet;
	(*If intersect should be processed*)
	execute		:BOOL;
END_VAR
VAR_INST
	cycleManager :CNM_CycleManager.SimpleCycleManager;
	changeIndex :__XWORD;
END_VAR
VAR
	iteratedObject, intersectObject :CNM_AbstractObject.IObject;
	iterateState 				:CNM_ReturnTypes.SingleExecutionState;
	insertOperationsThisCycle	:UDINT := 0;
	objectsRemoved :BOOL := FALSE;
END_VAR
VAR CONSTANT
	INIT :DINT := CNM_ReturnTypes.DefaultSteps.STEP.INIT;
	PROCESSING :DINT := INIT + 1;
	SUCCESS :DINT := CNM_ReturnTypes.DefaultSteps.STEP.SUCCESS;
	ERROR :DINT := CNM_ReturnTypes.DefaultSteps.STEP.ERROR;
END_VAR

Implementation

REPEAT
	cycleManager(execute := execute);
	CASE cycleManager.step.current OF
	INIT:
		IF THIS^.isObjectValid(THIS^.intersectIterator) THEN 
			THIS^.intersectIterator.destruct();
		END_IF
		IF THIS^.intersectedTree <> 0 THEN
			__DELETE(THIS^.intersectedTree);
		END_IF
		IF (THIS^.isObjectNull(set)) THEN
			cycleManager.proceedWith(ERROR);
			CONTINUE;
		ELSIF (THIS^.isEqual(set)) THEN
			cycleManager.proceedWith(SUCCESS);
			CONTINUE;
		END_IF 
		cycleManager.configuration.sequence.requireSuccessStep := FALSE;
		IF set.size = 0 THEN
			THIS^.clear();
			cycleManager.proceedWith(SUCCESS);
			CONTINUE;
		END_IF
		
		
		IF (set.createNewIterator(iterator => THIS^.intersectIterator) <> CNM_ReturnTypes.SingleExecutionResult.SUCCESS) THEN
			cycleManager.proceedWith(ERROR);
			CONTINUE;	
		END_IF
		THIS^.intersectedTree := __NEW(BalancedBinarySearchTree( nodeComparator := THIS^.nodeComparator));
		IF THIS^.intersectedTree <> 0 THEN
			THIS^.intersectIterator.destruct();
			cycleManager.proceedWith(ERROR);
			CONTINUE;	
		END_IF
		THIS^.intersectIterator.iterate(FALSE);
		cycleManager.proceed();
		
	PROCESSING:
		CASE THIS^.intersectIterator.iterate(execute := TRUE, object => iteratedObject) OF
		CNM_ReturnTypes.SingleExecutionState.BUSY:
			IF THIS^.getEqualObject(object := iteratedObject, foundObject => intersectObject) THEN
				IF (THIS^.intersectedTree^.insert(intersectObject) <> CNM_ReturnTypes.SingleExecutionResult.ERROR) THEN
					insertOperationsThisCycle := insertOperationsThisCycle + log2(THIS^.intersectedTree^.size);
				ELSE
					cycleManager.proceedWith(ERROR);
					CONTINUE;
				END_IF
			END_IF
			insertOperationsThisCycle := insertOperationsThisCycle + log2(THIS^.size);
		CNM_ReturnTypes.SingleExecutionState.ERROR:
			cycleManager.proceedWith(ERROR);
			CONTINUE;
		CNM_ReturnTypes.SingleExecutionState.SUCCESS:
			THIS^.clear();
			THIS^.root := THIS^.intersectedTree^.root;
			THIS^.size := THIS^.intersectedTree^.size;
			THIS^.intersectedTree^.root := 0;
			THIS^.intersectedTree^.destruct();
			THIS^.intersectedTree := 0;
			THIS^.intersectIterator.destruct();
			THIS^.intersectIterator := 0;
			cycleManager.proceedWith(SUCCESS);
			CONTINUE;
		END_CASE
	
	ERROR:
		THIS^.intersectIterator.destruct();
		THIS^.intersectIterator := 0;
		__DELETE(THIS^.intersectedTree);
		THIS^.intersectedTree := 0;
	END_CASE	
UNTIL
	(insertOperationsThisCycle >= THIS^.maxCycleCompares) OR_ELSE
	(cycleManager.state <> CNM_ReturnTypes.SingleExecutionState.BUSY)
END_REPEAT

intersect := cycleManager.state;