How to use

getName

method

in

org.eclipse.emf.ecore.EStructuralFeature

protected void log(Object obj, int level, StringBuffer log) {
  EObject object = (EObject) obj;
  List properties = object.eClass().getEAllStructuralFeatures();
  for (Iterator p = properties.iterator(); p.hasNext(); ) {
    EStructuralFeature property = (EStructuralFeature) p.next();
    Object value = object.eGet(property);
    // skip empty properties
    if (value == null
        || (value instanceof Collection && ((Collection) value).isEmpty())
        || (value instanceof Map && ((Map) value).isEmpty())) {
      continue;
    }
    log.append("\n");
    for (int i = 0; i < level; i++) log.append("    ");
    if (value instanceof EObject && (level < 3)) {
      log.append(property.getName());
      log.append(":");
      log((EObject) value, level + 1, log);
    } else if (value instanceof Collection) {
      log(property.getName(), (Collection) value, level + 1, log);
    } else {
      log.append(property.getName());
      log.append(" = " + value);
    }
  }
}

  @Override
  public boolean shouldFollowReference(EClass originalClass, EClass eClass, EStructuralFeature eStructuralFeature) {
    if (eStructuralFeature.getName().equals("Representation") && onlyIncludeRepresentationForThisClass != eClass) {
      return false;
    } else {
      if (eStructuralFeature.getName().equals("StyledByItem")) {
        return true;
      }
      return hideAllInverse.shouldFollowReference(originalClass, eClass, eStructuralFeature);
    }
  }
};

@Override
public String toString() {
  StringBuilder sb = new StringBuilder();
  sb.append(eClass.getName() + "\n");
  for (EStructuralFeature eStructuralFeature : map.keySet()) {
    sb.append("\t" + eStructuralFeature.getName() + ": " + map.get(eStructuralFeature) + "\n");
  }
  return sb.toString();
}

public boolean shouldFollowReference(EClass originalQueryClass, EClass eClass, EStructuralFeature eStructuralFeature) {
  StructuralFeatureIdentifier o = new StructuralFeatureIdentifier(eClass.getName(), eStructuralFeature.getName());
  boolean generalShouldIgnoreAnswer = generalIgnoreSet.contains(o);
  if (generalShouldIgnoreAnswer) {
    // If the general ignore file says ignore, we should check for a specific override
    if (specificIncludeMap.containsKey(originalQueryClass)) {
      return specificIncludeMap.get(originalQueryClass).contains(o);
    }
    return false;
  }
  return true;
}

  @Override
  public Set<HashMapVirtualObject> getDirectListFeature(EStructuralFeature representationsFeature) {
    return (Set<HashMapVirtualObject>) eGet(representationsFeature.getName());
  }
}

public void removeFromGeneralIgnoreSet(EStructuralFeature eStructuralFeature) {
  Iterator<StructuralFeatureIdentifier> iterator = generalIgnoreSet.iterator();
  while (iterator.hasNext()) {
    StructuralFeatureIdentifier next = iterator.next();
    if (next.geteStructuralFeature().equals(eStructuralFeature.getName())) {
      iterator.remove();
    }
  }
}

  @Override
  public boolean shouldFollowReference(EClass originalClass, EClass eClass, EStructuralFeature eStructuralFeature) {
    if (eStructuralFeature.getName().equals("Representation")) {
      return false;
    } else {
      return hideAllInverse.shouldFollowReference(originalClass, eClass, eStructuralFeature);
    }
  }
};

@Override
public AbstractHashMapVirtualObject getDirectFeature(EStructuralFeature eReference) {
  return (AbstractHashMapVirtualObject) eGet(eReference.getName());
}

@SuppressWarnings("unchecked")
public void addUseForSerialization(EStructuralFeature eStructuralFeature, int index) {
  if (eStructuralFeature.getEContainingClass().isSuperTypeOf(eClass)) {
    Set<Object> set = (Set<Object>) useForSerializationFeatures.get(eStructuralFeature);
    if (set == null) {
      set = new HashSet<>();
      useForSerializationFeatures.put(eStructuralFeature, set);
    }
    set.add(index);
  } else {
    throw new IllegalArgumentException(eStructuralFeature.getName() + " does not exist in " + eClass.getName());
  }
}

public void addUseForSerialization(EStructuralFeature eStructuralFeature) {
  if (eStructuralFeature.getEContainingClass().isSuperTypeOf(eClass)) {
    useForSerializationFeatures.put(eStructuralFeature, true);
  } else {
    throw new IllegalArgumentException(eStructuralFeature.getName() + " does not exist in " + eClass.getName());
  }
}
 

