public void testSortedSetWithNaturalOrderingOnRefs() throws Exception { Object factoryBean = appContext.getBean("&sortedSetWithNaturalOrderingOnRefs"); assertTrue(factoryBean instanceof OsgiServiceCollectionProxyFactoryBean); Comparator comp = getComparator(factoryBean); assertNotNull(comp); assertSame(ServiceReferenceComparator.class, comp.getClass()); Class<?>[] intfs = getInterfaces(factoryBean); assertTrue(Arrays.equals(new Class<?>[] { Externalizable.class }, intfs)); OsgiServiceLifecycleListener[] listeners = getListeners(factoryBean); assertEquals(2, listeners.length); Object bean = appContext.getBean("sortedSetWithNaturalOrderingOnRefs"); assertFalse(bean instanceof OsgiServiceSortedSet); assertTrue(bean instanceof SortedSet); }
public static byte[] toCompressedBytes(@Nonnull final Externalizable obj, @Nonnull final CompressionAlgorithm algo, final boolean bin2txt) throws IOException { FastMultiByteArrayOutputStream bos = new FastMultiByteArrayOutputStream(); OutputStream out = null; FinishableOutputStream dos = null; try { out = bin2txt ? new Base91OutputStream(bos) : bos; dos = CompressionStreamFactory.createOutputStream(out, algo); toStream(obj, dos); dos.finish(); //dos.flush(); return bos.toByteArray_clear(); } finally { IOUtils.closeQuietly(dos); IOUtils.closeQuietly(out); } }
@Override protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { switch(code) { case TRANSACT_methodReturningTheExternalizable: { data.enforceInterface(this.getInterfaceDescriptor()); final Externalizable returnValue = delegate.methodReturningTheExternalizable(); reply.writeNoException(); AidlUtil.writeToObjectStream(reply, returnValue); return true; } } return super.onTransact(code, data, reply, flags); }
@Override public Externalizable methodReturningTheExternalizable() throws RemoteException { Parcel data = Parcel.obtain(); Parcel reply = Parcel.obtain(); try { data.writeInterfaceToken(ExternalizableTest3$$AidlServerImpl.DESCRIPTOR); delegate.transact(ExternalizableTest3$$AidlServerImpl.TRANSACT_methodReturningTheExternalizable, data, reply, 0); reply.readException(); return AidlUtil.readFromObjectStream(reply); } finally { data.recycle(); reply.recycle(); } }
/** * Returns the instantiated bean. * If the bean implements <code>CommandObject</code>, its * <code>setCommandContext</code> method will be called. * @param dh the data handler describing the command data * @param loader the class loader used to instantiate the bean */ public Object getCommandObject(DataHandler dh, ClassLoader loader) throws IOException, ClassNotFoundException { Object object = Beans.instantiate(loader, className); if (object != null) { if (object instanceof CommandObject) { CommandObject command = (CommandObject)object; command.setCommandContext(verb, dh); } else if (dh != null && (object instanceof Externalizable)) { InputStream in = dh.getInputStream(); if (in != null) { Externalizable externalizable = (Externalizable)object; externalizable.readExternal(new ObjectInputStream(in)); } } } return object; }
public static Graph deSerialize(byte[] byteArray, Class<? extends Externalizable> clazz) { ObjectInputStream ois; Graph graph; try { ois = new ObjectInputStream(new ByteArrayInputStream(byteArray)); graph = (Graph) clazz.newInstance(); graph.readExternal(ois); ois.close(); } catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e) { e.printStackTrace(); return null; } Preconditions.checkNotNull(graph); return graph; }
/** * Determines whether class contains custom Java serialization logic. * * @param cls Class. * @return {@code true} if custom Java serialization logic exists, {@code false} otherwise. */ @SuppressWarnings("unchecked") public static boolean isCustomJavaSerialization(Class cls) { for (Class c = cls; c != null && !c.equals(Object.class); c = c.getSuperclass()) { if (Externalizable.class.isAssignableFrom(c)) return true; try { Method writeObj = c.getDeclaredMethod("writeObject", ObjectOutputStream.class); Method readObj = c.getDeclaredMethod("readObject", ObjectInputStream.class); if (!Modifier.isStatic(writeObj.getModifiers()) && !Modifier.isStatic(readObj.getModifiers()) && writeObj.getReturnType() == void.class && readObj.getReturnType() == void.class) return true; } catch (NoSuchMethodException ignored) { // No-op. } } return false; }
/** * */ protected void readExternalizable(String className, Object object) throws ClassNotFoundException, IOException { if (object instanceof Externalizable) { if (isDebug) trace.startExternalizableObject(className, objectTable.size() - 1); ((Externalizable)object).readExternal(this); } else { //Class '{className}' must implement java.io.Externalizable to receive client IExternalizable instances. SerializationException ex = new SerializationException(); ex.setMessage(10305, new Object[] {object.getClass().getName()}); throw ex; } }
@SneakyThrows public Object deserialize(AmfReader reader) { Object result = cls.newInstance(); if (result instanceof Externalizable) { ((Externalizable) result).readExternal(reader); return result; } for (Map.Entry<String, Object> field : reader.readAmf0KeyValuePairs().entrySet()) { setField(result, field.getKey(), field.getValue()); } return result; }
public void testSortedSetWithNaturalOrderingOnRefs() throws Exception { Object factoryBean = appContext.getBean("&sortedSetWithNaturalOrderingOnRefs"); assertTrue(factoryBean instanceof OsgiServiceCollectionProxyFactoryBean); Comparator comp = getComparator(factoryBean); assertNotNull(comp); assertSame(ServiceReferenceComparator.class, comp.getClass()); Class[] intfs = getInterfaces(factoryBean); assertTrue(Arrays.equals(new Class[] { Externalizable.class }, intfs)); OsgiServiceLifecycleListener[] listeners = getListeners(factoryBean); assertEquals(2, listeners.length); Object bean = appContext.getBean("sortedSetWithNaturalOrderingOnRefs"); assertFalse(bean instanceof OsgiServiceSortedSet); assertTrue(bean instanceof SortedSet); }
protected Object instantiateAndReadNoSer(Class c, FSTClazzInfo clzSerInfo, FSTClazzInfo.FSTFieldInfo referencee, int readPos) throws Exception { Object newObj; newObj = clzSerInfo.newInstance(getCodec().isMapBased()); if (newObj == null) { throw new IOException(referencee.getDesc() + ":Failed to instantiate '" + c.getName() + "'. Register a custom serializer implementing instantiate or define empty constructor.."); } if ( clzSerInfo.isExternalizable() ) { getCodec().ensureReadAhead(readExternalReadAHead); ((Externalizable)newObj).readExternal(this); getCodec().readExternalEnd(); } else { FSTClazzInfo.FSTFieldInfo[] fieldInfo = clzSerInfo.getFieldInfo(); readObjectFields(referencee, clzSerInfo, fieldInfo, newObj,0,0); } return newObj; }
public static void writeNullableObject(Serializable object, ObjectOutput out) throws IOException { boolean isNull = object == null; out.writeBoolean(isNull); if( !isNull ) { if( object instanceof Externalizable ) { ((Externalizable)object).writeExternal(out); } else { out.writeObject(object); } } }
public static byte[] serializeToBytes(Externalizable e) throws IOException { ByteArrayOutputStream bos = null; ObjectOutputStream oos = null; byte[] object; try{ bos = new ByteArrayOutputStream(); oos = new ObjectOutputStream(bos); oos.writeObject(e); oos.flush(); object = bos.toByteArray(); } finally { if(oos != null){ oos.close(); } if(bos != null){ bos.close(); } } return object; }
@Test public void testGet() { InterfaceMap<Object> map = new InterfaceMap<Object>(); A a = new A(); B b = new B(); map.put(a, a); map.put(b, b); assertSame(a, map.get(Runnable.class)); assertSame(b, map.get(Externalizable.class)); assertSame(b, map.get(Comparable.class)); }
private boolean isExcplicitlyRequiredClass(Class<?> i) { Set<Class<?>> requiredClasses = new HashSet<Class<?>>(); requiredClasses.add(EJBTestBase.Caller.class); requiredClasses.add(Comparable.class); requiredClasses.add(Runnable.class); requiredClasses.add(Externalizable.class); requiredClasses.add(javax.enterprise.event.Event.class); requiredClasses.add(org.slf4j.Logger.class); return requiredClasses.contains(i); }
public void testMultipleInterfaces() throws Exception { OsgiServiceProxyFactoryBean factory = (OsgiServiceProxyFactoryBean) appContext.getBean("&multi-interfaces"); Class<?>[] intfs = (Class[]) TestUtils.getFieldValue(factory, "interfaces"); assertNotNull(intfs); assertEquals(2, intfs.length); assertTrue(Arrays.equals(new Class<?>[] { Serializable.class, Externalizable.class }, intfs)); }
public void testSimpleSortedSet() { Object factoryBean = appContext.getBean("&implicitSortedSet"); assertTrue(factoryBean instanceof OsgiServiceCollectionProxyFactoryBean); Object bean = appContext.getBean("implicitSortedSet"); assertFalse(bean instanceof OsgiServiceSortedSet); assertTrue(bean instanceof SortedSet); Class<?>[] intfs = getInterfaces(factoryBean); assertTrue(Arrays.equals(new Class<?>[] { Externalizable.class }, intfs)); }
public void testSortedListWithNaturalOrderingOnServs() throws Exception { Object factoryBean = appContext.getBean("&sortedListWithNaturalOrderingOnServs"); assertTrue(factoryBean instanceof OsgiServiceCollectionProxyFactoryBean); assertNull(getComparator(factoryBean)); Object bean = appContext.getBean("sortedListWithNaturalOrderingOnServs"); assertFalse(bean instanceof OsgiServiceSortedList); assertTrue(bean instanceof List); Class<?>[] intfs = getInterfaces(factoryBean); assertTrue(Arrays.equals(new Class<?>[] { Externalizable.class }, intfs)); }
/** * Method to declare various Java types to be handles as JSON array. * * @param clazz the type * @return <code>true</code> if handles as array * @since 1.4 */ protected boolean isArray(final Class<?> clazz) { return clazz != null && (clazz.isArray() || Collection.class.isAssignableFrom(clazz) || Externalizable.class.isAssignableFrom(clazz) || Map.class.isAssignableFrom(clazz) || Map.Entry.class.isAssignableFrom(clazz)); }
/** * Returns an accessible no-arg constructor for an externalizable class to be * initialized using a public no-argument constructor. * * @param cl the class to instantiate * @return A no-arg constructor for the class; returns {@code null} if * the class does not implement {@link java.io.Externalizable} */ public final Constructor<?> newConstructorForExternalization(Class<?> cl) { if (!Externalizable.class.isAssignableFrom(cl)) { return null; } try { Constructor<?> cons = cl.getConstructor(); cons.setAccessible(true); return cons; } catch (NoSuchMethodException ex) { return null; } }
public final Constructor<?> newConstructorForExternalization(Class<?> cl) { if (!Externalizable.class.isAssignableFrom(cl)) { return null; } try { Constructor<?> cons = cl.getConstructor(); cons.setAccessible(true); return cons; } catch (NoSuchMethodException ex) { return null; } }
public static boolean writeObjectToFile(final File saveFile, final Externalizable data) { ObjectOutput out; try { out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(saveFile, true))); data.writeExternal(out); // out.writeObject(data); out.close(); } catch (Exception e) { Log.e(LOG_TAG, "Error writing bookmark to file", e); return false; } return true; }
/** * Writes an object to the ObjectOutput stream. * If possible, we will send over a magic number instead of the class name * so that we transfer less amount of data. * @param inst - an object instance to be serialized, can not be null * @param out - the ObjectOutput stream we will write the serialized data to */ public static void write(Externalizable inst, ObjectOutput out) throws IOException { boolean is_null=(inst == null); try { // if inst is a null value we write this first out.writeBoolean(is_null); if(is_null) return; //find out if we have a magic number for this class int magic=mConfigurator.getMagicNumber(inst.getClass()); //-1 means no magic number otherwise we have one if(magic != -1) { //true means we use a magic number out.writeBoolean(true); //write the magic number out.writeInt(magic); } else { //we don't have a magic number out.writeBoolean(false); //write the classname instead out.writeUTF(inst.getClass().getName()); }//end if //write the object data inst.writeExternal(out); } catch(Exception x) { if(x instanceof IOException) throw (IOException)x; else throw new java.io.IOException(x.toString()); } }
public static byte[] toCompressedBytes(@Nonnull final Externalizable obj) throws IOException { FastMultiByteArrayOutputStream bos = new FastMultiByteArrayOutputStream(); DeflaterOutputStream dos = new DeflaterOutputStream(bos); try { toStream(obj, dos); dos.finish(); dos.flush(); return bos.toByteArray_clear(); } finally { IOUtils.closeQuietly(dos); } }
public static void readCompressedObject(@Nonnull final byte[] src, @Nonnull final Externalizable dst) throws IOException, ClassNotFoundException { FastByteArrayInputStream bis = new FastByteArrayInputStream(src); final InflaterInputStream iis = new InflaterInputStream(bis); try { readObject(iis, dst); } finally { IOUtils.closeQuietly(iis); } }
public static void readCompressedObject(@Nonnull final byte[] src, final int len, @Nonnull final Externalizable dst, @Nonnull final CompressionAlgorithm algo, final boolean bin2txt) throws IOException, ClassNotFoundException { FastByteArrayInputStream bis = new FastByteArrayInputStream(src, len); InputStream in = null; InputStream compressedStream = null; try { in = bin2txt ? new Base91InputStream(bis) : bis; compressedStream = CompressionStreamFactory.createInputStream(in, algo); readObject(compressedStream, dst); } finally { IOUtils.closeQuietly(compressedStream); IOUtils.closeQuietly(in); } }
public static void readCompressedObject(@Nonnull final byte[] src, final int offset, final int length, @Nonnull final Externalizable dst) throws IOException, ClassNotFoundException { FastByteArrayInputStream bis = new FastByteArrayInputStream(src, offset, length); final InflaterInputStream iis = new InflaterInputStream(bis); try { readObject(iis, dst); } finally { IOUtils.closeQuietly(iis); } }
public Writer(AidlProcessor.Environment environment, State state, CharSequence outParcelName) { super(environment); this.nullable = state.nullable; this.assumeFinal = state.assumeFinal; this.name = state.name; this.allocator = state.allocator; this.parcelName = outParcelName; this.allowUnchecked = state.allowUnchecked; this.sizeType = lookup("android.util.Size"); this.sizeF = lookup("android.util.SizeF"); this.parcelable = lookup("android.os.Parcelable"); this.iBinder = lookup("android.os.IBinder"); this.bundle = lookup("android.os.Bundle"); this.persistable = lookup("android.os.PersistableBundle"); this.sparseBoolArray = lookup("android.util.SparseBooleanArray"); string = lookup(String.class); charSequence = lookup(CharSequence.class); this.serializable = lookup(Serializable.class); this.externalizable = lookup(Externalizable.class); this.theIterator = lookup(Iterator.class); collectionIterator = lookupMethod(theCollection, "iterator", "Iterator"); mapEntrySet = lookupMethod(theMap, "entrySet", Set.class); if (state.returnValue) { flags = Util.literal("$T.PARCELABLE_WRITE_RETURN_VALUE", parcelable); } else { flags = 0; } }
@Override protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { switch(code) { case TRANSACT_methodWithExternalizableReturn: { data.enforceInterface(this.getInterfaceDescriptor()); final Externalizable returnValue = delegate.methodWithExternalizableReturn(); reply.writeNoException(); if (returnValue == null) { reply.writeByte((byte) -1); } else { reply.writeByte((byte) 0); ObjectOutputStream objectOutputStream = null; try { ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream(); objectOutputStream = new ObjectOutputStream(arrayOutputStream); returnValue.writeExternal(objectOutputStream); objectOutputStream.flush(); reply.writeByteArray(arrayOutputStream.toByteArray()); } catch (Exception e) { throw new IllegalStateException("Failed to serialize net.sf.aidl2.SomeExternalizable", e); } finally { AidlUtil.shut(objectOutputStream); } } return true; } } return super.onTransact(code, data, reply, flags); }
/** * Compute the repository id in the RMI hashed format. */ public String getRMIRepositoryID(final Class cx) { long hash = 0; Class of = cx.isArray() ? cx.getComponentType() : null; if (cx.equals(String[].class)) return RMI_STRING_ARRAY_ID; else if (cx.equals(String.class)) return RMI_STRING_ID; else if (cx.equals(Class.class)) return RMI_CLASS_ID; else if (Remote.class.isAssignableFrom(cx) || !Serializable.class.isAssignableFrom(cx) || cx.isInterface() || (cx.isArray() && (!Serializable.class.isAssignableFrom(of) || of.isPrimitive() || Remote.class.isAssignableFrom(of))) ) // Some classes that have zero hash code and serial no version id // included. return "RMI:" + cx.getName() + ":" + toHex(hash); else if (cx.isArray()) // Arrays have the same hashcode and uid as they components. return "RMI:" + cx.getName() + ":" + toHex(getHashCode(of)) + ":" + toHex(getSid(of)); else { if (Externalizable.class.isAssignableFrom(cx)) hash = 1; else hash = getHashCode(cx); return "RMI:" + cx.getName() + ":" + toHex(hash) + ":" + toHex(getSid(cx)); } }
