/** * Gets the schema that was either registered or lazily initialized at runtime. * <p> * Method overload for backwards compatibility. */ public static <T> Schema<T> getSchema(Class<T> typeClass) { return getSchema(typeClass, ID_STRATEGY); }
/** * Generates a schema from the given class. */ public static <T> RuntimeSchema<T> createFrom(Class<T> typeClass, IdStrategy strategy) { return createFrom(typeClass, NO_EXCLUSIONS, strategy); }
return RuntimeSchema.createFrom(typeClass, this); if (rs.getFieldCount() == 0) return rs; final ArrayList<Field<T>> fields = new ArrayList<>(rs.getFieldCount()); for (Field<T> f : rs.getFields()) { final int groupFilter = f.groupFilter; if (groupFilter != 0) { return fields.size() == rs.getFieldCount() ? rs : new RuntimeSchema<>(typeClass, fields, rs.instantiator);
static boolean tryWriteWithoutCause(Output output, Object value, Schema<Object> schema) throws IOException { if (schema instanceof RuntimeSchema && __cause != null) { // ignore the field "cause" if its references itself (cyclic) final RuntimeSchema<Object> ms = (RuntimeSchema<Object>) schema; if (ms.getFieldCount() > 1 && ms.getFields().get(1).name.equals("cause")) { final Object cause; try { cause = __cause.get(value); } catch (Exception e) { throw new RuntimeException(e); } if (cause == value) { // its cyclic, skip the second field "cause" ms.getFields().get(0).writeTo(output, value); for (int i = 2, len = ms.getFieldCount(); i < len; i++) ms.getFields().get(i).writeTo(output, value); return true; } } } return false; }
@Test public void testEntityFullyAnnotated() { RuntimeSchema<EntityFullyAnnotated> schema = (RuntimeSchema<EntityFullyAnnotated>) RuntimeSchema .getSchema(EntityFullyAnnotated.class, RuntimeEnv.ID_STRATEGY); assertTrue(schema.getFieldCount() == 2); assertEquals(schema.getFields().get(0).name, "id"); assertEquals(schema.getFields().get(0).number, 3); assertEquals(schema.getFields().get(1).name, "name"); assertEquals(schema.getFields().get(1).number, 5); assertTrue(schema.getFieldNumber("alias") == 0); assertNull(schema.getFieldByName("alias")); }
public void testPipe() throws Exception { Schema<Zoo> schema = RuntimeSchema.getSchema(Zoo.class); Pipe.Schema<Zoo> pipeSchema = ((RuntimeSchema<Zoo>) schema).getPipeSchema(); Zoo p = filledZoo(); ProtostuffPipeTest.roundTrip(p, schema, pipeSchema); }
@Test public void testPojoWithMappedAbstractTypes() { RuntimeSchema<PojoWithMappedAbstractTypes> schema = (RuntimeSchema<PojoWithMappedAbstractTypes>) RuntimeSchema .getSchema(PojoWithMappedAbstractTypes.class, RuntimeEnv.ID_STRATEGY); assertTrue(schema.getFields().size() == 4); assertTrue(schema.getFields().get(0) instanceof RuntimeMessageField); assertTrue(schema.getFields().get(1) instanceof RuntimeMessageField); assertTrue(schema.getFields().get(2) instanceof RuntimeObjectField); assertTrue(schema.getFields().get(3) instanceof RuntimeDerivativeField); }
.getSchema(ComplexFieldsPojo.class); assertTrue(mappedSchema.getFieldCount() == 45); mappedSchema.getFieldByName("someCollectionValueArray"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueCollection"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueList"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueSet"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueMap"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueObject"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someCollectionValueWildcard"), expectedCollectionClass); assertAssignable(mappedSchema.getFieldByName("someListValueArray"), expectedCollectionClass); assertAssignable( mappedSchema.getFieldByName("someListValueCollection"),
@Test public void testEntityWithFieldAlias() { RuntimeSchema<EntityWithFieldAlias> schema = (RuntimeSchema<EntityWithFieldAlias>) RuntimeSchema .getSchema(EntityWithFieldAlias.class, RuntimeEnv.ID_STRATEGY); assertTrue(schema.getFieldCount() == 2); // The field with the smallest field number will be written first. // In this case, field200 (despite field400 being declared 1st) verify(schema, 200, "f200", 0); verify(schema, 400, "field400", 1); }
@Test public void testEmptyFieldsPojo() { RuntimeSchema<EmptyFieldsPojo> schema = RuntimeSchema.createFrom(EmptyFieldsPojo.class, RuntimeEnv.ID_STRATEGY); Assert.assertNotNull(schema); Assert.assertEquals(0, schema.getFieldCount()); }
@Test public void testSerializeDeserializeNumericEnum() throws Exception { RuntimeSchema<A> schema = RuntimeSchema.createFrom(A.class); A source = new A(TaggedEnum.TEN); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); LinkedBuffer buffer = LinkedBuffer.allocate(); ProtostuffIOUtil.writeTo(outputStream, source, schema, buffer); byte[] bytes = outputStream.toByteArray(); A newMessage = schema.newMessage(); ProtostuffIOUtil.mergeFrom(bytes, newMessage, schema); Assert.assertEquals(source, newMessage); }
@Test public void testWriteNumericEnum() throws Exception { RuntimeSchema<A> schema = RuntimeSchema.createFrom(A.class); A a = new A(TaggedEnum.TEN); Output output = Mockito.mock(Output.class); schema.writeTo(output, a); Mockito.verify(output).writeEnum(1, 10, false); Mockito.verifyNoMoreInteractions(output); }
static <T> void verify(RuntimeSchema<T> schema, int number, String name, int offset) { assertEquals(schema.getFields().get(offset).name, name); assertEquals(schema.getFields().get(offset).number, number); assertEquals(name, schema.getFieldName(number)); assertEquals(number, schema.getFieldNumber(name)); }
@Override public final void writeTo(Output output, T message) throws IOException { for (Field<T> f : getFields()) f.writeTo(output, message); }
final Map<String, java.lang.reflect.Field> fieldMap = findInstanceFields(typeClass); final ArrayList<Field<T>> fields = new ArrayList<Field<T>>( fieldMap.size()); return new RuntimeSchema<T>(typeClass, fields, RuntimeEnv.newInstantiator(typeClass));
return new RuntimeSchema<T>(typeClass, fields, RuntimeEnv.newInstantiator(typeClass));
@Test public void testMuchExcludedEntity() throws Exception { RuntimeSchema<MuchExcludedEntity> schema = (RuntimeSchema<MuchExcludedEntity>) RuntimeSchema .getSchema(MuchExcludedEntity.class); assertTrue(schema.getFieldCount() == 1); assertTrue(schema.getFieldNumber("id") == 0); assertNull(schema.getFieldByName("id")); assertTrue(schema.getFieldNumber("name") == 0); assertNull(schema.getFieldByName("name")); assertEquals(schema.getFields().get(0).name, "alias"); assertEquals(schema.getFields().get(0).number, 1); assertTrue(schema.getFieldNumber("timestamp") == 0); assertNull(schema.getFieldByName("timestamp")); }
public void testPolymorphic() throws Exception { Schema<Zoo> schema = RuntimeSchema.getSchema(Zoo.class); Pipe.Schema<Zoo> pipeSchema = ((RuntimeSchema<Zoo>) schema).getPipeSchema(); Zoo zoo = PolymorphicSerializationTest.filledZoo(); // numeric only protobufRoundTrip(zoo, schema, pipeSchema, true); protostuffRoundTrip(zoo, schema, pipeSchema, true); }
/** * Simple serialization/deserialization test * * @throws Exception */ @Test public void testSerializeDeserialize() throws Exception { RuntimeSchema<A6> schema = RuntimeSchema.createFrom(A6.class); A6 source = new A6(42); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); LinkedBuffer buffer = LinkedBuffer.allocate(); ProtostuffIOUtil.writeTo(outputStream, source, schema, buffer); byte[] bytes = outputStream.toByteArray(); A6 newMessage = schema.newMessage(); ProtostuffIOUtil.mergeFrom(bytes, newMessage, schema); Assert.assertEquals(source, newMessage); }