@Override public boolean shouldReplicate(FieldMetadata<?, ?> field, boolean initial, boolean toOwner) { switch (field.getName()) { case "lightDiffuseIntensity": case "lightAmbientIntensity": return initial || !simulateFading; } return true; } }
@Override public Float get() { return (Float) fieldMetadata.getValueChecked(target); }
@Override public void set(Float value) { fieldMetadata.setValue(target, value); } };
/** * @param object The instance of this class to copy * @return A copy of the given object */ public T copy(T object) { T result = constructor.construct(); if (result != null) { for (FIELD field : fields.values()) { field.setValue(result, field.getCopyOfValue(object)); } } return result; }
logger.warn("UIWidget type {} lacks id field", elementMetadata.getUri()); } else { fieldMetadata.setValue(element, id); if (jsonObject.has(field.getSerializationName())) { unknownFields.remove(field.getSerializationName()); if (field.getName().equals(CONTENTS_FIELD) && UILayout.class.isAssignableFrom(elementMetadata.getType())) { continue; if (List.class.isAssignableFrom(field.getType())) { Type contentType = ReflectionUtil.getTypeParameter(field.getField().getGenericType(), 0); if (contentType != null) { List<Object> result = Lists.newArrayList(); JsonArray list = jsonObject.getAsJsonArray(field.getSerializationName()); for (JsonElement item : list) { result.add(context.deserialize(item, contentType)); field.setValue(element, result); field.setValue(element, context.deserialize(jsonObject.get(field.getSerializationName()), field.getType())); logger.error("Failed to deserialize field {} of {}", field.getName(), type, e);
/** * Deserializes a value onto an object * * @param target The object to deserialize the field onto * @param fieldMetadata The metadata of the field * @param data The serialized value of the field * @param context The deserialization context */ public void deserializeOnto(Object target, FieldMetadata<?, ?> fieldMetadata, PersistedData data, DeserializationContext context) { TypeHandler<?> handler = getHandlerFor(fieldMetadata); if (handler == null) { logger.error("No type handler for type {} used by {}::{}", fieldMetadata.getType(), target.getClass(), fieldMetadata); } else { try { Object deserializedValue = handler.deserialize(data, context); fieldMetadata.setValue(target, deserializedValue); } catch (DeserializationException e) { logger.error("Unable to deserialize field '{}' from '{}'", fieldMetadata.getName(), data.toString(), e); } } }
private List<ComponentFieldUri> determineAnimationPoolUris() { final List<ComponentFieldUri> animationSetUris = Lists.newArrayList(); for (ComponentMetadata<?> componentMetadata : componentLibrary.iterateComponentMetadata()) { SimpleUri uri = componentMetadata.getUri(); for (FieldMetadata<?, ?> fieldMetadata : componentMetadata.getFields()) { if (fieldMetadata.getType().isAssignableFrom(List.class)) { Type fieldType = fieldMetadata.getField().getGenericType(); if (fieldType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) fieldType; Type[] typeArguments = parameterizedType.getActualTypeArguments(); if (typeArguments.length == 1) { Class<?> typeClass = ReflectionUtil.getClassOfType(typeArguments[0]); if (typeClass.isAssignableFrom(MeshAnimation.class)) { animationSetUris.add(new ComponentFieldUri(uri, fieldMetadata.getName())); } } } } } } return animationSetUris; }
private void serializeEventInfo(NetData.ServerInfoMessage.Builder serverInfoMessageBuilder) { Map<Class<? extends Event>, Integer> eventIdTable = eventSerializer.getIdMapping(); for (Map.Entry<Class<? extends Event>, Integer> eventMapping : eventIdTable.entrySet()) { ByteString.Output fieldIds = ByteString.newOutput(); EventMetadata<?> metadata = eventLibrary.getMetadata(eventMapping.getKey()); NetData.SerializationInfo.Builder info = NetData.SerializationInfo.newBuilder() .setId(eventMapping.getValue()) .setName(metadata.getUri().toString()); for (FieldMetadata<?, ?> field : metadata.getFields()) { fieldIds.write(field.getId()); info.addFieldName(field.getName()); } info.setFieldIds(fieldIds.toByteString()); serverInfoMessageBuilder.addEvent(info); } }
protected Binding<Float> createFloatBinding(Object target, final FieldMetadata<Object, ?> fieldMetadata) { Class<?> type = fieldMetadata.getType(); if (type == Integer.class || type == Integer.TYPE) { return new Binding<Float>() {
@Test public void testPrivateField() throws Exception { DefaultClassMetadata<PrivateField> metadata = new DefaultClassMetadata<>(new SimpleUri(), PrivateField.class, factory, copyStrategyLibrary); assertNotNull(metadata); assertEquals(1, metadata.getFieldCount()); FieldMetadata fieldMetadata = metadata.getField("name"); assertNotNull(fieldMetadata); assertEquals(String.class, fieldMetadata.getType()); assertEquals("name", fieldMetadata.getName()); assertNotNull(metadata.newInstance()); }
private Map<FieldMetadata<?, ?>, TypeHandler> getFieldHandlerMap(ClassMetadata<?, ?> type) { Map<FieldMetadata<?, ?>, TypeHandler> handlerMap = Maps.newHashMap(); for (FieldMetadata<?, ?> field : type.getFields()) { TypeHandler<?> handler = getHandlerFor(field.getField().getGenericType()); if (handler != null) { handlerMap.put(field, handler); } else { logger.info("Unsupported field: '{}.{}'", type.getUri(), field.getName()); } } return handlerMap; }
@Override public PersistedData serialize(T value, SerializationContext context) { if (value == null) { return context.createNull(); } Map<String, PersistedData> mappedData = Maps.newLinkedHashMap(); for (Map.Entry<FieldMetadata<T, ?>, TypeHandler<?>> entry : mappedFields.entrySet()) { Object val = entry.getKey().getValue(value); if (val != null) { TypeHandler handler = entry.getValue(); PersistedData fieldValue = handler.serialize(val, context); if (fieldValue != null) { mappedData.put(entry.getKey().getName(), fieldValue); } } } return context.create(mappedData); }
private <T extends Component> void updateComponent(EntityRef blockEntity, ComponentMetadata<T> metadata, T targetComponent) { T currentComp = blockEntity.getComponent(metadata.getType()); if (currentComp != null) { boolean changed = false; for (FieldMetadata<T, ?> field : metadata.getFields()) { Object newVal = field.getValue(targetComponent); if (!Objects.equal(field.getValue(currentComp), newVal)) { field.setValue(currentComp, newVal); changed = true; } } if (changed) { blockEntity.saveComponent(currentComp); } } }
@Override protected <V> FieldMetadata<T, V> createField(Field field, CopyStrategy<V> copyStrategy, ReflectFactory factory) throws InaccessibleFieldException { return new FieldMetadata<>(this, field, copyStrategy, factory); } }
/** * For types that need to be copied (e.g. Vector3f) for safe usage, this method will create a new copy of a field from an object. * Otherwise it behaves the same as getValue * This method is checked to conform to the generic parameters of the FieldMetadata * * @param from The object to copy the field from * @return A safe to use copy of the value of this field in the given object */ public U getCopyOfValueChecked(T from) { return getCopyOfValue(from); }
/** * @param owner The ClassMetadata that owns this field * @param field The field this metadata is for * @param copyStrategy The CopyStrategy appropriate for the type of the field * @param factory The reflection provider */ @SuppressWarnings("unchecked") public FieldMetadata(ClassMetadata<T, ?> owner, Field field, CopyStrategy<U> copyStrategy, ReflectFactory factory) throws InaccessibleFieldException { this.owner = owner; this.copyStrategy = copyStrategy; this.type = (Class<U>) determineType(field, owner.getType()); this.accessor = factory.createFieldAccessor(owner.getType(), field, type); this.field = field; SerializedName name = field.getAnnotation(SerializedName.class); if (name != null) { serializationName = name.value(); } else { serializationName = field.getName(); } }
public Object getComponentField(ComponentFieldUri uri) { ComponentLibrary componentLibrary = CoreRegistry.get(EntitySystemLibrary.class).getComponentLibrary(); ComponentMetadata<? extends Component> metadata = componentLibrary.getMetadata(uri.getComponentUri()); if (metadata == null) { return null; } Component component = entity.getComponent(metadata.getType()); if (component == null) { return null; } FieldMetadata<?, ?> fieldMetadata = metadata.getField(uri.getFieldName()); if (fieldMetadata == null) { return null; } Field field = fieldMetadata.getField(); try { return field.get(component); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }
private void serializeComponentInfo(NetData.ServerInfoMessage.Builder serverInfoMessageBuilder) { Map<Class<? extends Component>, Integer> componentIdTable = entitySerializer.getIdMapping(); for (Map.Entry<Class<? extends Component>, Integer> componentIdMapping : componentIdTable.entrySet()) { ByteString.Output fieldIds = ByteString.newOutput(); ComponentMetadata<?> metadata = componentLibrary.getMetadata(componentIdMapping.getKey()); NetData.SerializationInfo.Builder info = NetData.SerializationInfo.newBuilder() .setId(componentIdMapping.getValue()) .setName(metadata.getUri().toString()); for (FieldMetadata<?, ?> field : metadata.getFields()) { fieldIds.write(field.getId()); info.addFieldName(field.getName()); } info.setFieldIds(fieldIds.toByteString()); serverInfoMessageBuilder.addComponent(info); } }
@Override @SuppressWarnings("unchecked") public void set(Float value) { Class<? extends Number> type = binding.fieldMetadata.getType(); if (type == Integer.TYPE || type == Integer.class) { ((Binding<Integer>) binding).set(value.intValue()); } else if (type == Float.TYPE || type == Float.class) { ((Binding<Float>) binding).set(value); } } }