/** * This method is for use in situations where metadata is being used generically and the actual type of the value cannot be * * @param object The instance of this class to copy * @return A copy of the given object, or null if object is not of the type described by this metadata. */ public T copyRaw(Object object) { if (getType().isInstance(object)) { return copy(getType().cast(object)); } return null; }
@Override public <U extends WorldGeneratorPlugin> List<U> instantiateAllOfType(Class<U> ofType) { List<U> result = Lists.newArrayList(); for (ClassMetadata classMetadata : library) { if (ofType.isAssignableFrom(classMetadata.getType()) && classMetadata.isConstructable() && classMetadata.getType().getAnnotation(RegisterPlugin.class) != null) { U item = ofType.cast(classMetadata.newInstance()); if (item != null) { result.add(item); } } } return result; } }
/** * returns the class representing the block family based off the registered id. * * @param uri * @return */ public Class<? extends BlockFamily> getBlockFamily(String uri) { ClassMetadata<? extends BlockFamily, ?> resolved = library.resolve(uri); if (uri == null || uri.isEmpty() || resolved == null) { logger.error(" Failed to resolve Blockfamily {}", uri); return SymmetricFamily.class; } return resolved.getType(); }
@Override public void register(SimpleUri uri, Class<? extends T> clazz) { ClassMetadata<? extends T, ?> metadata = createMetadata(clazz, reflectFactory, copyStrategyLibrary, uri); if (metadata != null) { classLookup.put(clazz, metadata); ClassMetadata<? extends T, ?> prev = uriLookup.put(uri.getObjectName(), uri.getModuleName(), metadata); if (prev != null && !prev.equals(metadata)) { logger.warn("Duplicate entry for '{}': {} and {}", uri, prev.getType(), metadata.getType()); } } }
@Override public String toString() { if (uri.isValid()) { return uri.toString(); } return getType().toString(); }
/** * @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(); } }
private <T> Map<Class<? extends T>, Integer> generateIds(ClassLibrary<T> classLibrary) { Map<Class<? extends T>, Integer> result = Maps.newHashMap(); for (ClassMetadata<? extends T, ?> metadata : classLibrary) { int index = result.size(); result.put(metadata.getType(), index); int fieldId = 0; for (FieldMetadata<?, ?> field : metadata.getFields()) { if (fieldId >= 256) { logger.error("Class {} has too many fields (>255), serialization will be incomplete", metadata.getUri()); break; } field.setId((byte) fieldId); fieldId++; } } return result; }
public void apply(UISkinBuilder builder) { super.apply(builder); if (elements != null) { for (Map.Entry<String, ElementInfo> entry : elements.entrySet()) { ClassLibrary<UIWidget> library = CoreRegistry.get(NUIManager.class).getWidgetMetadataLibrary(); ClassMetadata<? extends UIWidget, ?> metadata = library.resolve(entry.getKey(), ModuleContext.getContext()); if (metadata != null) { builder.setElementClass(metadata.getType()); entry.getValue().apply(builder); } else { logger.warn("Failed to resolve UIWidget class {}, skipping style information", entry.getKey()); } } } } }
public AbstractClassLibrary(AbstractClassLibrary<T> factory, CopyStrategyLibrary copyStrategies) { this.reflectFactory = factory.reflectFactory; this.copyStrategyLibrary = copyStrategies; for (Table.Cell<Name, Name, ClassMetadata<? extends T, ?>> cell: factory.uriLookup.cellSet()) { Name objectName = cell.getRowKey(); Name moduleName = cell.getColumnKey(); ClassMetadata<? extends T, ?> oldMetaData = cell.getValue(); Class<? extends T> clazz = oldMetaData.getType(); SimpleUri uri = oldMetaData.getUri(); ClassMetadata<? extends T, ?> metadata = createMetadata(clazz, factory.reflectFactory, copyStrategies, uri); if (metadata != null) { classLookup.put(clazz, metadata); uriLookup.put(objectName, moduleName, metadata); } else { throw new RuntimeException("Failed to create copy of class library"); } } }
if (jsonObject.has(field.getSerializationName())) { unknownFields.remove(field.getSerializationName()); if (field.getName().equals(CONTENTS_FIELD) && UILayout.class.isAssignableFrom(elementMetadata.getType())) { continue; if (UILayout.class.isAssignableFrom(elementMetadata.getType())) { UILayout<LayoutHint> layout = (UILayout<LayoutHint>) element; ReflectionUtil.getTypeParameter(elementMetadata.getType().getGenericSuperclass(), 0); if (jsonObject.has(CONTENTS_FIELD)) { for (JsonElement child : jsonObject.getAsJsonArray(CONTENTS_FIELD)) {
.getWidgetMetadataLibrary() .resolve(type, ModuleContext.getContext()) .getType(); } else { if (List.class.isAssignableFrom(currentClass) .getWidgetMetadataLibrary() .resolve(type, ModuleContext.getContext()) .getType(); .getWidgetMetadataLibrary() .resolve(type, ModuleContext.getContext()) .getType();
private <T> Map<Class<? extends T>, Integer> applySerializationInfo(List<NetData.SerializationInfo> infoList, ClassLibrary<T> classLibrary) { Map<Class<? extends T>, Integer> idTable = Maps.newHashMap(); for (NetData.SerializationInfo info : infoList) { ClassMetadata<? extends T, ?> metadata = classLibrary.getMetadata(new SimpleUri(info.getName())); if (metadata != null) { idTable.put(metadata.getType(), info.getId()); for (int i = 0; i < info.getFieldIds().size(); ++i) { FieldMetadata<?, ?> field = metadata.getField(info.getFieldName(i)); if (field != null) { field.setId(info.getFieldIds().byteAt(i)); } else { logger.error("Server has unknown field '{}' on '{}'", info.getFieldName(i), info.getName()); } } } else { logger.error("Server has unknown class '{}'", info.getName()); } } return idTable; }