plugins/bt/org.eclipse.papyrus.robotics.bt.xsdgw.uml2xml/transforms/btSetChildLib.qvto

/*****************************************************************************
 * Copyright (c) 2019, 2023 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *  Matteo MORELLI (CEA LIST) <matteo.morelli@cea.fr> - Initial API and implementation
 *  Matteo MORELLI (CEA LIST) <matteo.morelli@cea.fr> - Bug #581697
 *  Matteo MORELLI (CEA LIST) <matteo.morelli@cea.fr> - Bug #581733
 *****************************************************************************/

library btSetChildLib;

modeltype BTS uses 'https://github.com/BehaviorTree/BehaviorTree.CPP/behaviortree_schema.xsd';
modeltype ECORE uses 'http://www.eclipse.org/emf/2002/Ecore';

-- ==============
-- === parent ===
-- ==============

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : EObject, in child : EObject) {
	switch {
		case (parent.oclIsKindOf(BehaviorTreeType))  { setBtChildNode(parent.oclAsType(BehaviorTreeType),child) }
		case (parent.oclIsKindOf(SequenceType))      { setBtChildNode(parent.oclAsType(SequenceType),child) }
		case (parent.oclIsKindOf(ReactiveSequenceType))      { setBtChildNode(parent.oclAsType(ReactiveSequenceType),child) }
		case (parent.oclIsKindOf(ParallelType))      { setBtChildNode(parent.oclAsType(ParallelType),child) }
		case (parent.oclIsKindOf(FallbackType))      { setBtChildNode(parent.oclAsType(FallbackType),child) }
		case (parent.oclIsKindOf(ReactiveFallbackType))      { setBtChildNode(parent.oclAsType(ReactiveFallbackType),child) }
		case (parent.oclIsKindOf(InverterType))      { setBtChildNode(parent.oclAsType(InverterType),child) }
		case (parent.oclIsKindOf(RepeatType))        { setBtChildNode(parent.oclAsType(RepeatType),child) }
		case (parent.oclIsKindOf(RetryType))         { setBtChildNode(parent.oclAsType(RetryType),child) }
		else {
			assert fatal (false)
                with log('Unknown parent node type (\''+ parent.eClass().name +'\')!');
		}
	};
}

-- ========================
-- === child management ===
-- ========================

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : BehaviorTreeType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus := child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence := child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel := child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback := child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   := child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition:= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter := child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   := child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   := child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : SequenceType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  += child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence += child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel += child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback += child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   += child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition+= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter += child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   += child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   += child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : ReactiveSequenceType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  += child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence += child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel += child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback += child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   += child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition+= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter += child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   += child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   += child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : ParallelType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  += child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence += child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel += child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback += child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   += child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition+= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter += child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   += child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   += child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : FallbackType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  += child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence += child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel += child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback += child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   += child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition+= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter += child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   += child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   += child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : ReactiveFallbackType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  += child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence += child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel += child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback += child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   += child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition+= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter += child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   += child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   += child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : InverterType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  := child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence := child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel := child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback := child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   := child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition:= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter := child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   := child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   := child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : RepeatType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  := child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence := child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel := child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback := child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   := child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition:= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter := child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   := child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   := child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}

/**
 * Tbd.
 */
helper setBtChildNode(inout parent : RetryType, in child : EObject) {
	switch {
		case (child.oclIsKindOf(SubTreePlusType))  { parent.subtreeplus  := child.oclAsType(SubTreePlusType) }
		case (child.oclIsKindOf(SequenceType)) { parent.sequence := child.oclAsType(SequenceType) }
		case (child.oclIsKindOf(ReactiveSequenceType)) { parent.reactiveSequence := child.oclAsType(ReactiveSequenceType) }
		case (child.oclIsKindOf(ParallelType)) { parent.parallel := child.oclAsType(ParallelType) }
		case (child.oclIsKindOf(FallbackType)) { parent.fallback := child.oclAsType(FallbackType) }
		case (child.oclIsKindOf(ReactiveFallbackType)) { parent.reactiveFallback := child.oclAsType(ReactiveFallbackType) }
		case (child.oclIsKindOf(ActionType))   { parent.action   := child.oclAsType(ActionType) }
		case (child.oclIsKindOf(ConditionType)){ parent.condition:= child.oclAsType(ConditionType) }
		case (child.oclIsKindOf(InverterType)) { parent.inverter := child.oclAsType(InverterType) }
		case (child.oclIsKindOf(RepeatType))   { parent.repeat   := child.oclAsType(RepeatType) }
		case (child.oclIsKindOf(RetryType))    { parent.retryUntilSuccessful   := child.oclAsType(RetryType) }
		else {
			assert fatal (false)
                with log('Unknown child node type (\''+ child.eClass().name +'\')!');
		}
	};
}