@Override public boolean shouldReplicate(FieldMetadata<?, ?> field, boolean initial, boolean toOwner) { switch (field.getName()) { case "lightDiffuseIntensity": case "lightAmbientIntensity": return initial || !simulateFading; } return true; } }
@Override public String getTitle() { return field.getName(); }
public MappedContainerTypeHandler(Class<T> clazz, Map<FieldMetadata<T, ?>, TypeHandler<?>> mappedFields) { this.clazz = clazz; this.mappedFields = mappedFields; for (FieldMetadata<T, ?> field : mappedFields.keySet()) { this.fieldByName.put(UriUtil.normalise(field.getName()), field); } }
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; }
/** * Scans the class this metadata describes, adding all fields to the class' metadata. * * @param copyStrategyLibrary The library of copy strategies * @param factory The reflection provider */ private void addFields(CopyStrategyLibrary copyStrategyLibrary, ReflectFactory factory, Predicate<Field> includedFieldsPredicate) { for (Field field : ReflectionUtils.getAllFields(clazz, includedFieldsPredicate)) { if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) { continue; } CopyStrategy<?> copyStrategy = copyStrategyLibrary.getStrategy(field.getGenericType()); try { FIELD metadata = createField(field, copyStrategy, factory); if (metadata != null) { fields.put(metadata.getName().toLowerCase(Locale.ENGLISH), metadata); } } catch (InaccessibleFieldException e) { logger.error("Could not create metadata for field '{}' of type '{}', may be private.'", field, clazz); } } }
@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); }
/** * 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; }
if (jsonObject.has(field.getSerializationName())) { unknownFields.remove(field.getSerializationName()); if (field.getName().equals(CONTENTS_FIELD) && UILayout.class.isAssignableFrom(elementMetadata.getType())) { continue; logger.error("Failed to deserialize field {} of {}", field.getName(), type, 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); } }
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); } }
@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()); }