/**
 * Copyright (c) 2020 CEA LIST
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 * 
 */
package org.eclipse.papyrus.aiml.profile.AIML.Pooling_layers.impl;

import java.util.Collection;

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

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.EClass;

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

import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;

import org.eclipse.papyrus.aiml.profile.AIML.Pooling_layers.Pooling_layersPackage;
import org.eclipse.papyrus.aiml.profile.AIML.Pooling_layers.Pooling_layers_1_1_1_1;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Pooling layers 1111</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Pooling_layers.impl.Pooling_layers_1_1_1_1Impl#isCeil_mode <em>Ceil mode</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Pooling_layers.impl.Pooling_layers_1_1_1_1Impl#getPool_size <em>Pool size</em>}</li>
 * </ul>
 *
 * @generated
 */
public abstract class Pooling_layers_1_1_1_1Impl extends Pooling_layers_1_1_1Impl implements Pooling_layers_1_1_1_1 {
	/**
	 * The default value of the '{@link #isCeil_mode() <em>Ceil mode</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #isCeil_mode()
	 * @generated
	 * @ordered
	 */
	protected static final boolean CEIL_MODE_EDEFAULT = false;

	/**
	 * The cached value of the '{@link #isCeil_mode() <em>Ceil mode</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #isCeil_mode()
	 * @generated
	 * @ordered
	 */
	protected boolean ceil_mode = CEIL_MODE_EDEFAULT;

	/**
	 * The cached value of the '{@link #getPool_size() <em>Pool size</em>}' attribute list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getPool_size()
	 * @generated
	 * @ordered
	 */
	protected EList<Integer> pool_size;

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

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

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean isCeil_mode() {
		return ceil_mode;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void setCeil_mode(boolean newCeil_mode) {
		boolean oldCeil_mode = ceil_mode;
		ceil_mode = newCeil_mode;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, Pooling_layersPackage.POOLING_LAYERS_1111__CEIL_MODE, oldCeil_mode, ceil_mode));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public EList<Integer> getPool_size() {
		if (pool_size == null) {
			pool_size = new EDataTypeUniqueEList<Integer>(Integer.class, this, Pooling_layersPackage.POOLING_LAYERS_1111__POOL_SIZE);
		}
		return pool_size;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case Pooling_layersPackage.POOLING_LAYERS_1111__CEIL_MODE:
				return isCeil_mode();
			case Pooling_layersPackage.POOLING_LAYERS_1111__POOL_SIZE:
				return getPool_size();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case Pooling_layersPackage.POOLING_LAYERS_1111__CEIL_MODE:
				setCeil_mode((Boolean)newValue);
				return;
			case Pooling_layersPackage.POOLING_LAYERS_1111__POOL_SIZE:
				getPool_size().clear();
				getPool_size().addAll((Collection<? extends Integer>)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case Pooling_layersPackage.POOLING_LAYERS_1111__CEIL_MODE:
				setCeil_mode(CEIL_MODE_EDEFAULT);
				return;
			case Pooling_layersPackage.POOLING_LAYERS_1111__POOL_SIZE:
				getPool_size().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case Pooling_layersPackage.POOLING_LAYERS_1111__CEIL_MODE:
				return ceil_mode != CEIL_MODE_EDEFAULT;
			case Pooling_layersPackage.POOLING_LAYERS_1111__POOL_SIZE:
				return pool_size != null && !pool_size.isEmpty();
		}
		return super.eIsSet(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public String toString() {
		if (eIsProxy()) return super.toString();

		StringBuilder result = new StringBuilder(super.toString());
		result.append(" (ceil_mode: "); //$NON-NLS-1$
		result.append(ceil_mode);
		result.append(", pool_size: "); //$NON-NLS-1$
		result.append(pool_size);
		result.append(')');
		return result.toString();
	}

} //Pooling_layers_1_1_1_1Impl
