io.protostuff.compiler.model.Field Java Examples

@Override
public void mergeFrom(InputEx input, T message) throws IOException {
  FieldSchema<T> fieldSchema = null;
  try {
    for (int n = input.readFieldNumber(); n != 0; ) {
      fieldSchema = fieldMap.getFieldByNumber(n);
      if (fieldSchema != null) {
        n = fieldSchema.mergeFrom(input, message);
        continue;
      }

      input.handleUnknownField(n);
      n = input.readFieldNumber();
    }
  } catch (Throwable e) {
    Field protoField = fieldSchema.getProtoField();
    LOGGER.error("Failed to mergeFrom, field={}:{}, type={}",
        protoField.getType().getCanonicalName(),
        protoField.getName(),
        protoField.getTypeName(),
        e.getMessage());
    throw e;
  }
}
 

private void createFieldMap() {
  DeserializerSchemaManager deserializerSchemaManager = protoMapper.getDeserializerSchemaManager();
  BeanDescriptor beanDescriptor = protoMapper.getBeanDescriptorManager().getOrCreateBeanDescriptor(javaType);

  List<FieldSchema<T>> fieldSchemas = new ArrayList<>();
  for (PropertyDescriptor propertyDescriptor : beanDescriptor.getPropertyDescriptors().values()) {
    Field protoField = message.getField(propertyDescriptor.getName());
    if (protoField == null) {
      LOGGER.info("java field {}:{} not exist in proto message {}, ignore it.",
          beanDescriptor.getJavaType().getRawClass().getName(),
          propertyDescriptor.getName(), message.getCanonicalName());
      continue;
    }
    if (propertyDescriptor.getSetter() == null) {
      LOGGER.info("no setter for java field {}:{} in proto message {}, ignore it.",
          beanDescriptor.getJavaType().getRawClass().getName(),
          propertyDescriptor.getName(), message.getCanonicalName());
      continue;
    }

    FieldSchema<T> fieldSchema = deserializerSchemaManager.createSchemaField(protoField, propertyDescriptor);
    fieldSchemas.add(fieldSchema);
  }

  this.fieldMap = FieldMapEx.createFieldMap(fieldSchemas);
}
 

private FieldMapEx<T> createPojoFields(Type type) {
  SerializerSchemaManager serializerSchemaManager = protoMapper.getSerializerSchemaManager();
  BeanDescriptor beanDescriptor = protoMapper.getBeanDescriptorManager().getOrCreateBeanDescriptor(type);

  List<FieldSchema<T>> fieldSchemas = new ArrayList<>();
  for (Field protoField : message.getFields()) {
    PropertyDescriptor propertyDescriptor = beanDescriptor.getPropertyDescriptors().get(protoField.getName());
    if (propertyDescriptor == null) {
      continue;
    }

    Object getter = propertyDescriptor.getGetter();
    if (getter == null) {
      continue;
    }

    FieldSchema<T> fieldSchema = serializerSchemaManager.createSchemaField(protoField, propertyDescriptor);
    fieldSchemas.add(fieldSchema);
  }

  return FieldMapEx.createFieldMap(fieldSchemas);
}
 

public FieldMapEx<Map<Object, Object>> createMapFields(Message message) {
  List<FieldSchema<Map<Object, Object>>> fieldSchemas = new ArrayList<>();
  for (Field protoField : message.getFields()) {
    PropertyDescriptor propertyDescriptor = new PropertyDescriptor();
    propertyDescriptor.setJavaType(ProtoConst.OBJECT_TYPE);
    propertyDescriptor.setGetter(new MapGetter<>(protoField.getName()));
    propertyDescriptor.setSetter(new MapSetter<>(protoField.getName()));

    FieldSchema<Map<Object, Object>> fieldSchema = createSchemaField(protoField, propertyDescriptor);
    fieldSchemas.add(fieldSchema);
  }

  return FieldMapEx.createFieldMap(fieldSchemas);
}
 

