How to use

isMany

method

in

org.eclipse.emf.ecore.EStructuralFeature

  @SuppressWarnings({ "rawtypes", "unchecked" })
  public void apply(IdEObject value) {
    if (eStructuralFeature.isMany()) {
      List list = (List)newObject.eGet(eStructuralFeature);
      list.add(value);
    } else {
      newObject.eSet(eStructuralFeature, value);
    }
  }
}

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 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();
}
 

private boolean useUnsetBit(EStructuralFeature feature, IdEObject object) {
  // TODO non-unsettable boolean values can also be stored in these bits
  Object value = object.eGet(feature);
  if (feature.isUnsettable()) {
    if (!object.eIsSet(feature)) {
      return true;
    }
    if (feature.isMany() && ((List<?>)value).isEmpty()) {
      return true;
    }
  } else {
    if (feature.isMany() && ((List<?>)value).isEmpty()) {
      return true;
    }
    if (feature.getDefaultValue() == value || (feature.getDefaultValue() != null && feature.getDefaultValue().equals(value))) {
      return true;
    }
  }
  return false;
}

public void eUnset(EStructuralFeature feature) throws BimserverDatabaseException {
  if (useUnsetBit(feature)) {
    int pos = featureCounter / 8;
    byte b = buffer.get(pos);
    b |= (1 << (featureCounter % 8));
    buffer.put(pos, b);
  } else {
    if (feature instanceof EReference) {
      if (feature.isMany()) {
        ensureCapacity(buffer.position(), 4);
        buffer.putInt(0);
      } else {
        ensureCapacity(buffer.position(), 2);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short)-1);
        buffer.order(ByteOrder.BIG_ENDIAN);
      }
    } else if (feature.getEType() instanceof EEnum) {
      writeEnum(feature, null);
    } else {
      writePrimitiveValue(feature, null);
    }
  }
  incrementFeatureCounter(feature);
}

  public void setAttribute(EStructuralFeature feature, Object value) throws BimserverDatabaseException {
    if (feature.isMany()) {
      throw new UnsupportedOperationException("Feature isMany not supported by setAttribute");
    } else {
      if (feature.getEType() instanceof EEnum) {
        writeEnum(feature, value);
      } else if (feature.getEType() instanceof EClass) {
        if (value == null) {
          ensureCapacity(buffer.position(), 2);
          buffer.order(ByteOrder.LITTLE_ENDIAN);
          buffer.putShort((short) -1);
          buffer.order(ByteOrder.BIG_ENDIAN);
        } else if (value instanceof WrappedVirtualObject) {
          ByteBuffer otherBuffer = ((WrappedVirtualObject) value).write();
          ensureCapacity(buffer.position(), otherBuffer.position());
          buffer.put(otherBuffer.array(), 0, otherBuffer.position());
//                    writeWrappedValue(getPid(), getRid(), (WrappedVirtualObject) value, getPackageMetaData());
        } else {
          throw new UnsupportedOperationException("??");
        }
      } else if (feature.getEType() instanceof EDataType) {
        writePrimitiveValue(feature, value);
      }
    }
    incrementFeatureCounter(feature);
  }
 

@Override
public int getSize() {
  int size = 2;
  for (EStructuralFeature eStructuralFeature : map.keySet()) {
    Object val = map.get(eStructuralFeature);
    if (eStructuralFeature.isMany()) {
      size += 4;
      List list = (List)val;
      for (Object o : list) {
        if (o instanceof HashMapWrappedVirtualObject) {
          size += ((HashMapWrappedVirtualObject) o).getSize();
        } else {
          throw new UnsupportedOperationException();
        }
      }
    } else {
      if (eStructuralFeature.getEType() instanceof EDataType) {
        size += getPrimitiveSize((EDataType) eStructuralFeature.getEType(), val);
      } else {
        size += ((HashMapWrappedVirtualObject)val).getSize();
      }
    }
  }
  return size;
}

private boolean useUnsetBit(EStructuralFeature feature) {
  // TODO non-unsettable boolean values can also be stored in these bits
  Object value = eGet(feature);
  if (feature.isUnsettable()) {
    if (!eIsSet(feature)) {
      return true;
    }
  } else {
    if (feature.isMany() && (value == null || ((List<?>)value).isEmpty())) {
      return true;
    }
    if (feature.getDefaultValue() == value || (feature.getDefaultValue() != null && feature.getDefaultValue().equals(value))) {
      return true;
    }
  }
  return false;
}

private boolean useUnsetBit(EStructuralFeature feature) {
  // TODO non-unsettable boolean values can also be stored in these bits
  if (feature.isUnsettable()) {
    return true;
  } else {
    if (feature.isMany()) {
      return true;
    }
    if (feature.getDefaultValue() == null || (feature.getDefaultValue() != null && feature.getDefaultValue() == null)) {
      return true;
    }
  }
  return false;
}
 

