/**
 *  Copyright (c)2020 CEA LIST, Committer Name, and others.
 * 
 *  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:
 *  CEA LIST - Initial API and implementation
 *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
 *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
 * 
 */
package org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign;


/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>CITS Frame</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCITSFrameID <em>CITS Frame ID</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}</li>
 *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame()
 * @model
 * @generated
 */
public interface CITSFrame extends Data {
	/**
	 * Returns the value of the '<em><b>Time</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Time</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Time</em>' attribute.
	 * @see #setTime(String)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Time()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getTime();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Time</em>' attribute.
	 * @see #getTime()
	 * @generated
	 */
	void setTime(String value);

	/**
	 * Returns the value of the '<em><b>Vehicle ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Vehicle ID</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Vehicle ID</em>' attribute.
	 * @see #setVehicleID(String)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_VehicleID()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getVehicleID();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Vehicle ID</em>' attribute.
	 * @see #getVehicleID()
	 * @generated
	 */
	void setVehicleID(String value);

	/**
	 * Returns the value of the '<em><b>Latitude</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Latitude</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Latitude</em>' attribute.
	 * @see #setLatitude(double)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Latitude()
	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
	 * @generated
	 */
	double getLatitude();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Latitude</em>' attribute.
	 * @see #getLatitude()
	 * @generated
	 */
	void setLatitude(double value);

	/**
	 * Returns the value of the '<em><b>Longitude</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Longitude</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Longitude</em>' attribute.
	 * @see #setLongitude(double)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Longitude()
	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
	 * @generated
	 */
	double getLongitude();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Longitude</em>' attribute.
	 * @see #getLongitude()
	 * @generated
	 */
	void setLongitude(double value);

	/**
	 * Returns the value of the '<em><b>Speed Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Speed Value</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Speed Value</em>' attribute.
	 * @see #setSpeedValue(double)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_SpeedValue()
	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
	 * @generated
	 */
	double getSpeedValue();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Speed Value</em>' attribute.
	 * @see #getSpeedValue()
	 * @generated
	 */
	void setSpeedValue(double value);

	/**
	 * Returns the value of the '<em><b>Heading Value</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Heading Value</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Heading Value</em>' attribute.
	 * @see #setHeadingValue(double)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_HeadingValue()
	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
	 * @generated
	 */
	double getHeadingValue();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Heading Value</em>' attribute.
	 * @see #getHeadingValue()
	 * @generated
	 */
	void setHeadingValue(double value);

	/**
	 * Returns the value of the '<em><b>Brake Pedal Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Brake Pedal Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Brake Pedal Engaged</em>' attribute.
	 * @see #setBrakePedalEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_BrakePedalEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isBrakePedalEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Brake Pedal Engaged</em>' attribute.
	 * @see #isBrakePedalEngaged()
	 * @generated
	 */
	void setBrakePedalEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Gas Pedal Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Gas Pedal Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Gas Pedal Engaged</em>' attribute.
	 * @see #setGasPedalEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_GasPedalEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isGasPedalEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Gas Pedal Engaged</em>' attribute.
	 * @see #isGasPedalEngaged()
	 * @generated
	 */
	void setGasPedalEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Emergency Brake Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Emergency Brake Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Emergency Brake Engaged</em>' attribute.
	 * @see #setEmergencyBrakeEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_EmergencyBrakeEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isEmergencyBrakeEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Emergency Brake Engaged</em>' attribute.
	 * @see #isEmergencyBrakeEngaged()
	 * @generated
	 */
	void setEmergencyBrakeEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Collision Warning Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Collision Warning Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Collision Warning Engaged</em>' attribute.
	 * @see #setCollisionWarningEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CollisionWarningEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isCollisionWarningEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Collision Warning Engaged</em>' attribute.
	 * @see #isCollisionWarningEngaged()
	 * @generated
	 */
	void setCollisionWarningEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Acc Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Acc Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Acc Engaged</em>' attribute.
	 * @see #setAccEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_AccEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isAccEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Acc Engaged</em>' attribute.
	 * @see #isAccEngaged()
	 * @generated
	 */
	void setAccEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Cruise Control Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Cruise Control Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Cruise Control Engaged</em>' attribute.
	 * @see #setCruiseControlEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CruiseControlEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isCruiseControlEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Cruise Control Engaged</em>' attribute.
	 * @see #isCruiseControlEngaged()
	 * @generated
	 */
	void setCruiseControlEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Speed Limiter Engaged</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Speed Limiter Engaged</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Speed Limiter Engaged</em>' attribute.
	 * @see #setSpeedLimiterEngaged(boolean)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_SpeedLimiterEngaged()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isSpeedLimiterEngaged();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Speed Limiter Engaged</em>' attribute.
	 * @see #isSpeedLimiterEngaged()
	 * @generated
	 */
	void setSpeedLimiterEngaged(boolean value);

	/**
	 * Returns the value of the '<em><b>Certificate ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Certificate ID</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Certificate ID</em>' attribute.
	 * @see #setCertificateID(String)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CertificateID()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getCertificateID();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Certificate ID</em>' attribute.
	 * @see #getCertificateID()
	 * @generated
	 */
	void setCertificateID(String value);

	/**
	 * Returns the value of the '<em><b>CITS Frame ID</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>CITS Frame ID</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>CITS Frame ID</em>' attribute.
	 * @see #setCITSFrameID(String)
	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CITSFrameID()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getCITSFrameID();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCITSFrameID <em>CITS Frame ID</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>CITS Frame ID</em>' attribute.
	 * @see #getCITSFrameID()
	 * @generated
	 */
	void setCITSFrameID(String value);

} // CITSFrame
