/**
 * Copyright (c) 2011, 2016 - 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 
 * 
 *  Based on ideas from Xtext, Xtend, Xcore
 *   
 *  Contributors:  
 *  		Christophe Loetz (Loetz GmbH&Co.KG) - Initial implementation 
 *  
 */
package org.eclipse.osbp.xtext.datamartdsl.impl;

import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;

import org.eclipse.osbp.xtext.authorizationdsl.Role;

import org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage;
import org.eclipse.osbp.xtext.datamartdsl.DatamartRole;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Datamart Role</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.osbp.xtext.datamartdsl.impl.DatamartRoleImpl#getAssignedRole <em>Assigned Role</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class DatamartRoleImpl extends DatamartLazyResolverImpl implements DatamartRole {
	/**
	 * The cached value of the '{@link #getAssignedRole() <em>Assigned Role</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getAssignedRole()
	 * @generated
	 * @ordered
	 */
	protected Role assignedRole;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected DatamartRoleImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return DatamartDSLPackage.Literals.DATAMART_ROLE;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Role getAssignedRole() {
		if (assignedRole != null && assignedRole.eIsProxy()) {
			InternalEObject oldAssignedRole = (InternalEObject)assignedRole;
			assignedRole = (Role)eResolveProxy(oldAssignedRole);
			if (assignedRole != oldAssignedRole) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE, oldAssignedRole, assignedRole));
			}
		}
		return assignedRole;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Role basicGetAssignedRole() {
		return assignedRole;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setAssignedRole(Role newAssignedRole) {
		Role oldAssignedRole = assignedRole;
		assignedRole = newAssignedRole;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE, oldAssignedRole, assignedRole));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE:
				if (resolve) return getAssignedRole();
				return basicGetAssignedRole();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE:
				setAssignedRole((Role)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE:
				setAssignedRole((Role)null);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case DatamartDSLPackage.DATAMART_ROLE__ASSIGNED_ROLE:
				return assignedRole != null;
		}
		return super.eIsSet(featureID);
	}

} //DatamartRoleImpl
