/** {@inheritDoc} */ @Override public void serialize(BinaryObjectImpl bin, JsonGenerator gen, SerializerProvider ser) throws IOException { try { BinaryType meta = bin.rawType(); // Serialize to JSON if we have metadata. if (meta != null && !F.isEmpty(meta.fieldNames())) { gen.writeStartObject(); for (String name : meta.fieldNames()) { Object val = bin.field(name); if (val instanceof BinaryObjectImpl) { BinaryObjectImpl ref = (BinaryObjectImpl)val; if (ref.hasCircularReferences()) throw ser.mappingException("Failed convert to JSON object for circular references"); } gen.writeObjectField(name, val); } gen.writeEndObject(); } else { // Otherwise serialize as Java object. Object obj = bin.deserialize(); gen.writeObject(obj); } } catch (BinaryObjectException ignore) { gen.writeNull(); } } };
/** * @return Value. */ public static BinaryObject doReadBinaryObject(BinaryInputStream in, BinaryContext ctx, boolean detach) { if (in.offheapPointer() > 0) { int len = in.readInt(); int pos = in.position(); in.position(in.position() + len); int start = in.readInt(); return new BinaryObjectOffheapImpl(ctx, in.offheapPointer() + pos, start, len); } else { byte[] arr = doReadByteArray(in); int start = in.readInt(); BinaryObjectImpl binO = new BinaryObjectImpl(ctx, arr, start); if (detach) { binO.detachAllowed(true); return binO.detach(); } return binO; } }
/** * Constructor. * * @param obj Object. * @param valCtx Object value context. */ public GridH2ValueCacheObject(CacheObject obj, CacheObjectValueContext valCtx) { assert obj != null; if (obj instanceof BinaryObjectImpl) { ((BinaryObjectImpl)obj).detachAllowed(true); obj = ((BinaryObjectImpl)obj).detach(); } this.obj = obj; this.valCtx = valCtx; }
b.deserialize(); // deserialize working byte[] a = b.array(); for (int i = b.dataStartOffset(), j = b.footerStartOffset(); i < j; ++i) { byte old = a[i]; b.deserialize();
/** {@inheritDoc} */ @Override public KeyCacheObject copy(int part) { if (this.part == part) return this; BinaryObjectImpl cp = new BinaryObjectImpl(ctx, arr, start); cp.part = part; return cp; }
int res = Integer.compare(first.typeId(), second.typeId()); res = Integer.compare(first.hashCode(), second.hashCode()); int firstDataStart = first.dataStartOffset(); int secondDataStart = second.dataStartOffset(); int firstLen = first.footerStartOffset() - firstDataStart; int secondLen = second.footerStartOffset() - secondDataStart;
new DetachedInnerTestObject(null, id)), marsh).deserialize(); assert innerPo.detached(); DetachedInnerTestObject inner = innerPo.deserialize(); BinaryObjectImpl detachedPo = (BinaryObjectImpl)innerPo.detach(); assert detachedPo.detached(); inner = detachedPo.deserialize(); assert innerPo.detached(); inner = innerPo.deserialize(); detachedPo = (BinaryObjectImpl)innerPo.detach(); assert detachedPo.detached(); inner = innerPo.deserialize();
/** * @return Detached binary object. */ public BinaryObjectImpl detach() { if (!detachAllowed || detached()) return this; int len = length(); byte[] arr0 = new byte[len]; U.arrayCopy(arr, start, arr0, 0, len); return new BinaryObjectImpl(ctx, arr0, 0); }
ptr, 0, obj.array().length); assertFalse(offheapObj.equals("str")); assertTrue(offheapObj.equals(obj)); assertTrue(obj.equals(offheapObj)); ptr1, 0, obj.array().length); assertEquals(obj.type().typeId(), offheapObj.type().typeId()); assertEquals(obj.hashCode(), offheapObj.hashCode()); assertEquals(obj.type().typeId(), offheapObj.type().typeId()); assertEquals(obj.hashCode(), offheapObj.hashCode()); BinaryObjectImpl innerObj = obj.field("inner"); assertFalse(obj.equals(offheapObj)); ptr2, 0, obj.array().length);
assert !objBin.hasField(fieldName); assert objBin.hasField(fieldNameA); assert objBin.hasField(fieldNameB); assertNull(objBin.field(fieldName)); assertEquals(Integer.valueOf(1), objBin.field(fieldNameA)); assertEquals(Integer.valueOf(2), objBin.field(fieldNameB)); BinaryType type = objBin.type(); DuplicateFieldsB deserialized = objBin.deserialize();
BinaryObjectImpl portObj = marshal(obj1, marsh); assertArrayEquals(obj1.valArr, portObj.<BigDecimal[]>field("valArr")); assertArrayEquals(obj1.valArr, portObj.<DecimalReflective>deserialize().valArr); assertArrayEquals(obj1.valArr, (BigDecimal[])portObj.type().field("valArr").value(portObj)); assertEquals(obj1.val, portObj.field("val")); assertEquals(obj1.val, portObj.<DecimalReflective>deserialize().val); assertEquals(obj1.val, portObj.type().field("val").value(portObj)); assertEquals(obj2.val, portObj.field("val")); assertArrayEquals(obj2.valArr, portObj.<BigDecimal[]>field("valArr")); assertEquals(obj2.val, portObj.<DecimalMarshalAware>deserialize().val); assertArrayEquals(obj2.valArr, portObj.<DecimalMarshalAware>deserialize().valArr); assertEquals(obj2.rawVal, portObj.<DecimalMarshalAware>deserialize().rawVal); assertArrayEquals(obj2.rawValArr, portObj.<DecimalMarshalAware>deserialize().rawValArr); assertEquals(obj2.val, portObj.type().field("val").value(portObj)); assertArrayEquals(obj2.valArr, (BigDecimal[])portObj.type().field("valArr").value(portObj)); assertEquals(obj2.val, portObj.field("val")); assertEquals(obj2.val, portObj.<DecimalMarshalAware>deserialize().val); assertEquals(obj2.val, portObj.type().field("val").value(portObj));
/** * */ @Test public void testReadResolve() throws Exception { BinaryMarshaller marsh = binaryMarshaller(Arrays.asList( new BinaryTypeConfiguration(MySingleton.class.getName()), new BinaryTypeConfiguration(SingletonMarker.class.getName()))); BinaryObjectImpl binaryObj = marshal(MySingleton.INSTANCE, marsh); assertTrue(binaryObj.array().length <= 1024); // Check that big string was not serialized. MySingleton singleton = binaryObj.deserialize(); assertSame(MySingleton.INSTANCE, singleton); }
/** * Constructor. * * @param objImpl Binary object */ BinaryBuilderReader(BinaryObjectImpl objImpl) { ctx = objImpl.context(); arr = objImpl.array(); pos = objImpl.start(); reader = new BinaryReaderExImpl(ctx, BinaryHeapInputStream.create(arr, pos), ctx.configuration().getClassLoader(), false); objMap = new HashMap<>(); }
/** * Gets the Java filter if present. * * @param filter Filter object. * @param ctx Context. * @return Java filter or null. */ private static CacheEntryEventFilter getJavaFilter(Object filter, GridKernalContext ctx) { if (filter instanceof BinaryObjectImpl) { BinaryObjectImpl bo = (BinaryObjectImpl)filter; if (bo.typeId() == GridBinaryMarshaller.PLATFORM_JAVA_OBJECT_FACTORY_PROXY) { PlatformJavaObjectFactoryProxy prx = bo.deserialize(); return (CacheEntryEventFilter)prx.factory(ctx).create(); } } return null; }
/** * @throws Exception If failed. */ @Test public void testKeepDeserialized() throws Exception { BinaryMarshaller marsh = binaryMarshaller(Arrays.asList(new BinaryTypeConfiguration(SimpleObject.class.getName()))); BinaryObjectImpl po = marshal(simpleObject(), marsh); CacheObjectContext coCtx = new CacheObjectContext(newContext(), null, null, false, false, true, false, false); assert po.value(coCtx, false) == po.value(coCtx, false); po = marshal(simpleObject(), marsh); assert po.deserialize() != po.deserialize(); }
BinaryObjectImpl binObjRaw1 = marshal(objectRaw, m1); assertNotEquals(binObj0.array().length, binObj1.array().length); assertNotEquals(binObjWithRaw0.array().length, binObjWithRaw1.array().length); assertNotEquals(binObjRaw0.array().length, binObjRaw1.array().length); BinaryObjectImpl binObjRawOther1 = marshal(objectRawOther, m1); assertEquals(binObjOther0.length(), binObj0.length()); assertEquals(binObjOther1.length(), binObj1.length()); assertEquals(binObjWithRawOther0.length(), binObjWithRaw0.length()); assertEquals(binObjWithRawOther1.length(), binObjWithRaw1.length()); assertEquals(binObjRawOther0.length(), binObjRaw0.length()); assertEquals(binObjRawOther1.length(), binObjRaw1.length());
/** * */ @Test public void testReadResolveOnBinaryAware() throws Exception { BinaryMarshaller marsh = binaryMarshaller(Collections.singletonList( new BinaryTypeConfiguration(MyTestClass.class.getName()))); BinaryObjectImpl binaryObj = marshal(new MyTestClass(), marsh); MyTestClass obj = binaryObj.deserialize(); assertEquals("readResolve", obj.s); }
/** * @param po Binary object. */ public void doWriteBinaryObject(@Nullable BinaryObjectImpl po) { if (po == null) out.writeByte(GridBinaryMarshaller.NULL); else { byte[] poArr = po.array(); out.unsafeEnsure(1 + 4 + poArr.length + 4); out.unsafeWriteByte(GridBinaryMarshaller.BINARY_OBJ); out.unsafeWriteInt(poArr.length); out.writeByteArray(poArr); out.unsafeWriteInt(po.start()); } }