/** * Create a new instance of {@param type}, must have a default constructor */ public <T> T newInstance(Class<T> type) { if (type == lastClass) { return (T) lastFactory.newInstance(); } lastFactory = factories.get(type); lastClass = type; return (T) lastFactory.newInstance(); } }
public static <R> InstanceFactory<R> defaultFactory(Class<R> type) { return new DefaultInstanceFactory<>(type); }
private T readBean(Contexts.ReadContext context) { T bean = instanceFactory.newInstance(); for (Serializer handler : fieldSerializers) { handler.readIntoField(bean, context); } return bean; } }
public static <R> BeanBuilder<R> stub(final Class<R> type) { InstanceFactory<R> fact = new DefaultInstanceFactory<>(type); R stub = fact.newInstance(); ProxyFactory factory = new ProxyFactory(stub); final Stack<Method> m = new Stack<>(); factory.addAdvice(new MethodInterceptor() { @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { PropertyDescriptor descriptor = BeanUtils.findPropertyForMethod(methodInvocation.getMethod()); if (descriptor == null) { throw new IllegalStateException(String.format("Method %s is not a getter or setter", methodInvocation.getMethod().getName())); } m.push(methodInvocation.getMethod()); return defaultReturnObjects.get(methodInvocation.getMethod().getReturnType()); } }); return new BeanBuilder<>((R) factory.getProxy(), fact, m); }
@Override public void initialize(TypeRef typeRef, SerializerContext context) { contentSerializer = context.serializer(typeRef.getTypeParameters().get(0), this); cache = new InstanceFactoryCache(getFactories()); }
private T readCollection(Contexts.ReadContext context) { T c = (T) cache.newInstance(context.getMeta().readConcreteType()); int count = context.getMeta().readRepetitionCount(); for (int i = 0; i < count; i++) { c.add(contentSerializer.readValue(context)); } return c; } }
/** * Get a instance factory for this type, if none is found {@link com.github.jasonruckman.sidney.core.serde.factory.DefaultInstanceFactory} */ public <T> InstanceFactory<T> get(Class<?> type) { InstanceFactory<T> factory = conf.getRegistrations().getInstanceFactories().get(type); if (factory == null) { factory = defaultFactories.get(type); if (factory == null) { factory = (InstanceFactory<T>) defaultFactory(type); defaultFactories.put(type, factory); } } return factory; } }
@Override public void initialize(TypeRef typeRef, SerializerContext context) { fieldSerializers = new Serializer[typeRef.getFields().size()]; for(int i = 0; i < fieldSerializers.length; i++) { fieldSerializers[i] = context.serializer(typeRef.getFields().get(i), this); } instanceFactory = getFactories().get(typeRef.getType()); }
public SerializerContextImpl(Configuration conf, References references) { this.conf = conf; this.references = references; registrations = conf.getRegistrations(); factories = new Factories(conf); addCustomFactories(); addPrimitiveFactories(); addArrayFactories(); addJdkDefaults(); addEntry(Collection.class, CollectionSerializer.class); addEntry(Map.class, MapSerializer.class); addEntry(Object.class, BeanSerializer.class); }
public HashMap<K, V> nextHashMap() { HashMap<K, V> map = hashMapFactory.newInstance(); for (int i = 0; i < sizeGenerator.next(); i++) { map.put(keyGenerator.next(), valueGenerator.next()); } return map; }
@Override public void initialize(TypeRef typeRef, SerializerContext context) { keySerializer = context.serializer(typeRef.getTypeParameters().get(0), this); valueSerializer = context.serializer(typeRef.getTypeParameters().get(1), this); cache = new InstanceFactoryCache(getFactories()); }
private T readMap(Contexts.ReadContext context) { T map = (T) cache.newInstance(context.getMeta().readConcreteType()); int size = context.getMeta().readRepetitionCount(); for (int i = 0; i < size; i++) { map.put(keySerializer.readValue(context), valueSerializer.readValue(context)); } return map; } }
@Override public Map<K, V> next() { Map<K, V> map = hashMapFactory.newInstance(); for (int i = 0; i < sizeGenerator.next(); i++) { map.put(keyGenerator.next(), valueGenerator.next()); } return map; }
public TreeMap<K, V> nextTreeMap() { TreeMap<K, V> map = treeMapFactory.newInstance(); for (int i = 0; i < sizeGenerator.next(); i++) { map.put(keyGenerator.next(), valueGenerator.next()); } return map; }
@Override public T next() { T newStub = factory.newInstance(); for (FieldAndStrategy fieldAndStrategy : strategies) { fieldAndStrategy.getAccessor().set(newStub, fieldAndStrategy.getStrategy().next()); } return newStub; } };