egenerictype_impl.go

// Code generated by soft.generator.go. DO NOT EDIT.

// *****************************************************************************
// Copyright(c) 2021 MASA Group
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//
// *****************************************************************************

package ecore

// eGenericTypeImpl is the implementation of the model object 'EGenericType'
type eGenericTypeImpl struct {
	CompactEObjectContainer
	eClassifier    EClassifier
	eLowerBound    EGenericType
	eRawType       EClassifier
	eTypeArguments EList
	eTypeParameter ETypeParameter
	eUpperBound    EGenericType
}
type eGenericTypeImplInitializers interface {
	initETypeArguments() EList
}

// newEGenericTypeImpl is the constructor of a eGenericTypeImpl
func newEGenericTypeImpl() *eGenericTypeImpl {
	eGenericType := new(eGenericTypeImpl)
	eGenericType.SetInterfaces(eGenericType)
	eGenericType.Initialize()
	return eGenericType
}

func (eGenericType *eGenericTypeImpl) Initialize() {
	eGenericType.CompactEObjectContainer.Initialize()

}

func (eGenericType *eGenericTypeImpl) asEGenericType() EGenericType {
	return eGenericType.GetInterfaces().(EGenericType)
}

func (eGenericType *eGenericTypeImpl) asInitializers() eGenericTypeImplInitializers {
	return eGenericType.AsEObject().(eGenericTypeImplInitializers)
}

func (eGenericType *eGenericTypeImpl) EStaticClass() EClass {
	return GetPackage().GetEGenericType()
}

func (eGenericType *eGenericTypeImpl) EStaticFeatureCount() int {
	return EGENERIC_TYPE_FEATURE_COUNT
}

// IsInstance default implementation
func (eGenericType *eGenericTypeImpl) IsInstance(interface{}) bool {
	panic("IsInstance not implemented")
}

// GetEClassifier get the value of eClassifier
func (eGenericType *eGenericTypeImpl) GetEClassifier() EClassifier {
	if eGenericType.eClassifier != nil && eGenericType.eClassifier.EIsProxy() {
		oldEClassifier := eGenericType.eClassifier
		newEClassifier := eGenericType.EResolveProxy(oldEClassifier).(EClassifier)
		eGenericType.eClassifier = newEClassifier
		if newEClassifier != oldEClassifier {
			if eGenericType.ENotificationRequired() {
				eGenericType.ENotify(NewNotificationByFeatureID(eGenericType, RESOLVE, EGENERIC_TYPE__ECLASSIFIER, oldEClassifier, newEClassifier, NO_INDEX))
			}
		}
	}
	return eGenericType.eClassifier
}

func (eGenericType *eGenericTypeImpl) basicGetEClassifier() EClassifier {
	return eGenericType.eClassifier
}

// SetEClassifier set the value of eClassifier
func (eGenericType *eGenericTypeImpl) SetEClassifier(newEClassifier EClassifier) {
	oldEClassifier := eGenericType.eClassifier
	eGenericType.eClassifier = newEClassifier
	if eGenericType.ENotificationRequired() {
		eGenericType.ENotify(NewNotificationByFeatureID(eGenericType.AsEObject(), SET, EGENERIC_TYPE__ECLASSIFIER, oldEClassifier, newEClassifier, NO_INDEX))
	}
}

// GetELowerBound get the value of eLowerBound
func (eGenericType *eGenericTypeImpl) GetELowerBound() EGenericType {
	return eGenericType.eLowerBound
}

// SetELowerBound set the value of eLowerBound
func (eGenericType *eGenericTypeImpl) SetELowerBound(newELowerBound EGenericType) {
	if newELowerBound != eGenericType.eLowerBound {
		var notifications ENotificationChain
		if oldELowerBoundInternal, _ := eGenericType.eLowerBound.(EObjectInternal); oldELowerBoundInternal != nil {
			notifications = oldELowerBoundInternal.EInverseRemove(eGenericType, EOPPOSITE_FEATURE_BASE-EGENERIC_TYPE__ELOWER_BOUND, notifications)
		}
		if newELowerBoundInternal, _ := newELowerBound.(EObjectInternal); newELowerBoundInternal != nil {
			notifications = newELowerBoundInternal.EInverseAdd(eGenericType.AsEObject(), EOPPOSITE_FEATURE_BASE-EGENERIC_TYPE__ELOWER_BOUND, notifications)
		}
		notifications = eGenericType.basicSetELowerBound(newELowerBound, notifications)
		if notifications != nil {
			notifications.Dispatch()
		}
	}
}

