Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
<copyright> Copyright (c) 2009, 2010 Springsite BV (The Netherlands) and others 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 Contributors: Martin Taal - Initial API and implementation </copyright> $Id: ModelEFactory.java,v 1.8 2011/08/25 12:32:37 mtaal Exp $
 
 
 package org.eclipse.emf.texo.model;
 
 
 import  org.eclipse.emf.common.notify.Adapter;
 import  org.eclipse.emf.common.notify.Notification;
 import  org.eclipse.emf.common.notify.NotificationChain;
 import  org.eclipse.emf.common.util.EList;
 import  org.eclipse.emf.common.util.Enumerator;
 import  org.eclipse.emf.common.util.TreeIterator;
 import  org.eclipse.emf.common.util.URI;
 import  org.eclipse.emf.ecore.EAnnotation;
 import  org.eclipse.emf.ecore.EClass;
 import  org.eclipse.emf.ecore.EDataType;
 import  org.eclipse.emf.ecore.EEnum;
 import  org.eclipse.emf.ecore.EEnumLiteral;
 import  org.eclipse.emf.ecore.EFactory;
 import  org.eclipse.emf.ecore.EObject;
 import  org.eclipse.emf.ecore.EOperation;
 import  org.eclipse.emf.ecore.EPackage;
 import  org.eclipse.emf.ecore.EReference;
 import  org.eclipse.emf.ecore.EStructuralFeature;
 import  org.eclipse.emf.ecore.EStructuralFeature.Setting;
 import  org.eclipse.emf.ecore.InternalEObject;
 import  org.eclipse.emf.ecore.impl.DynamicEObjectImpl;
 import  org.eclipse.emf.ecore.impl.EFactoryImpl;
 import  org.eclipse.emf.ecore.resource.Resource;
 import  org.eclipse.emf.ecore.resource.Resource.Internal;
Wraps a ModelFactory to forward the calls to convertToString and createFromString to it. Other EFactory calls are forwarded to the super class.

Author(s):
Martin Taal
 
 public class ModelEFactory implements EFactory, InternalEObject, TexoComponent {
 
   private EFactoryImpl delegate;
   private boolean isDynamicEFactory = false;
   private ModelFactory modelFactory;

  
Checks if the objectvalue is an Enumerator or an EEnumLiteral, if so calls getLiteral() on these. Otherwise if it is a Dynamic EFactory then the call is delegated to ModelFactory.convertToString(EDataType, Object). If a generated EFactory then that one is used.

Parameters:
dataType the EDataType of the objectValue
objectValue the object to convert to a String
See also:
org.eclipse.emf.ecore.impl.EFactoryImpl.convertToString(org.eclipse.emf.ecore.EDataType, java.lang.Object)
getXmlHandler()
 
   public String convertToString(final EDataType dataTypefinal Object objectValue) {
     if () {
       if (objectValue instanceof Enumerator) {
         final Enumerator enumerator = (Enumerator) objectValue;
         return enumerator.getLiteral();
       }
       if (objectValue instanceof EEnumLiteral) {
         final EEnumLiteral eEnumLiteral = (EEnumLiteral) objectValue;
         return eEnumLiteral.getLiteral();
       }
 
       return .convertToString(dataTypeobjectValue);
     }
     return .convertToString(dataTypeobjectValue);
   }

  
Call is delegated to ModelFactory.createFromString(EDataType, String). In case of a dynamic EFactory, overrides handling of enums to return the EMF Enumerator instance instead of the generated java type.

See also:
org.eclipse.emf.ecore.impl.EFactoryImpl.createFromString(org.eclipse.emf.ecore.EDataType, java.lang.String)
getXmlHandler()
  public Object createFromString(final EDataType dataTypefinal String stringValue) {
    // if the efactory is not the default efactory then use it to
    // convert
    if (!) {
      return .createFromString(dataTypestringValue);
    }
    if (dataType instanceof EEnum) {
      if (stringValue == null || stringValue.trim().length() == 0) {
        return null;
      }
      return ((EEnum) dataType).getEEnumLiteralByLiteral(stringValue);
    }
    final EDataType baseType = ModelUtils.getEnumBaseDataTypeIfObject(dataType);
    if (baseType != null && baseType instanceof EEnum) {
      if (stringValue == null || stringValue.trim().length() == 0) {
        return null;
      }
      final EEnum eeNum = (EEnum) baseType;
      EEnumLiteral eeNumLiteral = eeNum.getEEnumLiteralByLiteral(stringValue);
      if (eeNumLiteral == null) {
        eeNumLiteral = eeNum.getEEnumLiteral(stringValue);
      }
      if (eeNumLiteral == null) {
        throw new IllegalArgumentException("The value '" + stringValue //$NON-NLS-1$
            + "' is not a valid enumerator of '" //$NON-NLS-1$
            + dataType.getName() + "'"); //$NON-NLS-1$
      }
      return eeNumLiteral;
    }
    return .createFromString(dataTypestringValue);
  }

  

Returns:
the modelFactory
    return ;
  }

  

