@GenModel(fileExtensions="signal")
@GenModel(modelName="SignalDSL")
@GenModel(prefix="SignalDSL")
// force bigModel == false
@GenModel(loadInitialization="false")
@GenModel(literalsInterface="true")

@GenModel(copyrightText="Copyright (c) 2011, 2018 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 All rights reserved. This program and the accompanying materials
 are made available under the terms of the Eclipse Public License v1.0
 which accompanies this distribution, and is available at
 http://www.eclipse.org/legal/epl-v10.html
 
 Contributors:                                                      
    Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 
 generated from SignalDSL.xcore

 ")
@GenModel(updateClasspath="false")
@Ecore(nsURI="http://osbp.eclipse.org/xtext/signal/SignalDSL")
@Ecore(nsPrefix="signaldsl")
@Ecore(rootPackage="signaldsl")
package org.eclipse.osbp.xtext.signal

import org.eclipse.emf.ecore.EObject
import org.eclipse.emf.ecore.InternalEObject
import org.eclipse.osbp.dsl.semantic.common.types.LPackage
import org.eclipse.osbp.xtext.datainterchange.DataInterchange
import org.eclipse.osbp.xtext.oxtype.resource.EcoreUtil3
import org.eclipse.xtext.xtype.XImportSection

class SignalModel{
	contains XImportSection importSection
	contains SignalPackage[] packages
}

type InternalEObject wraps InternalEObject

class SignalLazyResolver {
	op EObject eResolveProxy(InternalEObject proxy) {
		return EcoreUtil3.resolve(proxy, this.eResource().resourceSet);
	}
}

class SignalPackage extends LPackage {
	contains SignalWatcher[] watchers
	contains SignalHandler[] handlers
}

class SignalBase extends SignalLazyResolver{
	String name
}

class SignalWatcher extends SignalLazyResolver {
	String name
	String directory
	SignalTypeEnum signal
	contains SignalHandler[] handlers
}

class SignalHandler extends SignalLazyResolver {
	String name
	SignalHandlerTypeEnum actionType
	String filemask
	contains SignalDatainterchange[] datainterchanges
	contains DataTransfer data
//	contains SignalNotification notification
}

interface SignalProcessor extends SignalLazyResolver {}

class SignalDatainterchange extends SignalProcessor {
	SignalActionEnum dataAction
	refers DataInterchange dataRef
}

class DataTransfer extends SignalLazyResolver {
}

class SingleTransfer extends DataTransfer {
	contains SignalDatainterchange interchange
}

class ListTransfer extends DataTransfer {
	SignalExecutionTypeEnum executiontype
	contains SignalDatainterchange[] interchanges
}

enum SignalHandlerTypeEnum {
	doafter as 'doAfter'	
	doaftermodify as 'doAfterModify'
	doaftercreate as 'doAfterCreate'
	doafterdelete as 'doAfterDelete'
}

enum SignalTypeEnum{
	all as 'all'
	createsignals as 'createSignals' 
	deletesignals as 'deleteSignals' 
	modifysignals as 'modifySignals'
}

enum SignalActionEnum {
	DATAIMPORT as 'Import'
	DATAEXPORT as 'Export'
	NONE as 'None'
}

enum SignalExecutionTypeEnum {
	SYNC as 'synch'
	ASYNC as 'asynch'
}