func (eGenericType *eGenericTypeImpl) basicSetELowerBound(newELowerBound EGenericType, msgs ENotificationChain) ENotificationChain {
	oldELowerBound := eGenericType.eLowerBound
	eGenericType.eLowerBound = newELowerBound
	notifications := msgs
	if eGenericType.ENotificationRequired() {
		notification := NewNotificationByFeatureID(eGenericType.AsEObject(), SET, EGENERIC_TYPE__ELOWER_BOUND, oldELowerBound, newELowerBound, NO_INDEX)
		if notifications != nil {
			notifications.Add(notification)
		} else {
			notifications = notification
		}
	}
	return notifications
}

// GetERawType get the value of eRawType
func (eGenericType *eGenericTypeImpl) GetERawType() EClassifier {
	if eGenericType.eRawType != nil && eGenericType.eRawType.EIsProxy() {
		oldERawType := eGenericType.eRawType
		newERawType := eGenericType.EResolveProxy(oldERawType).(EClassifier)
		eGenericType.eRawType = newERawType
		if newERawType != oldERawType {
			if eGenericType.ENotificationRequired() {
				eGenericType.ENotify(NewNotificationByFeatureID(eGenericType, RESOLVE, EGENERIC_TYPE__ERAW_TYPE, oldERawType, newERawType, NO_INDEX))
			}
		}
	}
	return eGenericType.eRawType
}

func (eGenericType *eGenericTypeImpl) basicGetERawType() EClassifier {
	return eGenericType.eRawType
}

// GetETypeArguments get the value of eTypeArguments
func (eGenericType *eGenericTypeImpl) GetETypeArguments() EList {
	if eGenericType.eTypeArguments == nil {
		eGenericType.eTypeArguments = eGenericType.asInitializers().initETypeArguments()
	}
	return eGenericType.eTypeArguments
}

// GetETypeParameter get the value of eTypeParameter
func (eGenericType *eGenericTypeImpl) GetETypeParameter() ETypeParameter {
	return eGenericType.eTypeParameter
}

// SetETypeParameter set the value of eTypeParameter
func (eGenericType *eGenericTypeImpl) SetETypeParameter(newETypeParameter ETypeParameter) {
	oldETypeParameter := eGenericType.eTypeParameter
	eGenericType.eTypeParameter = newETypeParameter
	if eGenericType.ENotificationRequired() {
		eGenericType.ENotify(NewNotificationByFeatureID(eGenericType.AsEObject(), SET, EGENERIC_TYPE__ETYPE_PARAMETER, oldETypeParameter, newETypeParameter, NO_INDEX))
	}
}

// GetEUpperBound get the value of eUpperBound
func (eGenericType *eGenericTypeImpl) GetEUpperBound() EGenericType {
	return eGenericType.eUpperBound
}

// SetEUpperBound set the value of eUpperBound
func (eGenericType *eGenericTypeImpl) SetEUpperBound(newEUpperBound EGenericType) {
	if newEUpperBound != eGenericType.eUpperBound {
		var notifications ENotificationChain
		if oldEUpperBoundInternal, _ := eGenericType.eUpperBound.(EObjectInternal); oldEUpperBoundInternal != nil {
			notifications = oldEUpperBoundInternal.EInverseRemove(eGenericType, EOPPOSITE_FEATURE_BASE-EGENERIC_TYPE__EUPPER_BOUND, notifications)
		}
		if newEUpperBoundInternal, _ := newEUpperBound.(EObjectInternal); newEUpperBoundInternal != nil {
			notifications = newEUpperBoundInternal.EInverseAdd(eGenericType.AsEObject(), EOPPOSITE_FEATURE_BASE-EGENERIC_TYPE__EUPPER_BOUND, notifications)
		}
		notifications = eGenericType.basicSetEUpperBound(newEUpperBound, notifications)
		if notifications != nil {
			notifications.Dispatch()
		}
	}
}

func (eGenericType *eGenericTypeImpl) basicSetEUpperBound(newEUpperBound EGenericType, msgs ENotificationChain) ENotificationChain {
	oldEUpperBound := eGenericType.eUpperBound
	eGenericType.eUpperBound = newEUpperBound
	notifications := msgs
	if eGenericType.ENotificationRequired() {
		notification := NewNotificationByFeatureID(eGenericType.AsEObject(), SET, EGENERIC_TYPE__EUPPER_BOUND, oldEUpperBound, newEUpperBound, NO_INDEX)
		if notifications != nil {
			notifications.Add(notification)
		} else {
			notifications = notification
		}
	}
	return notifications
}

func (eGenericType *eGenericTypeImpl) initETypeArguments() EList {
	return NewBasicEObjectList(eGenericType.AsEObjectInternal(), EGENERIC_TYPE__ETYPE_ARGUMENTS, -1, true, true, false, false, false)
}