public void fakeRead(ByteBuffer buffer, EStructuralFeature feature) throws BimserverDatabaseException {
  boolean wrappedValue = feature.getEType().getEAnnotation("wrapped") != null;
  if (feature.isMany()) {
    if (feature.getEType() instanceof EEnum) {
    } else if (feature.getEType() instanceof EClass) {

private void writeWrappedValue(int pid, int rid, WrappedVirtualObject wrappedValue, ByteBuffer buffer, PackageMetaData packageMetaData) throws BimserverDatabaseException {
  Short cid = getDatabaseInterface().getCidOfEClass(wrappedValue.eClass());
  buffer.order(ByteOrder.LITTLE_ENDIAN);
  buffer.putShort((short) -cid);
  buffer.order(ByteOrder.BIG_ENDIAN);
  for (EStructuralFeature eStructuralFeature : wrappedValue.eClass().getEAllStructuralFeatures()) {
    Object val = wrappedValue.eGet(eStructuralFeature);
    if (eStructuralFeature.isMany()) {
      List list = (List)val;
      buffer.putInt(list.size());
      for (Object o : list) {
        if (o instanceof HashMapWrappedVirtualObject) {
          writeWrappedValue(pid, rid, (VirtualObject) o, buffer, packageMetaData);
        }
      }
    } else {
      if (eStructuralFeature.getEType() instanceof EDataType) {
        writePrimitiveValue(eStructuralFeature, val, buffer);
      } else {
        writeWrappedValue(pid, rid, (HashMapWrappedVirtualObject) val, buffer, packageMetaData);
      }
    }
  }
}
 

private void writeEmbeddedValue(int pid, int rid, Object value, ByteBuffer buffer, PackageMetaData packageMetaData) throws BimserverDatabaseException {
  IdEObject wrappedValue = (IdEObject) value;
  Short cid = database.getCidOfEClass(wrappedValue.eClass());
  buffer.order(ByteOrder.LITTLE_ENDIAN);
  buffer.putShort((short) -cid);
  buffer.order(ByteOrder.BIG_ENDIAN);
  
  for (EStructuralFeature eStructuralFeature : wrappedValue.eClass().getEAllStructuralFeatures()) {
    if (eStructuralFeature.isMany()) {
      writeList(wrappedValue, buffer, packageMetaData, eStructuralFeature);
    } else {
      Object val = wrappedValue.eGet(eStructuralFeature);
      if (eStructuralFeature.getEType() instanceof EClass) {
        writeEmbeddedValue(pid, rid, val, buffer, packageMetaData);
      } else {
        writePrimitiveValue(eStructuralFeature, val, buffer);
      }
    }
  }
}

Object sourceValue = sourceObject.eGet(eStructuralFeature);
if (eStructuralFeature instanceof EReference) {
  if (eStructuralFeature.isMany()) {
    List sourceList = (List) sourceValue;
    List targetList = (List) targetObject.eGet(eStructuralFeature);
  if (eStructuralFeature.isMany()) {
    List sourceList = (List) sourceValue;
    List targetList = (List) targetObject.eGet(eStructuralFeature);

private HashMapWrappedVirtualObject readEmbeddedValue(EStructuralFeature feature, ByteBuffer buffer, EClass eClass) throws BimserverDatabaseException {
  HashMapWrappedVirtualObject eObject = new HashMapWrappedVirtualObject(eClass);
  for (EStructuralFeature eStructuralFeature : eClass.getEAllStructuralFeatures()) {
    if (eStructuralFeature.isMany()) {
    } else {
      if (eStructuralFeature.getEType() instanceof EDataType) {
        Object primitiveValue = readPrimitiveValue(eStructuralFeature.getEType(), buffer);
        eObject.setAttribute(eStructuralFeature, primitiveValue);
      } else {
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        short cid = buffer.getShort();
        buffer.order(ByteOrder.BIG_ENDIAN);
        if (cid == -1) {
          // null, do nothing
        } else if (cid < 0) {
          // negative cid means value is embedded in
          // record
          EClass referenceClass = queryObjectProvider.getDatabaseSession().getEClass((short) (-cid));
          eObject.setAttribute(eStructuralFeature, readEmbeddedValue(eStructuralFeature, buffer, referenceClass));
        }
      }
    }
  }
  return eObject;
}
 

private IdEObject readEmbeddedValue(EStructuralFeature feature, ByteBuffer buffer, EClass eClass, QueryInterface query) throws BimserverDatabaseException {
  IdEObject eObject = createInternal(eClass, query);
  for (EStructuralFeature eStructuralFeature : eClass.getEAllStructuralFeatures()) {
    if (eStructuralFeature.isMany()) {
      // Not implemented
    } else {
      if (eStructuralFeature.getEType() instanceof EDataType) {
        Object primitiveValue = readPrimitiveValue(eStructuralFeature.getEType(), buffer, query);
        ((IdEObjectImpl) eObject).setLoaded();
        eObject.eSet(eStructuralFeature, primitiveValue);
      } else {
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        short cid = buffer.getShort();
        buffer.order(ByteOrder.BIG_ENDIAN);
        if (cid == -1) {
          // null, do nothing
        } else if (cid < 0) {
          // non minus one and negative cid means value is embedded in record
          EClass referenceClass = database.getEClassForCid((short) (-cid));
          eObject.eSet(eStructuralFeature, readEmbeddedValue(eStructuralFeature, buffer, referenceClass, query));
        }
      }
    }
  }
  return eObject;
}

if (feature.isMany()) {
  if (nextToken == JsonToken.START_ARRAY) {
    EList values = new BasicEList();
if (feature.isMany() && nextToken == JsonToken.START_ARRAY) {
  EList values = new BasicEList();
  while (jp.nextToken() != JsonToken.END_ARRAY) {

if (feature.isMany()) {
  List<Object> childObjs = (List<Object>) eObj.eGet(feature);
  jg.writeFieldName(jsonKey);
if (feature.isMany()) {
  List<EObject> childObjs = (List<EObject>) eObj.eGet(feature);
  jg.writeFieldName(jsonKey);

protected EStructuralFeature.Internal.SettingDelegate eSettingDelegate(EStructuralFeature eFeature) {
  SettingDelegate eSettingDelegate = super.eSettingDelegate(eFeature);
  if (useInverses) {
    return eSettingDelegate;
  }
  if (eFeature instanceof EReference && ((EReference)eFeature).getEOpposite() != null) {
    // TODO cache/pre-generate the objects created in this block
    if (eFeature.isMany()) {
      if (eFeature.isUnsettable()) {
        return new InternalSettingDelegateMany(InternalSettingDelegateMany.EOBJECT_UNSETTABLE, eFeature);
      } else {
        return new InternalSettingDelegateMany(InternalSettingDelegateMany.EOBJECT, eFeature);
      }
    } else {
      if (eFeature.isUnsettable()) {
        return new InternalSettingDelegateSingleEObjectUnsettable((EClass) eFeature.getEType(), eFeature);
      } else {
        return new InternalSettingDelegateSingleEObject((EClass) eFeature.getEType(), eFeature);
      }
    }
  } else {
    return eSettingDelegate;
  }
}

public void updateNode(int expressId, EClass ec, VirtualObject eObject) throws DeserializeException, BimserverDatabaseException {
  for (WaitingVirtualObject waitingObject : waitingObjects.get(expressId)) {
    if (waitingObject.getStructuralFeature().isMany()) {
      ListWaitingVirtualObject listWaitingObject = (ListWaitingVirtualObject)waitingObject;
      if (((EClass) waitingObject.getStructuralFeature().getEType()).isSuperTypeOf(eObject.eClass())) {
        if (waitingObject instanceof TwoDimensionalListWaitingVirtualObject) {
          TwoDimensionalListWaitingVirtualObject twoDimensionalListWaitingVirtualObject = (TwoDimensionalListWaitingVirtualObject)waitingObject;
          ListCapableVirtualObject object2 = twoDimensionalListWaitingVirtualObject.getObject2();
          object2.setListItemReference(waitingObject.getStructuralFeature(), listWaitingObject.getIndex(), eObject.eClass(), eObject.getOid(), waitingObject.getBufferPosition());
        } else {
          waitingObject.getObject().setListItemReference(waitingObject.getStructuralFeature(), listWaitingObject.getIndex(), eObject.eClass(), eObject.getOid(), waitingObject.getBufferPosition());
        }
        decrementOpenConnections(waitingObject.getObject());
      } else {
        throw new DeserializeException(waitingObject.getLineNumber(), "Field " + waitingObject.getStructuralFeature().getName() + " of "
            + waitingObject.getStructuralFeature().getEContainingClass().getName() + " cannot contain a " + eObject.eClass().getName());
      }
    } else {
      if (((EClass) waitingObject.getStructuralFeature().getEType()).isSuperTypeOf(eObject.eClass())) {
        waitingObject.getObject().setReference(waitingObject.getStructuralFeature(), eObject.getOid(), waitingObject.getBufferPosition());
        decrementOpenConnections(waitingObject.getObject());
      } else {
        throw new DeserializeException(waitingObject.getLineNumber(), "Field " + waitingObject.getStructuralFeature().getName() + " of "
            + waitingObject.getStructuralFeature().getEContainingClass().getName() + " cannot contain a " + eObject.eClass().getName() + "/" + eObject.getOid());
      }
    }
  }
  waitingObjects.remove(expressId);
}

public static String getType(EStructuralFeature eStructuralFeature) {
  boolean embedsReference = eStructuralFeature.getEAnnotation("embedsreference") != null;
  EClassifier eType = eStructuralFeature.getEType();
  if (eStructuralFeature.isMany()) {
    if (eType instanceof EDataType) {
      if (eType == EcorePackage.eINSTANCE.getEString()) {