Java Type.ARRAY屬性代碼示例

private static Type getUsedTypeFromUnion(Object avroObjField) {
    if (GenericRecord.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.RECORD;
    } else if (Number.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.LONG;
    } else if (Boolean.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.BOOLEAN;
    } else if (String.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.STRING;
    } else if (byte[].class.isAssignableFrom(avroObjField.getClass()) || ByteBuffer.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.BYTES;
    } else if (Map.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.MAP;
    } else if (List.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.ARRAY;
    } else if (Enum.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.ENUM;
    } else {
        LOGGER.error("Used type of union is unknown.");
        return null;
    }
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> Serializer<T> getSerializer(Type type, Type elementType) {
  Serializer serializer = null;
  if (type == null) {
    if (elementType == null) {
      serializer = null;
    } else {
      serializer = getSerializer(elementType);
    }
  } else {
    if (elementType == null) {
      serializer = getSerializer(type);
    }
  }

  if (type == Type.ARRAY) {
    serializer = ListSerializer.get(elementType);
  } else if (type == Type.MAP) {
    serializer = MapSerializer.get(elementType);
  } else {
    serializer = null;
  }
  return serializer;
}
 

public static Type getType(Class<?> clazz) {
  if (clazz.equals(Utf8.class)) {
    return Type.STRING;
  } else if (clazz.equals(Boolean.class) || clazz.equals(boolean.class)) {
    return Type.BOOLEAN;
  } else if (clazz.equals(ByteBuffer.class)) {
    return Type.BYTES;
  } else if (clazz.equals(Double.class) || clazz.equals(double.class)) {
    return Type.DOUBLE;
  } else if (clazz.equals(Float.class) || clazz.equals(float.class)) {
    return Type.FLOAT;
  } else if (clazz.equals(Integer.class) || clazz.equals(int.class)) {
    return Type.INT;
  } else if (clazz.equals(Long.class) || clazz.equals(long.class)) {
    return Type.LONG;
  } else if (clazz.isAssignableFrom(List.class)) {
    return Type.ARRAY;
  } else if (clazz.isAssignableFrom(Map.class)) {
    return Type.MAP;
  } else if (clazz.equals(Persistent.class)) {
    return Type.RECORD;
  } else if (clazz.getSuperclass().equals(SpecificFixed.class)) {
    return Type.FIXED;
  } else {
    return null;
  }
}
 

public static Class<?> getClass(Type type) {
  if (type == Type.STRING) {
    return Utf8.class;
  } else if (type == Type.BOOLEAN) {
    return Boolean.class;
  } else if (type == Type.BYTES) {
    return ByteBuffer.class;
  } else if (type == Type.DOUBLE) {
    return Double.class;
  } else if (type == Type.FLOAT) {
    return Float.class;
  } else if (type == Type.INT) {
    return Integer.class;
  } else if (type == Type.LONG) {
    return Long.class;
  } else if (type == Type.ARRAY) {
    return List.class;
  } else if (type == Type.MAP) {
    return Map.class;
  } else if (type == Type.RECORD) {
    return Persistent.class;
  } else if (type == Type.FIXED) {
    // return SpecificFixed.class;
    return null;
  } else {
    return null;
  }
}
 

protected static String typeFor(Schema sc, boolean isNullable) {
	
	if (sc.getType() == Type.ARRAY) {
		return sc.getElementType().getName().toUpperCase();
	}

	return sc.getType().name() + (isNullable ? NullableTypeSuffix : "");
}
 

private String labelFor(Schema sc) {
	
	Type typ = (sc.getType() == Type.ARRAY) ?
			sc.getElementType().getType() : 
			sc.getType();
	
	String typeText = formatType(typ.getName());
	String name = showFullNames ? sc.getFullName() : sc.getName();
	
	boolean isNullable = sc.getType() == Type.UNION && isNullableSingleType(sc.getTypes());
	
	return isNullable ?
		"<i>" + name + "</i>  " + typeText :
		name + "  " + typeText;
}
 

private void render(Schema sc, String parent, boolean isNullable) {

		String childId = newIdFor(parent, sc.getName());
		
		startNewLine();
		appendIds(childId, parent);
		append("type", typeFor(sc, isNullable), true);
		append("text", labelFor(sc), false);
		appendDoc(sc.getDoc());
		endLine();
		
		if (showConstraints) showConstraints(sc, childId);
		if (showMetrics) showMetrics(sc, childId);
		
		incrementDepth();
		
		if (sc.getType() == Type.RECORD) {
			for (Field fld : sc.getFields()) { 
				render(fld, childId); 
				}
			}

		if (sc.getType() == Type.ARRAY) {
			render(sc.getElementType(), childId, false);
			}
		
		if (sc.getType() == Type.UNION) {
			System.out.println("####!!!!!####");
			}
		
		decrementDepth();
	}
 

public void validate(Schema schema) {
    if (schema.getType() != Type.ARRAY)
        throw new IllegalArgumentException("Must be type " + Type.ARRAY);
    fieldCodec.validate(schema.getElementType());
}
 

public static Schema getElementSchema(GenericArray<?> array) {
  Schema schema = array.getSchema();
  return (schema.getType() == Type.ARRAY) ? schema.getElementType() : schema;
}