/** * Adds an enum value to the enumValuesByNumber table. If an enum value * with the same type and number already exists, does nothing. (This is * allowed; the first value define with the number takes precedence.) */ void addEnumValueByNumber(final EnumValueDescriptor value) { final DescriptorIntPair key = new DescriptorIntPair(value.getType(), value.getNumber()); final EnumValueDescriptor old = enumValuesByNumber.put(key, value); if (old != null) { enumValuesByNumber.put(key, old); // Not an error: Multiple enum values may have the same number, but // we only want the first one in the map. } }
/** * Adds an enum value to the enumValuesByNumber table. If an enum value * with the same type and number already exists, does nothing. (This is * allowed; the first value define with the number takes precedence.) */ void addEnumValueByNumber(final EnumValueDescriptor value) { final DescriptorIntPair key = new DescriptorIntPair(value.getType(), value.getNumber()); final EnumValueDescriptor old = enumValuesByNumber.put(key, value); if (old != null) { enumValuesByNumber.put(key, old); // Not an error: Multiple enum values may have the same number, but // we only want the first one in the map. } }
/** * Converts a list of MapEntry messages into a Map used for equals() and * hashCode(). */ @SuppressWarnings({"rawtypes", "unchecked"}) private static Map convertMapEntryListToMap(List list) { if (list.isEmpty()) { return Collections.emptyMap(); } Map result = new HashMap(); Iterator iterator = list.iterator(); Message entry = (Message) iterator.next(); Descriptors.Descriptor descriptor = entry.getDescriptorForType(); Descriptors.FieldDescriptor key = descriptor.findFieldByName("key"); Descriptors.FieldDescriptor value = descriptor.findFieldByName("value"); Object fieldValue = entry.getField(value); if (fieldValue instanceof EnumValueDescriptor) { fieldValue = ((EnumValueDescriptor) fieldValue).getNumber(); } result.put(entry.getField(key), fieldValue); while (iterator.hasNext()) { entry = (Message) iterator.next(); fieldValue = entry.getField(value); if (fieldValue instanceof EnumValueDescriptor) { fieldValue = ((EnumValueDescriptor) fieldValue).getNumber(); } result.put(entry.getField(key), fieldValue); } return result; }
private void generateProtoFromDescriptor(EnumValueDescriptor descriptor, Appendable out, String indent) throws IOException { out.append(indent); out.append(descriptor.getName() + " = " + descriptor.getNumber()); out.append(";\n"); }
@Override public SoyValue soyFromProto(Object field) { int value; if (field instanceof ProtocolMessageEnum) { value = ((ProtocolMessageEnum) field).getNumber(); } else { // The value will be an EnumValueDescriptor when fetched via reflection or a // ProtocolMessageEnum otherwise. Who knows why. value = ((EnumValueDescriptor) field).getNumber(); } return IntegerData.forValue(value); }
@Override public SoyValue apply(EnumValueDescriptor input) { // / Proto enum that was obtained via reflection (e.g. from SoyProtoValue) return IntegerData.forValue(input.getNumber()); } });
public Integer getValue(String memberName) { EnumValueDescriptor value = descriptor.findValueByName(memberName); if (value != null) { return value.getNumber(); } return null; }
@Override public SoyValue apply(EnumValueDescriptor input) { // / Proto enum that was obtained via reflection (e.g. from SoyProtoValue) return IntegerData.forValue(input.getNumber()); } });
private Object convertFieldValue(SField field, Object val) throws ConvertException { if (val instanceof EnumValueDescriptor) { EnumValueDescriptor enumValueDescriptor = (EnumValueDescriptor) val; Class<?> enumClass; try { enumClass = Class.forName("org.bimserver.interfaces.objects." + enumValueDescriptor.getType().getName()); for (Object v : enumClass.getEnumConstants()) { Enum<?> e = (Enum<?>) v; if (e.ordinal() == enumValueDescriptor.getNumber()) { val = e; break; } } } catch (ClassNotFoundException e) { LOGGER.error("", e); } return val; } else if (field.getType().getInstanceClass() == Date.class) { return new Date((Long) val); } else if (field.getType().getInstanceClass() == DataHandler.class) { ByteString byteString = (ByteString) val; ByteArrayDataSource byteArrayDataSource = new ByteArrayDataSource("test", byteString.toByteArray()); return new DataHandler(byteArrayDataSource); } else if (val instanceof DynamicMessage) { return convertProtocolBuffersMessageToSObject((DynamicMessage) val, null, field.isAggregate() ? field.getGenericType() : field.getType()); } else { return val; } }
@SuppressWarnings("unchecked") @Override public Builder<K, V> setField(FieldDescriptor field, Object value) { checkFieldDescriptor(field); if (field.getNumber() == 1) { setKey((K) value); } else { if (field.getType() == FieldDescriptor.Type.ENUM) { value = ((EnumValueDescriptor) value).getNumber(); } else if (field.getType() == FieldDescriptor.Type.MESSAGE) { if (value != null && !metadata.defaultValue.getClass().isInstance(value)) { // The value is not the exact right message type. However, if it // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. value = ((Message) metadata.defaultValue).toBuilder().mergeFrom((Message) value).build(); } } setValue((V) value); } return this; }
private IRubyObject wrapField(ThreadContext context, Descriptors.FieldDescriptor fieldDescriptor, Object value) { if (value == null) { return context.runtime.getNil(); } Ruby runtime = context.runtime; switch (fieldDescriptor.getType()) { case INT32: case INT64: case UINT32: case UINT64: case FLOAT: case DOUBLE: case BOOL: case BYTES: case STRING: return Utils.wrapPrimaryValue(context, fieldDescriptor.getType(), value); case MESSAGE: RubyClass typeClass = (RubyClass) ((RubyDescriptor) getDescriptorForField(context, fieldDescriptor)).msgclass(context); RubyMessage msg = (RubyMessage) typeClass.newInstance(context, Block.NULL_BLOCK); return msg.buildFrom(context, (DynamicMessage) value); case ENUM: Descriptors.EnumValueDescriptor enumValueDescriptor = (Descriptors.EnumValueDescriptor) value; if (enumValueDescriptor.getIndex() == -1) { // UNKNOWN ENUM VALUE return runtime.newFixnum(enumValueDescriptor.getNumber()); } return runtime.newSymbol(enumValueDescriptor.getName()); default: return runtime.newString(value.toString()); } }
@Override public void setRepeated(final Builder builder, final int index, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(setRepeatedValueMethod, builder, index, ((EnumValueDescriptor) value).getNumber()); return; } super.setRepeated(builder, index, invokeOrDie(valueOfMethod, null, value)); } @Override
@Override public void set(final Builder builder, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(setValueMethod, builder, ((EnumValueDescriptor) value).getNumber()); return; } super.set(builder, invokeOrDie(valueOfMethod, null, value)); } }
@Override public void set(final Builder builder, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(setValueMethod, builder, ((EnumValueDescriptor) value).getNumber()); return; } super.set(builder, invokeOrDie(valueOfMethod, null, value)); } }
@Override public void addRepeated(final Builder builder, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(addRepeatedValueMethod, builder, ((EnumValueDescriptor) value).getNumber()); return; } super.addRepeated(builder, invokeOrDie(valueOfMethod, null, value)); } }
@Override public void addRepeated(final Builder builder, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(addRepeatedValueMethod, builder, ((EnumValueDescriptor) value).getNumber()); return; } super.addRepeated(builder, invokeOrDie(valueOfMethod, null, value)); } }
@Override public void setRepeated(final Builder builder, final int index, final Object value) { if (supportUnknownEnumValue) { invokeOrDie(setRepeatedValueMethod, builder, index, ((EnumValueDescriptor) value).getNumber()); return; } super.setRepeated(builder, index, invokeOrDie(valueOfMethod, null, value)); } @Override
private RubyModule buildModuleFromDescriptor(ThreadContext context) { Ruby runtime = context.runtime; Utils.checkNameAvailability(context, name.asJavaString()); RubyModule enumModule = RubyModule.newModule(runtime); for (Descriptors.EnumValueDescriptor value : descriptor.getValues()) { enumModule.defineConstant(value.getName(), runtime.newFixnum(value.getNumber())); } enumModule.instance_variable_set(runtime.newString(Utils.DESCRIPTOR_INSTANCE_VAR), this); enumModule.defineAnnotatedMethods(RubyEnum.class); return enumModule; }
@JRubyMethod(meta = true) public static IRubyObject resolve(ThreadContext context, IRubyObject recv, IRubyObject name) { RubyEnumDescriptor rubyEnumDescriptorescriptor = (RubyEnumDescriptor) getDescriptor(context, recv); Descriptors.EnumDescriptor descriptor = rubyEnumDescriptorescriptor.getDescriptor(); Descriptors.EnumValueDescriptor value = descriptor.findValueByName(name.asJavaString()); if (value == null) return context.runtime.getNil(); return context.runtime.newFixnum(value.getNumber()); }
@JRubyMethod public IRubyObject each(ThreadContext context, Block block) { Ruby runtime = context.runtime; for (Descriptors.EnumValueDescriptor enumValueDescriptor : descriptor.getValues()) { block.yield(context, runtime.newArray(runtime.newSymbol(enumValueDescriptor.getName()), runtime.newFixnum(enumValueDescriptor.getNumber()))); } return runtime.getNil(); }