docs: public static List<FieldInfo> processDefaultValue(List<Field> fields, boolean ignoreNoAnnotation,
              boolean isZipZap) {
          if (fields == null) {
              return null;
          }
  
          List<FieldInfo> ret = new ArrayList<FieldInfo>(fields.size());
  
          int maxOrder = 0;
          List<FieldInfo> unorderFields = new ArrayList<FieldInfo>(fields.size());
          Set<Integer> orders = new HashSet<Integer>();
          for (Field field : fields) {
              Ignore ignore = field.getAnnotation(Ignore.class);
              if (ignore != null) {
                  if (LOGGER.isDebugEnabled()) {
                      LOGGER.debug("Field name '{}' marked @Ignore annotation will be ignored.", field.getName());
                  }
                  continue;
              }
  
              Protobuf protobuf = field.getAnnotation(Protobuf.class);
              if (protobuf == null && !ignoreNoAnnotation) {
                  throw new RuntimeException("Field '" + field.getName() + "' has no @Protobuf annotation");
              }
  
              // check field is support for protocol buffer
              // any array except byte array is not support
              String simpleName = field.getType().getName();
              if (simpleName.startsWith("[")) {
                  if ((!simpleName.equals(byte[].class.getName())) && (!simpleName.equals(Byte[].class.getName()))) {
                      throw new RuntimeException("Array type of field '" + field.getName() + "' on class '"
                              + field.getDeclaringClass().getName() + "' is not support,  please use List instead.");
                  }
              }
  
              FieldInfo fieldInfo = new FieldInfo(field);
              FieldType annFieldType = FieldType.DEFAULT;
              int order = -1;
              if (protobuf != null) {
                  fieldInfo.setRequired(protobuf.required());
                  fieldInfo.setDescription(protobuf.description());
                  annFieldType = protobuf.fieldType();
                  order = protobuf.order();
              } else {
                  fieldInfo.setRequired(false);
              }
  
              // process type
              if (annFieldType == FieldType.DEFAULT) {
  
                  Class fieldTypeClass = field.getType();
  
                  // if list
                  boolean isList = fieldInfo.isList();
                  if (isList) {
                      fieldTypeClass = fieldInfo.getGenericKeyType();
                  }
  
                  FieldType fieldType = TYPE_MAPPING.get(fieldTypeClass);
                  if (fieldType == null) {
                      // check if type is enum
                      if (Enum.class.isAssignableFrom(fieldTypeClass)) {
                          fieldType = FieldType.ENUM;
                      } else if (fieldInfo.isMap()) {
                          fieldType = FieldType.MAP;
                      } else {
                          fieldType = FieldType.OBJECT;
                      }
                  }
                  
                  // check if enable zagzip
                  if (isZipZap) {
                      if (fieldType == FieldType.INT32) {
                          fieldType = FieldType.SINT32; // to convert to sint32 to enable zagzip
                      } else if (fieldType == FieldType.INT64) {
                          fieldType = FieldType.SINT64; // to convert to sint64 to enable zagzip
                      }
                  }
                  
                  
                  
                  fieldInfo.setFieldType(fieldType);
              } else {
                  fieldInfo.setFieldType(annFieldType);
              }
  
              if (order > 0) {
                  if (orders.contains(order)) {
                      throw new RuntimeException(
                              "order id '" + order + "' from field name '" + field.getName() + "'  is duplicate");
                  }
                  orders.add(order);
                  fieldInfo.setOrder(order);
                  if (order > maxOrder) {
                      maxOrder = order;
                  }
              } else {
                  unorderFields.add(fieldInfo);
              }
  
              if (fieldInfo.isList() && (fieldInfo.getFieldType().isPrimitive() || fieldInfo.getFieldType().isEnum())) {
                  Packed packed = field.getAnnotation(Packed.class);
                  if (packed == null) {
                      fieldInfo.setPacked(true);
                  } else {
                      fieldInfo.setPacked(packed.value());
                  }
              }
  
              ret.add(fieldInfo);
          }
  
          if (unorderFields.isEmpty()) {
              return ret;
          }
  
          for (FieldInfo fieldInfo : unorderFields) {
              maxOrder++;
              fieldInfo.setOrder(maxOrder);
  
              if (LOGGER.isDebugEnabled()) {
                  LOGGER.debug(
                          "Field '{}' from {} with @Protobuf annotation but not set order or order is 0,"
                                  + " It will set order value to {}",
                          fieldInfo.getField().getName(), fieldInfo.getField().getDeclaringClass().getName(), maxOrder);
              }
          }
  
          return ret;
      }