Parameters:
modelFactory the modelFactory to set
  public void setModelFactory(final ModelFactory modelFactory) {
    this. = modelFactory;
  }

  

Returns:
the original EFactory which is being wrapped by this ModelEFactory.
  public EFactory getDelegateEFactory() {
    return ;
  }

  

Parameters:
eClass
Returns:
See also:
org.eclipse.emf.ecore.EFactory.create(org.eclipse.emf.ecore.EClass)
  public EObject create(final EClass eClass) {
    // overridden to handle cases where the instanceClass is set, with Texo always
    // the DynamicEObjectImpl should be used and not the instanceClass
    if () {
      // note copied from EFactoryImpl.basicCreate
      return eClass.getInstanceClassName() == "java.util.Map$Entry" ? new DynamicEObjectImpl.BasicEMapEntry<StringString>( //$NON-NLS-1$
          eClass)
          : new DynamicEObjectImpl(eClass);
    }
    return .create(eClass);
  }
  public EList<Adapter> eAdapters() {
    return .eAdapters();
  }
  public boolean eDeliver() {
    return .eDeliver();
  }
  public EList<EAnnotation> getEAnnotations() {
    return .getEAnnotations();
  }
  public void eSetDeliver(boolean deliver) {
    .eSetDeliver(deliver);
  }
  public EPackage getEPackage() {
    return .getEPackage();
  }
  public void eNotify(Notification notification) {
    .eNotify(notification);
  }
  public EAnnotation getEAnnotation(String source) {
    return .getEAnnotation(source);
  }
  public void setEPackage(EPackage value) {
     = (EFactoryImpl) value.getEFactoryInstance();
    // if the efactory is not the default efactory then it will be used
    // to convert. Note that this comparison can go wrong if the
    // class of the delegate is loaded through a different classloader
    // than the EFactoryImpl class. But this is very unlikely (other
    // problems would then occur.
     = .getClass() == EFactoryImpl.class;
  }
  public EClass eClass() {
    return .eClass();
  }
  public Resource eResource() {
    return .eResource();
  }
  public EObject eContainer() {
    return .eContainer();
  }
  public EStructuralFeature eContainingFeature() {
    return .eContainingFeature();
  }
  public EReference eContainmentFeature() {
    return .eContainmentFeature();
  }
  public EList<EObject> eContents() {
    return .eContents();
  }
  public TreeIterator<EObject> eAllContents() {
    return .eAllContents();
  }
  public boolean eIsProxy() {
    return .eIsProxy();
  }
  public EList<EObject> eCrossReferences() {
    return .eCrossReferences();
  }
  public Object eGet(EStructuralFeature feature) {
    return .eGet(feature);
  }
  public Object eGet(EStructuralFeature featureboolean resolve) {
    return .eGet(featureresolve);
  }
  public void eSet(EStructuralFeature featureObject newValue) {
    .eSet(featurenewValue);
  }
  public boolean eIsSet(EStructuralFeature feature) {
    return .eIsSet(feature);
  }
  public void eUnset(EStructuralFeature feature) {
    .eUnset(feature);
  }
  public Object eInvoke(EOperation operation, EList<?> arguments) {
    try {
      // ugly method to make the code backward compatible with 3.5!
      // won't be called anyway in 3.5
      final Method method = .getClass().getMethod("invoke", EOperation.class, EList.class); //$NON-NLS-1$
      return method.invoke(operationarguments);
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  public int hashCode() {
    return .hashCode();
  }
  public boolean equals(Object obj) {
    return .equals(obj);
  }
  public NotificationChain basicSetEPackage(EPackage newEPackage, NotificationChain msgs) {
    return .basicSetEPackage(newEPackagemsgs);
  }
  public Object eGet(int featureIDboolean resolveboolean coreType) {
    return .eGet(featureIDresolvecoreType);
  }
  public InternalEObject eInternalContainer() {
    return .eInternalContainer();
  }
  public void eSet(int featureIDObject newValue) {
    .eSet(featureIDnewValue);
  }
  public void eUnset(int featureID) {
    .eUnset(featureID);
  }
  public boolean eIsSet(int featureID) {
    return .eIsSet(featureID);
  }
  public Object eInvoke(int operationID, EList<?> arguments) {
    try {
      // ugly method to make the code backward compatible with 3.5!
      // won't be called anyway in 3.5
      final Method method = .getClass().getMethod("eInvoke"int.class, EList.class); //$NON-NLS-1$
      return method.invoke(operationIDarguments);
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  public String eURIFragmentSegment(EStructuralFeature eStructuralFeature, EObject eObject) {
    return .eURIFragmentSegment(eStructuralFeatureeObject);
  }
  public boolean eNotificationRequired() {
    return .eNotificationRequired();
  }
  public EObject eObjectForURIFragmentSegment(String uriFragmentSegment) {
    return .eObjectForURIFragmentSegment(uriFragmentSegment);
  }
  public URI eProxyURI() {
    return .eProxyURI();
  }
  public void eSetProxyURI(URI uri) {
    .eSetProxyURI(uri);
  }
  public int eContainerFeatureID() {
    return .eContainerFeatureID();
  }
  public void eSetClass(EClass eClass) {
    .eSetClass(eClass);
  }
  public NotificationChain eInverseAdd(InternalEObject otherEndint featureID, NotificationChain msgs) {
    return .eInverseAdd(otherEndfeatureIDmsgs);
  }
  public Internal eDirectResource() {
    return .eDirectResource();
  }
  public NotificationChain eInverseRemove(InternalEObject otherEndint featureID, NotificationChain msgs) {
    return .eInverseRemove(otherEndfeatureIDmsgs);
  }
  public Object dynamicGet(int dynamicFeatureID) {
    return .dynamicGet(dynamicFeatureID);
  }
  public void dynamicSet(int dynamicFeatureIDObject newValue) {
    .dynamicSet(dynamicFeatureIDnewValue);
  }
  public void dynamicUnset(int dynamicFeatureID) {
    .dynamicUnset(dynamicFeatureID);
  }
  public boolean eContains(EObject eObject) {
    return .eContains(eObject);
  }
  public Internal eInternalResource() {
    return .eInternalResource();
  }
  public NotificationChain eSetResource(Internal resource, NotificationChain notifications) {
    return .eSetResource(resourcenotifications);
  }
  public Object eGet(EStructuralFeature eFeatureboolean resolveboolean coreType) {
    return .eGet(eFeatureresolvecoreType);
  }
  public Object eDynamicGet(EStructuralFeature eFeatureboolean resolve) {
    return .eDynamicGet(eFeatureresolve);
  }
  public Object eDynamicGet(int featureIDboolean resolveboolean coreType) {
    return .eDynamicGet(featureIDresolvecoreType);
  }
  public Object eOpenGet(EStructuralFeature eFeatureboolean resolve) {
    return .eOpenGet(eFeatureresolve);
  }
  public void eDynamicSet(EStructuralFeature eFeatureObject newValue) {
    .eDynamicSet(eFeaturenewValue);
  }
  public void eDynamicSet(int featureIDObject newValue) {
    .eDynamicSet(featureIDnewValue);
  }
  public void eOpenSet(EStructuralFeature eFeatureObject newValue) {
    .eOpenSet(eFeaturenewValue);
  }
  public void eDynamicUnset(EStructuralFeature eFeature) {
    .eDynamicUnset(eFeature);
  }
  public void eDynamicUnset(int featureID) {
    .eDynamicUnset(featureID);
  }
  public void eOpenUnset(EStructuralFeature eFeature) {
    .eOpenUnset(eFeature);
  }
  public boolean eDynamicIsSet(EStructuralFeature eFeature) {
    return .eDynamicIsSet(eFeature);
  }
  public boolean eDynamicIsSet(int featureID) {
    return .eDynamicIsSet(featureID);
  }
  public boolean eOpenIsSet(EStructuralFeature eFeature) {
    return .eOpenIsSet(eFeature);
  }
  public NotificationChain eBasicSetContainer(InternalEObject newContainerint newContainerFeatureID,
      NotificationChain msgs) {
    return .eBasicSetContainer(newContainernewContainerFeatureIDmsgs);
  }
  public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
    return .eBasicRemoveFromContainer(msgs);
  }
  public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
    return .eBasicRemoveFromContainerFeature(msgs);
  }
  public NotificationChain eDynamicBasicRemoveFromContainer(NotificationChain msgs) {
    return .eDynamicBasicRemoveFromContainer(msgs);
  }
  public NotificationChain eInverseAdd(InternalEObject otherEndint featureIDClass<?> baseClass,
      NotificationChain msgs) {
    return .eInverseAdd(otherEndfeatureIDbaseClassmsgs);
  }
  public NotificationChain eDynamicInverseAdd(InternalEObject otherEndint featureIDClass<?> inverseClass,
      NotificationChain msgs) {
    return .eDynamicInverseAdd(otherEndfeatureIDinverseClassmsgs);
  }
  public NotificationChain eInverseRemove(InternalEObject otherEndint featureIDClass<?> baseClass,
      NotificationChain msgs) {
    return .eInverseRemove(otherEndfeatureIDbaseClassmsgs);
  }
  public NotificationChain eDynamicInverseRemove(InternalEObject otherEndint featureIDClass<?> inverseClass,
      NotificationChain msgs) {
    return .eDynamicInverseRemove(otherEndfeatureIDinverseClassmsgs);
  }
  public EObject eResolveProxy(InternalEObject proxy) {
    return .eResolveProxy(proxy);
  }
  public int eBaseStructuralFeatureID(int derivedFeatureIDClass<?> baseClass) {
    return .eBaseStructuralFeatureID(derivedFeatureIDbaseClass);
  }
  public int eDerivedStructuralFeatureID(int baseFeatureIDClass<?> baseClass) {
    return .eDerivedStructuralFeatureID(baseFeatureIDbaseClass);
  }
  public int eDerivedStructuralFeatureID(EStructuralFeature eStructuralFeature) {
    return .eDerivedStructuralFeatureID(eStructuralFeature);
  }
  public int eDerivedOperationID(int baseOperationIDClass<?> baseClass) {
    try {
      // ugly method to make the code backward compatible with 3.5!
      // won't be called anyway in 3.5
      final Method method = .getClass().getMethod("eDerivedOperationID"int.classClass.class); //$NON-NLS-1$
      return ((Integermethod.invoke(baseOperationIDbaseClass)).intValue();
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  public int eDerivedOperationID(EOperation eOperation) {
    try {
      // ugly method to make the code backward compatible with 3.5!
      // won't be called anyway in 3.5
      final Method method = .getClass().getMethod("eDerivedOperationID", EOperation.class); //$NON-NLS-1$
      return ((Integermethod.invoke(eOperation)).intValue();
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  public Setting eSetting(EStructuralFeature eFeature) {
    return .eSetting(eFeature);
  }
  public EStore eStore() {
    return .eStore();
  }
  public void eSetStore(EStore store) {
    .eSetStore(store);
  }
  public Object eVirtualGet(int eDerivedStructuralFeatureID) {
    return .eVirtualGet(eDerivedStructuralFeatureID);
  }
  public Object eVirtualGet(int eDerivedStructuralFeatureIDObject defaultValue) {
    return .eVirtualGet(eDerivedStructuralFeatureIDdefaultValue);
  }
  public boolean eVirtualIsSet(int eDerivedStructuralFeatureID) {
    return .eVirtualIsSet(eDerivedStructuralFeatureID);
  }
  public Object eVirtualSet(int eDerivedStructuralFeatureIDObject value) {
    return .eVirtualSet(eDerivedStructuralFeatureIDvalue);
  }
  public Object eVirtualUnset(int eDerivedStructuralFeatureID) {
    return .eVirtualUnset(eDerivedStructuralFeatureID);
  }
  public Object eDynamicInvoke(int operationID, EList<?> arguments) {
    try {
      // ugly method to make the code backward compatible with 3.5!
      // won't be called anyway in 3.5
      final Method method = .getClass().getMethod("eDynamicInvoke"int.class, EList.class); //$NON-NLS-1$
      return method.invoke(operationIDarguments);
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  public String toString() {
    return .toString();
  }

  
Uses the Proxy concept to encapsulate the ModelEFactory within the correct class.
  public static class EFactoryInvocationHandler implements InvocationHandler {
    private final ModelEFactory modelEFactory;
    public EFactoryInvocationHandler(ModelEFactory modelEFactory) {
      this. = modelEFactory;
    }
    public Object invoke(Object objectMethod methodObject[] argsthrows Throwable {
      return method.invoke(args);
    }
  }
New to GrepCode? Check out our FAQ X