public static String makeSetter(EStructuralFeature eStructuralFeature) {
  StringBuilder sb = new StringBuilder();
  sb.append("set" + firstLetterUpperCase(eStructuralFeature.getName()));
  if (eStructuralFeature instanceof EReference && !eStructuralFeature.isMany() && eStructuralFeature.getEAnnotation("embedsreference") == null) {
    sb.append("Id");
  }
  return sb.toString();
}

public boolean createIndexTable(EClass eClass, EStructuralFeature eStructuralFeature, DatabaseSession databaseSession, boolean transactional) throws BimserverDatabaseException {
  return keyValueStore.createIndexTable(eClass.getEPackage().getName() + "_" + eClass.getName() + "_" + eStructuralFeature.getName(), databaseSession, transactional);
}

public static String makeGetter(EStructuralFeature eStructuralFeature) {
  StringBuilder sb = new StringBuilder();
  if (eStructuralFeature.getEType() == EcorePackage.eINSTANCE.getEBoolean()) {
    sb.append("is");
  } else {
    sb.append("get");
  }
  sb.append(firstLetterUpperCase(eStructuralFeature.getName()));
  if (eStructuralFeature instanceof EReference && !eStructuralFeature.isMany() && eStructuralFeature.getEAnnotation("embedsreference") == null) {
    sb.append("Id");
  }
  return sb.toString();
}
 

@Override
public String toString() {
  return "L" + lineNumber + ": " + getObject() + " " + getStructuralFeature().getName();
}

  @Override
  public String toString() {
    return getLineNumber() + ": " + getObject() + " " + getStructuralFeature().getName() + " (index: " + index + ")";
  }
}

private void addToList(EStructuralFeature eStructuralFeature, int index, AbstractEList list, EObject referencedObject) throws DeserializeException {
  EClass referenceEClass = referencedObject.eClass();
  if (((EClass) eStructuralFeature.getEType()).isSuperTypeOf(referenceEClass)) {
    while (list.size() <= index) {
      list.addUnique(referencedObject);
    }
  } else {
    throw new DeserializeException(-1, referenceEClass.getName() + " cannot be stored in " + eStructuralFeature.getName());
  }
}

  @Override
  public String toString() {
    return getLineNumber() + ": " + getObject() + " " + getStructuralFeature().getName() + " (index1: " + index1 + ", index2: " + index2 + ")";
  }
}

private void writeEmbedded(IdEObject object) throws IOException {
  print("{");
  print("\"_t\":\"" + object.eClass().getName() + "\",");
  for (EStructuralFeature eStructuralFeature : object.eClass().getEAllStructuralFeatures()) {
    print("\"" + eStructuralFeature.getName() + "\":");
    writePrimitive(eStructuralFeature, object.eGet(eStructuralFeature));
    if (object.eClass().getEAllStructuralFeatures().get(object.eClass().getEAllStructuralFeatures().size()-1) != eStructuralFeature) {
      print(",");
    }
  }
  print("}");
}

protected boolean isInverse(EStructuralFeature eStructuralFeature) throws ObjectIDMException {
  if (eStructuralFeature instanceof EReference && eStructuralFeature.getEContainingClass().getEAnnotation("wrapped") == null) {
    if (eStructuralFeature.getEAnnotation("hidden") == null && eStructuralFeature.getEContainingClass().getEAnnotation("hidden") == null) {
      EntityDefinition entityBN = packageMetaData.getSchemaDefinition().getEntityBN(eStructuralFeature.getEContainingClass().getName());
      if (entityBN == null) {
        throw new ObjectIDMException(eStructuralFeature.getEContainingClass().getName() + " not found");
      }
      Attribute attribute = entityBN.getAttributeBNWithSuper(eStructuralFeature.getName());
      return attribute instanceof InverseAttribute;
    } else {
      return false;
    }
  }
  return false;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private void processRef(IfcModelInterface model, WaitingList<Long> waitingList, IdEObjectImpl object,
    EStructuralFeature eStructuralFeature, int index, AbstractEList list, long refOid)
        throws DeserializeException {
  EntityDefinition entityBN = model.getPackageMetaData().getSchemaDefinition().getEntityBN(object.eClass().getName());
  Attribute attributeBN = entityBN.getAttributeBNWithSuper(eStructuralFeature.getName());
  if (skipInverses && attributeBN instanceof InverseAttribute && ((EReference)eStructuralFeature).getEOpposite() != null) {
    // skip
  } else {
    if (model.contains(refOid)) {
      EObject referencedObject = model.get(refOid);
      if (referencedObject != null) {
        addToList(eStructuralFeature, index, list, referencedObject);
      }
    } else {
      waitingList.add(refOid, new ListWaitingObject(-1, object, (EReference) eStructuralFeature, index));
    }
  }
}