/**
 * *******************************************************************************
 *  Copyright (c) 2017 Timing-Architects Embedded Systems GmbH and others.
 *  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
 * 
 *     Generated using Eclipse EMF
 * 
 * *******************************************************************************
 */
package org.eclipse.app4mc.amalthea.generator.configuration;

import org.eclipse.emf.ecore.EObject;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Activation Properties</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getPeriodicActivation <em>Periodic Activation</em>}</li>
 *   <li>{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getPeriodicTriangleShift <em>Periodic Triangle Shift</em>}</li>
 *   <li>{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getSporadicActivation <em>Sporadic Activation</em>}</li>
 * </ul>
 *
 * @see org.eclipse.app4mc.amalthea.generator.configuration.RTMGCPackage#getActivationProperties()
 * @model
 * @generated
 */
public interface ActivationProperties extends EObject {
	/**
	 * Returns the value of the '<em><b>Periodic Activation</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Periodic Activation</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Periodic Activation</em>' containment reference.
	 * @see #setPeriodicActivation(PeriodicActivation)
	 * @see org.eclipse.app4mc.amalthea.generator.configuration.RTMGCPackage#getActivationProperties_PeriodicActivation()
	 * @model containment="true" required="true"
	 * @generated
	 */
	PeriodicActivation getPeriodicActivation();

	/**
	 * Sets the value of the '{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getPeriodicActivation <em>Periodic Activation</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Periodic Activation</em>' containment reference.
	 * @see #getPeriodicActivation()
	 * @generated
	 */
	void setPeriodicActivation(PeriodicActivation value);

	/**
	 * Returns the value of the '<em><b>Periodic Triangle Shift</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Periodic Triangle Shift</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Periodic Triangle Shift</em>' containment reference.
	 * @see #setPeriodicTriangleShift(PeriodicTriangleShift)
	 * @see org.eclipse.app4mc.amalthea.generator.configuration.RTMGCPackage#getActivationProperties_PeriodicTriangleShift()
	 * @model containment="true" required="true"
	 * @generated
	 */
	PeriodicTriangleShift getPeriodicTriangleShift();

	/**
	 * Sets the value of the '{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getPeriodicTriangleShift <em>Periodic Triangle Shift</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Periodic Triangle Shift</em>' containment reference.
	 * @see #getPeriodicTriangleShift()
	 * @generated
	 */
	void setPeriodicTriangleShift(PeriodicTriangleShift value);

	/**
	 * Returns the value of the '<em><b>Sporadic Activation</b></em>' containment reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Sporadic Activation</em>' containment reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Sporadic Activation</em>' containment reference.
	 * @see #setSporadicActivation(SporadicActivation)
	 * @see org.eclipse.app4mc.amalthea.generator.configuration.RTMGCPackage#getActivationProperties_SporadicActivation()
	 * @model containment="true" required="true"
	 * @generated
	 */
	SporadicActivation getSporadicActivation();

	/**
	 * Sets the value of the '{@link org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties#getSporadicActivation <em>Sporadic Activation</em>}' containment reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Sporadic Activation</em>' containment reference.
	 * @see #getSporadicActivation()
	 * @generated
	 */
	void setSporadicActivation(SporadicActivation value);

} // ActivationProperties