func (eGenericType *eGenericTypeImpl) EGetFromID(featureID int, resolve bool) interface{} {
	switch featureID {
	case EGENERIC_TYPE__ECLASSIFIER:
		if resolve {
			return eGenericType.asEGenericType().GetEClassifier()
		}
		return eGenericType.basicGetEClassifier()
	case EGENERIC_TYPE__ELOWER_BOUND:
		return eGenericType.asEGenericType().GetELowerBound()
	case EGENERIC_TYPE__ERAW_TYPE:
		if resolve {
			return eGenericType.asEGenericType().GetERawType()
		}
		return eGenericType.basicGetERawType()
	case EGENERIC_TYPE__ETYPE_ARGUMENTS:
		return eGenericType.asEGenericType().GetETypeArguments()
	case EGENERIC_TYPE__ETYPE_PARAMETER:
		return eGenericType.asEGenericType().GetETypeParameter()
	case EGENERIC_TYPE__EUPPER_BOUND:
		return eGenericType.asEGenericType().GetEUpperBound()
	default:
		return eGenericType.CompactEObjectContainer.EGetFromID(featureID, resolve)
	}
}

func (eGenericType *eGenericTypeImpl) ESetFromID(featureID int, newValue interface{}) {
	switch featureID {
	case EGENERIC_TYPE__ECLASSIFIER:
		eGenericType.asEGenericType().SetEClassifier(newValue.(EClassifier))
	case EGENERIC_TYPE__ELOWER_BOUND:
		eGenericType.asEGenericType().SetELowerBound(newValue.(EGenericType))
	case EGENERIC_TYPE__ETYPE_ARGUMENTS:
		list := eGenericType.asEGenericType().GetETypeArguments()
		list.Clear()
		list.AddAll(newValue.(EList))
	case EGENERIC_TYPE__ETYPE_PARAMETER:
		eGenericType.asEGenericType().SetETypeParameter(newValue.(ETypeParameter))
	case EGENERIC_TYPE__EUPPER_BOUND:
		eGenericType.asEGenericType().SetEUpperBound(newValue.(EGenericType))
	default:
		eGenericType.CompactEObjectContainer.ESetFromID(featureID, newValue)
	}
}

func (eGenericType *eGenericTypeImpl) EUnsetFromID(featureID int) {
	switch featureID {
	case EGENERIC_TYPE__ECLASSIFIER:
		eGenericType.asEGenericType().SetEClassifier(nil)
	case EGENERIC_TYPE__ELOWER_BOUND:
		eGenericType.asEGenericType().SetELowerBound(nil)
	case EGENERIC_TYPE__ETYPE_ARGUMENTS:
		eGenericType.asEGenericType().GetETypeArguments().Clear()
	case EGENERIC_TYPE__ETYPE_PARAMETER:
		eGenericType.asEGenericType().SetETypeParameter(nil)
	case EGENERIC_TYPE__EUPPER_BOUND:
		eGenericType.asEGenericType().SetEUpperBound(nil)
	default:
		eGenericType.CompactEObjectContainer.EUnsetFromID(featureID)
	}
}

func (eGenericType *eGenericTypeImpl) EIsSetFromID(featureID int) bool {
	switch featureID {
	case EGENERIC_TYPE__ECLASSIFIER:
		return eGenericType.eClassifier != nil
	case EGENERIC_TYPE__ELOWER_BOUND:
		return eGenericType.eLowerBound != nil
	case EGENERIC_TYPE__ERAW_TYPE:
		return eGenericType.eRawType != nil
	case EGENERIC_TYPE__ETYPE_ARGUMENTS:
		return eGenericType.eTypeArguments != nil && eGenericType.eTypeArguments.Size() != 0
	case EGENERIC_TYPE__ETYPE_PARAMETER:
		return eGenericType.eTypeParameter != nil
	case EGENERIC_TYPE__EUPPER_BOUND:
		return eGenericType.eUpperBound != nil
	default:
		return eGenericType.CompactEObjectContainer.EIsSetFromID(featureID)
	}
}

func (eGenericType *eGenericTypeImpl) EInvokeFromID(operationID int, arguments EList) interface{} {
	switch operationID {
	case EGENERIC_TYPE__IS_INSTANCE_EJAVAOBJECT:
		return eGenericType.asEGenericType().IsInstance(arguments.Get(0))
	default:
		return eGenericType.CompactEObjectContainer.EInvokeFromID(operationID, arguments)
	}
}

func (eGenericType *eGenericTypeImpl) EBasicInverseRemove(otherEnd EObject, featureID int, notifications ENotificationChain) ENotificationChain {
	switch featureID {
	case EGENERIC_TYPE__ELOWER_BOUND:
		return eGenericType.basicSetELowerBound(nil, notifications)
	case EGENERIC_TYPE__ETYPE_ARGUMENTS:
		list := eGenericType.GetETypeArguments().(ENotifyingList)
		return list.RemoveWithNotification(otherEnd, notifications)
	case EGENERIC_TYPE__EUPPER_BOUND:
		return eGenericType.basicSetEUpperBound(nil, notifications)
	default:
		return eGenericType.CompactEObjectContainer.EBasicInverseRemove(otherEnd, featureID, notifications)
	}
}