检测数组类型是否在过滤列表
@param type 类名称
@return 是否在过滤列表
194703
public static boolean arrayFilter(String type) {

        int lastIndex = type.lastIndexOf(ARRAY_PREFIX);
        if (lastIndex == -1) {
            return false;
        }

        String arrayType = type.substring(lastIndex + 1);

        return nameFilter(arrayType);
    }
767484
public <T> T getBodyJson(java.lang.reflect.Type type) {
        String str = array.toString(StandardCharsets.UTF_8);
        if (str == null || str.isEmpty()) return null;
        return context.getJsonConvert().convertFrom(type, str);
    }
683425
public <R> R getData(TypeToken<R> type) {
        return GSON.fromJson(data, type.getType());
    }
1320379
public EsRequest mappings( String type ) {
        EsRequest mappings = new EsRequest();
            EsRequest mappingsValue = new EsRequest();
                EsRequest mtype = new EsRequest();
                    EsRequest properties = new EsRequest();       
                    for (EsIndexColumn col : columns()) {
                        properties.put(col.getName(), fieldMapping(col.getType()));
                        properties.put(col.getLowerCaseFieldName(), fieldMapping(PropertyType.STRING));
                        properties.put(col.getUpperCaseFieldName(), fieldMapping(PropertyType.STRING));
                        properties.put(col.getLengthFieldName(), fieldMapping(PropertyType.LONG));
                    }        
                mtype.put("properties", properties);
            mappingsValue.put(type, mtype);
        mappings.put("mappings", mappingsValue);
        
        return mappings;
    }
51952
public static Converter converterFor( Class type )
    {
        if (!converters.containsKey( type ))
            throw new IllegalArgumentException( "Don't know type: " + type );

        return converters.get( type );
    }
310630
private String getNameForType( Class<?> type )
    {
        if ( _typeToStringMap.containsKey( type ) )
        {
            return _typeToStringMap.get( type );
        }

        for ( Entry<String, Class<?>> entry : _typeMappings.entrySet() )
        {
            if ( entry.getValue().isAssignableFrom( type ) )
            {
                return entry.getKey();
            }
        }
        return null;
    }
1255859
public String getString(Integer type)
   {
      String result = null;

      byte[] item = m_map.get(type);
      if (item != null)
      {
         result = m_data.getString(getOffset(item));
      }

      return (result);
   }
611839
public <R> R getData(Class<R> type) {
        return GSON.fromJson(data, type);
    }
293726
public static String getValidType(String type)
    {
        return (validationClassMapper.get(type) == null) ? "binary" : validationClassMapper.get(type);
    }
1038767
public Type resolveType(Type type) {
        if (type instanceof Class) {
            Type resolvedType = types.get(type);
            if (resolvedType != null) {
                return resolvedType;
            }
        }
        return resolver.resolveType(type);
    }
1188892
static String actualTypeParametersString(TypeElement type) {
    List<? extends TypeParameterElement> typeParameters = type.getTypeParameters();
    if (typeParameters.isEmpty()) {
      return "";
    } else {
      return typeParameters
          .stream()
          .map(e -> e.getSimpleName().toString())
          .collect(joining(", ", "<", ">"));
    }
  }
733912
public Set<String> getKeys(Class<?> type) {
        return data.entrySet().stream().filter(val -> type.isAssignableFrom(val.getValue()
                .getClass())).map(Map.Entry::getKey).collect(Collectors
                .toSet());
    }
552287
public List<Address> getAddressesOfType(Type type) {
        List<Address> answer = new ArrayList<>(addresses.size());
        for (Address address : addresses) {
            if (address.getType().equals(type)) {
                answer.add(address);
            }
        }

        return answer;
    }
691707
public static Type resolveRefType(Type type) {
        if (type == null)
            return null;

        if (type instanceof RefType)
            return resolveRefType(((RefType) type).getRefType());
        else
            return type;
    }
664123
public static String nameFromValue(int type) {
        switch (type) {
            case SIMPLE_REFERENCE:
                return TYPENAME_SIMPLE_REFERENCE;
            default:
                return javax.jcr.PropertyType.nameFromValue(type);
        }
    }
1334381
public <T> List<T> getInstances(Class<T> type) {
		return getInstances(Key.get(type));
	}
652594
public <R> R getData(TypeToken<R> dataType) {
        return GSON.fromJson(data, dataType.getType());
    }