/**
 */
package org.eclipse.emf.parsley.tests.models.testmodels;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.FeatureMap;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Class For Controls</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#isBooleanFeature <em>Boolean Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getBooleanObjectFeature <em>Boolean Object Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getBooleanDataTypeFeature <em>Boolean Data Type Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#isBooleanPrimitiveDataTypeFeature <em>Boolean Primitive Data Type Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getEnumFeature <em>Enum Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getStringFeature <em>String Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getUnchangeableStringFeature <em>Unchangeable String Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getReferenceToClassWithName <em>Reference To Class With Name</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getMultiReferenceFeature <em>Multi Reference Feature</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getFeatureMapEntries <em>Feature Map Entries</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getFeatureMapEntries1 <em>Feature Map Entries1</em>}</li>
 *   <li>{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getFeatureMapEntries2 <em>Feature Map Entries2</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls()
 * @model
 * @generated
 */
public interface ClassForControls extends EObject {
	/**
	 * Returns the value of the '<em><b>Boolean Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Boolean Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Boolean Feature</em>' attribute.
	 * @see #setBooleanFeature(boolean)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_BooleanFeature()
	 * @model
	 * @generated
	 */
	boolean isBooleanFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#isBooleanFeature <em>Boolean Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Boolean Feature</em>' attribute.
	 * @see #isBooleanFeature()
	 * @generated
	 */
	void setBooleanFeature(boolean value);

	/**
	 * Returns the value of the '<em><b>Boolean Object Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Boolean Object Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Boolean Object Feature</em>' attribute.
	 * @see #setBooleanObjectFeature(Boolean)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_BooleanObjectFeature()
	 * @model
	 * @generated
	 */
	Boolean getBooleanObjectFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getBooleanObjectFeature <em>Boolean Object Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Boolean Object Feature</em>' attribute.
	 * @see #getBooleanObjectFeature()
	 * @generated
	 */
	void setBooleanObjectFeature(Boolean value);

	/**
	 * Returns the value of the '<em><b>Boolean Data Type Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Boolean Data Type Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Boolean Data Type Feature</em>' attribute.
	 * @see #setBooleanDataTypeFeature(Boolean)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_BooleanDataTypeFeature()
	 * @model dataType="org.eclipse.emf.parsley.tests.models.testmodels.BooleanDataType"
	 * @generated
	 */
	Boolean getBooleanDataTypeFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getBooleanDataTypeFeature <em>Boolean Data Type Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Boolean Data Type Feature</em>' attribute.
	 * @see #getBooleanDataTypeFeature()
	 * @generated
	 */
	void setBooleanDataTypeFeature(Boolean value);

	/**
	 * Returns the value of the '<em><b>Boolean Primitive Data Type Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Boolean Primitive Data Type Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Boolean Primitive Data Type Feature</em>' attribute.
	 * @see #setBooleanPrimitiveDataTypeFeature(boolean)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_BooleanPrimitiveDataTypeFeature()
	 * @model dataType="org.eclipse.emf.parsley.tests.models.testmodels.BooleanPrimitiveDataType"
	 * @generated
	 */
	boolean isBooleanPrimitiveDataTypeFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#isBooleanPrimitiveDataTypeFeature <em>Boolean Primitive Data Type Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Boolean Primitive Data Type Feature</em>' attribute.
	 * @see #isBooleanPrimitiveDataTypeFeature()
	 * @generated
	 */
	void setBooleanPrimitiveDataTypeFeature(boolean value);

	/**
	 * Returns the value of the '<em><b>Enum Feature</b></em>' attribute.
	 * The literals are from the enumeration {@link org.eclipse.emf.parsley.tests.models.testmodels.EnumForControls}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Enum Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Enum Feature</em>' attribute.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.EnumForControls
	 * @see #setEnumFeature(EnumForControls)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_EnumFeature()
	 * @model
	 * @generated
	 */
	EnumForControls getEnumFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getEnumFeature <em>Enum Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Enum Feature</em>' attribute.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.EnumForControls
	 * @see #getEnumFeature()
	 * @generated
	 */
	void setEnumFeature(EnumForControls value);

	/**
	 * Returns the value of the '<em><b>String Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>String Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>String Feature</em>' attribute.
	 * @see #setStringFeature(String)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_StringFeature()
	 * @model
	 * @generated
	 */
	String getStringFeature();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getStringFeature <em>String Feature</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>String Feature</em>' attribute.
	 * @see #getStringFeature()
	 * @generated
	 */
	void setStringFeature(String value);

	/**
	 * Returns the value of the '<em><b>Unchangeable String Feature</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Unchangeable String Feature</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Unchangeable String Feature</em>' attribute.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_UnchangeableStringFeature()
	 * @model changeable="false"
	 * @generated
	 */
	String getUnchangeableStringFeature();

	/**
	 * Returns the value of the '<em><b>Reference To Class With Name</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Reference To Class With Name</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Reference To Class With Name</em>' reference.
	 * @see #setReferenceToClassWithName(ClassWithName)
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_ReferenceToClassWithName()
	 * @model
	 * @generated
	 */
	ClassWithName getReferenceToClassWithName();

	/**
	 * Sets the value of the '{@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForControls#getReferenceToClassWithName <em>Reference To Class With Name</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Reference To Class With Name</em>' reference.
	 * @see #getReferenceToClassWithName()
	 * @generated
	 */
	void setReferenceToClassWithName(ClassWithName value);

	/**
	 * Returns the value of the '<em><b>Multi Reference Feature</b></em>' reference list.
	 * The list contents are of type {@link org.eclipse.emf.parsley.tests.models.testmodels.ClassWithName}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Multi Reference Feature</em>' reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Multi Reference Feature</em>' reference list.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_MultiReferenceFeature()
	 * @model
	 * @generated
	 */
	EList<ClassWithName> getMultiReferenceFeature();

	/**
	 * Returns the value of the '<em><b>Feature Map Entries</b></em>' attribute list.
	 * The list contents are of type {@link org.eclipse.emf.ecore.util.FeatureMap.Entry}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Feature Map Entries</em>' attribute list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Feature Map Entries</em>' attribute list.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_FeatureMapEntries()
	 * @model dataType="org.eclipse.emf.ecore.EFeatureMapEntry" many="true"
	 *        extendedMetaData="kind='group'"
	 * @generated
	 */
	FeatureMap getFeatureMapEntries();

	/**
	 * Returns the value of the '<em><b>Feature Map Entries1</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForFeatureMapEntry1}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Feature Map Entries1</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Feature Map Entries1</em>' containment reference list.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_FeatureMapEntries1()
	 * @model containment="true" transient="true" volatile="true" derived="true"
	 *        extendedMetaData="group='#featureMapEntries'"
	 * @generated
	 */
	EList<ClassForFeatureMapEntry1> getFeatureMapEntries1();

	/**
	 * Returns the value of the '<em><b>Feature Map Entries2</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.emf.parsley.tests.models.testmodels.ClassForFeatureMapEntry2}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Feature Map Entries2</em>' containment reference list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Feature Map Entries2</em>' containment reference list.
	 * @see org.eclipse.emf.parsley.tests.models.testmodels.TestmodelsPackage#getClassForControls_FeatureMapEntries2()
	 * @model containment="true" transient="true" volatile="true" derived="true"
	 *        extendedMetaData="group='#featureMapEntries'"
	 * @generated
	 */
	EList<ClassForFeatureMapEntry2> getFeatureMapEntries2();

} // ClassForControls
