RoomModel cGenRef {
	import room.basic.types.* from "Types.room"
	
	LogicalSystem LS {
		SubSystemRef sys1: SubSys
//		SubSystemRef sys2: SubSys
	}
	
	SubSystemClass SubSys {
		ActorRef Sender: Sender
		ActorRef Receiver: Receiver
		Binding Sender.dataOut and Receiver.dataIn
	
		LogicalThread dflt_thread
		LogicalThread other_thread
		
		ActorInstanceMapping Receiver -> dflt_thread
		ActorInstanceMapping Sender -> other_thread
	}

//	SubSystemClass SubSysSomewhatBigger {
//		ActorRef Receiver: Receiver
//		ActorRef Sender: Sender
//		ActorRef Broadcast: Broadcast
//		ActorRef Receiver2: Receiver
//		ActorRef ref0: Broadcast
//		ActorRef ref1: Broadcast
//		ActorRef ref2: Receiver
//		ActorRef ref3: Receiver
//		Binding Sender.dataOut and Broadcast.dataIn
//		Binding Broadcast.dataOut and ref0.dataIn
//		Binding Broadcast.dataOut and ref1.dataIn
//		Binding Receiver.dataIn and ref0.dataOut
//		Binding Receiver2.dataIn and ref0.dataOut
//		Binding ref2.dataIn and ref1.dataOut
//		Binding ref3.dataIn and ref1.dataOut
//	}

	async ActorClass Receiver {
		Interface {
			Port dataIn: CommunicationProtocol
		}
		Structure {
			external Port dataIn
			Attribute attr1: DataClass1
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Idle { }
				Transition tr0: Idle -> DataReceived {
					triggers {
						<sendData: dataIn>
					}
					action {
						"dataIn.receivedData();"
					}
				}
				Transition tr1: DataReceived -> DataReceived {
					triggers {
						<sendData: dataIn>
					}
					action {
						"dataIn.receivedData();"
					}
				}
				State Idle
				State DataReceived
			}
		}
	}

	ActorClass Broadcast {
		Interface {
			Port dataIn: CommunicationProtocol
			conjugated Port dataOut [2]: CommunicationProtocol
		}
		Structure {
			external Port dataIn
			external Port dataOut
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Idle { }
				Transition tr0: Idle -> tp0 of Sending {
					triggers {
						<sendData: dataIn>
					}
					action {
						"dataOut.sendData();"
					}
				}
				Transition tr1: tp1 of Sending -> ReceivedBoth {
					action {
						"dataIn.receivedData();"
					}
				}
				State Idle
				State Sending {
					subgraph {
						Transition tr0: my tp0 -> WaitingForReceived
						Transition tr1: WaitingForReceived -> ReceivedOne {
							triggers {
								<receivedData: dataOut>
							}
							action {
								"// Kommentar"
							}
						}
						Transition tr3: ReceivedOne -> my tp1 {
							triggers {
								<receivedData: dataOut>
							}
						}
						EntryPoint tp0
						ExitPoint tp1
						State WaitingForReceived
						State ReceivedOne
					}
				}
				State ReceivedBoth
			}
		}
	}

	ActorClass SenderManual {
		Interface {
			conjugated Port dataOut: CommunicationProtocol
		}
		Structure {
			external Port dataOut
			Attribute attribute1: int32
			Attribute attribute2: DataClass1
		}
		Behavior {
			//@BehaviorManual
			Operation operation1(argument1:int32, argument2: DataClass1 ref){""}
		}
	}
	ActorClass ReceiverManual {
		Interface {
			Port dataIn: CommunicationProtocol
		}
		Structure {
			external Port dataIn
		}
		Behavior {
			//@BehaviorManual
		}
	}
	
	

	async ActorClass Sender {
		Interface {
			conjugated Port dataOut: CommunicationProtocol
		}
		Structure {
			external Port dataOut
			Attribute counter: int32
			
		}
		Behavior {
			StateMachine {
				Transition init: initial -> SendingData {
					action {
						"counter=0;"
					}
				}
				Transition tr0: SendingData -> cp cp0 {
					triggers {
						<receivedData: dataOut>
					}
					action {
						"counter++;"
					}
				}
				Transition tr1: cp cp0 -> Done
				Transition tr2: cp cp0 -> SendingData {
					cond {
						"counter<10"
					}
				}
				ChoicePoint cp0
				State SendingData {
					entry {
						"dataOut.sendData();"
					}
					do {
						"etLogger_logInfo(\">>> sending tick\");"
					}
				}
				State Done {
					entry {
						"etLogger_logInfo(\"+++   Sender Done   +++\");"
					}
					do {
						"etLogger_logInfo(\">>> done tick\");"
						"if (++counter>20) etUnit_testFinished();"
					}
				}
			}
		}
	}

	ProtocolClass CommunicationProtocol {
		incoming {
			Message sendData()
		}
		outgoing {
			Message receivedData()
		}
	}
	
	ProtocolClass etRTSystemServicesProtocol {
		incoming {
			Message poll()
		}
	}
	
	DataClass DataClass1 {
		usercode1 {"// usercode1"}
		usercode2 {"// usercode2"}
		usercode3 {"// usercode3"}
		Attribute Attr1: int32
		Attribute ComplexAttr: DataClass2 
		Attribute Attr3: float32
		
		Operation MultiplyWithAttr1(value: int32): int32 {
			"return Attr1*value;"
		}
		Operation MultiplyWithAttr3(value: float32): float32 {
			"return Attr3*value;"
		}
	}

	DataClass DataClass2 {
		Attribute Attr1: int32
		Attribute Attr2: float32
		Attribute Attr3: int32
		Operation Operation1() {"/*nothing to do*/"}
	}

}