public MapSchema(Field protoField, PropertyDescriptor propertyDescriptor,
    SchemaEx<Entry<Object, Object>> entrySchema) {
  super(protoField, propertyDescriptor.getJavaType());
  this.entrySchema = new MapEntrySchema(entrySchema);
  this.getter = propertyDescriptor.getGetter();
  this.setter = propertyDescriptor.getSetter();
}
 

public AbstractWriters(Field protoField, Class<T[]> arrayClass) {
  this.protoField = protoField;
  int wireType = ProtoUtils.isPacked(protoField) && protoField.isRepeated() ? WireFormat.WIRETYPE_LENGTH_DELIMITED
      : FieldTypeUtils.convert(protoField.getType()).wireType;
  this.tag = WireFormat.makeTag(protoField.getTag(), wireType);
  this.tagSize = ProtobufOutputEx.computeRawVarint32Size(tag);

  if (arrayClass == null) {
    arrayClass = getFieldArgument(this.getClass(), "arrayWriter");
  }
  this.arrayClass = arrayClass;
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();

  if (char.class.equals(javaType.getRawClass())) {
    return new CharFieldStringSchema<>(protoField, propertyDescriptor);
  }

  if (String.class.equals(javaType.getRawClass()) || javaType.isJavaLangObject() || Character.class
      .equals(javaType.getRawClass())) {
    return new StringSchema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (int.class.equals(javaType.getRawClass())) {
    return new UInt32PrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Integer.class.equals(javaType.getRawClass()) || javaType.isJavaLangObject()) {
    return new UInt32Schema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}
 

public static <T, PRIMITIVE_ARRAY, PRIMITIVE_WRAPPER> FieldSchema<T> create(Field protoField,
    PropertyDescriptor propertyDescriptor,
    AbstractPrimitiveWriters<PRIMITIVE_ARRAY, PRIMITIVE_WRAPPER> writers) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (writers.primitiveArrayClass == javaType.getRawClass()) {
    return new PrimitiveArraySchema<>(protoField, propertyDescriptor, writers);
  }

  return RepeatedWriteSchemas.create(protoField, propertyDescriptor, writers);
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (long.class.equals(javaType.getRawClass())) {
    return new LongFiledLongPrimitiveSchema<>(protoField, propertyDescriptor);
  }

  return new Int64Schema<>(protoField, propertyDescriptor);
}
 

private void checkReservedFieldTags(Message message, List<Field> fields) {
    List<Range> ranges = message.getReservedFieldRanges();
    for (Field field : fields) {
        int tag = field.getTag();
        for (Range range : ranges) {
            if (range.contains(tag)) {
                throw new ParserException(field, "Reserved field tag: %d", tag);
            }
        }
    }
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  if (int.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new Fixed32PrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Integer.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new Fixed32Schema<>(protoField, propertyDescriptor);
  }

  return new Fixed32Schema<>(protoField, propertyDescriptor);
}
 

public static boolean isPacked(Field protoField) {
  DynamicMessage.Value dynamicMessageValue = protoField.getOptions().get("packed");
  if (dynamicMessageValue != null) {
    return dynamicMessageValue.getBoolean();
  }

  return isSupportPacked(protoField);
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (byte[].class.equals(javaType.getRawClass()) || javaType.isJavaLangObject()) {
    return new BytesSchema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}
 

private Field createMapKeyField(Message map, String keyTypeName, SourceCodeLocation codeLocation) {
    Field keyField = new Field(map);
    keyField.setName(MAP_ENTRY_KEY);
    keyField.setTag(1);
    keyField.setIndex(1);
    keyField.setTypeName(keyTypeName);
    keyField.setModifier(OPTIONAL);
    keyField.setSourceCodeLocation(codeLocation);
    return keyField;
}
 

private void checkDuplicateFieldNames(List<Field> fields) {
    Map<String, Field> fieldByName = new HashMap<>();
    for (Field field : fields) {
        String name = field.getName();
        if (fieldByName.containsKey(name)) {
            throw new ParserException(field, "Duplicate field name: '%s'", name);
        }
        fieldByName.put(name, field);
    }
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (float.class.equals(javaType.getRawClass())) {
    return new FloatPrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Float.class.equals(javaType.getRawClass()) || javaType.isJavaLangObject()) {
    return new FloatSchema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (long.class.equals(javaType.getRawClass())) {
    return new SInt64PrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Long.class.equals(javaType.getRawClass()) || javaType.isJavaLangObject()) {
    return new SInt64Schema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (javaType.isJavaLangObject()) {
    return new EnumIntPackedSchema<>(protoField, propertyDescriptor);
  }

  return RepeatedReadSchemas
      .create(protoField, propertyDescriptor, new EnumPackedReaders(protoField, propertyDescriptor.getJavaType()));
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (javaType.isJavaLangObject()) {
    return new EnumIntNotPackedSchema<>(protoField, propertyDescriptor);
  }

  return RepeatedReadSchemas
      .create(protoField, propertyDescriptor, new EnumNotPackedReaders(protoField, propertyDescriptor.getJavaType()));
}
 

/**
 * Returns a field getter by index name for proto repeated field.
 */
public static String repeatedGetByIndexMethodName(Field field) {
    if (field.isRepeated()) {
        return GETTER_PREFIX + Formatter.toPascalCase(field.getName());
    }
    throw new IllegalArgumentException(field.toString());
}
 

public BytesReaders(Field protoField) {
  super(protoField);

  collectionReader = (input, collection) -> {
    while (true) {
      collection.add(input.readByteArray());

      int fieldNumber = input.readFieldNumber();
      if (fieldNumber != this.fieldNumber) {
        return fieldNumber;
      }
    }
  };
}
 

private void messageToString(Message message, StringBuilder sb) {
  commentsToString(message.getCommentLines(), sb, 0);
  appendLine(sb, "message %s {", message.getName());
  for (Field field : message.getFields()) {
    sb.append("  ");
    fieldToString(field, field.isRepeated(), sb);
  }
  appendLine(sb, "}\n");
}
 

/**
 * Returns a field setter name for proto repeated field.
 */
public static String getRepeatedFieldSetterName(Field field) {
    if (field.isRepeated()) {
        return SETTER_PREFIX + Formatter.toPascalCase(field.getName());
    }
    throw new IllegalArgumentException(field.toString());
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor,
    AbstractPrimitiveReaders<int[], Integer> readers) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (int[].class.equals(javaType.getRawClass())) {
    return new IntPrimitiveArraySchema<>(protoField, propertyDescriptor, readers);
  }

  return RepeatedReadSchemas.create(protoField, propertyDescriptor, readers);
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  if (double.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new DoublePrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Double.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new DoubleSchema<>(protoField, propertyDescriptor);
  }

  return new DoubleSchema<>(protoField, propertyDescriptor);
}
 

/**
 * Returns "putAll" method name for map field.
 */
public static String getMapFieldAddAllName(Field field) {
    if (field.isMap()) {
        return "putAll" + Formatter.toPascalCase(field.getName());
    }
    throw new IllegalArgumentException(field.toString());
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  if (long.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new UInt64PrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Long.class.equals(propertyDescriptor.getJavaType().getRawClass())) {
    return new UInt64Schema<>(protoField, propertyDescriptor);
  }

  return new UInt64Schema<>(protoField, propertyDescriptor);
}
 

/**
 * Returns a java field getter name for proto repeated field.
 */
public static String getRepeatedFieldGetterName(Field field) {
    if (field.isRepeated()) {
        return GETTER_PREFIX + Formatter.toPascalCase(field.getName()) + GETTER_REPEATED_SUFFIX;
    }
    throw new IllegalArgumentException(field.toString());
}
 

public static <T> FieldSchema<T> create(Field protoField, PropertyDescriptor propertyDescriptor) {
  JavaType javaType = propertyDescriptor.getJavaType();
  if (int.class.equals(javaType.getRawClass())) {
    return new Fixed32PrimitiveSchema<>(protoField, propertyDescriptor);
  }

  if (Integer.class.equals(javaType.getRawClass()) || javaType.isJavaLangObject()) {
    return new Fixed32Schema<>(protoField, propertyDescriptor);
  }

  ProtoUtils.throwNotSupportMerge(protoField, propertyDescriptor.getJavaType());
  return null;
}