返回物流实体 用于其他处理

@param orderNo 物流单号
@param type    物流公司
@return
509259
public static ExpResultInfoVo getExpInfo(String orderNo, String type) {
        QueryHeard queryHeard = new QueryHeard(orderNo, type).invoke();
        String host = queryHeard.getHost();
        String path = queryHeard.getPath();
        Map<String, String> headers = queryHeard.getHeaders();
        Map<String, String> queries = queryHeard.getQueries();

        try {
            return getExpResultInfoDto(host, path, headers, queries);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
348210
protected IndexType getIndexType(String type)
    {
        type = type.toLowerCase();
        if ("keys".equals(type))
            return IndexType.KEYS;
        else if("custom".equals(type))
            return IndexType.CUSTOM;
        else if("composites".equals(type))
            return IndexType.COMPOSITES;
        else
            return null;
    }
1053658
protected final <T> Optional<T> defaultGetFirstService(Class<T> type) {
        final Iterator<T> services = getServices(type);
        return services.hasNext()
                ? Optional.of(services.next())
                : Optional.empty();
    }
663989
private static int order(Method method) {
        final Order order = findFirst(method, Order.class).orElse(null);
        return order != null ? order.value() : 0;
    }
691304
public OrderingType<WebFragmentType<T>> getOrCreateOrdering()
   {
      List<Node> nodeList = childNode.get("ordering");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new OrderingTypeImpl<WebFragmentType<T>>(this, "ordering", childNode, nodeList.get(0));
      }
      return createOrdering();
   }
696923
public static <S extends Storable> OrderingList<S> get(Class<S> type, String property) {
        OrderingList<S> list = emptyList();
        if (property != null) {
            list = list.concat(type, property);
        }
        return list;
    }
486552
public <K, T extends Persistable<K>> CastorDao<K, T> getDao(
                    final Class<T> type
                    )
    {
        if (type == null) {
            throw new IllegalArgumentException( "null type" );
        }

        @SuppressWarnings( "unchecked" )
        CastorDao<K, T>  dao = (CastorDao<K, T>)_daoMapping.get( type );

        if (dao == null) {
            dao = _createDao( type );
            _daoMapping.put( type, dao );
        }

        return dao;
    }
914739
public WexOrderInfoResult getBTCEOrderInfo(Long orderId) throws IOException {

    WexOrderInfoReturn btceOrderInfo =
        btce.OrderInfo(apiKey, signatureCreator, exchange.getNonceFactory(), orderId);

    checkResult(btceOrderInfo);

    return btceOrderInfo.getReturnValue().values().iterator().next();
  }
1143575
public function setOrder($order_field, $order_type)
    {
        $this->orderField = $order_field;
        $this->orderType = $order_type;
        $this->queryBuilder->orderBy($order_field, $order_type);

        return $this;
    }
765110
@Override
	public AppEngineGetList<E> sort(Order<?, ?>... orders) {
		if (orders == null) {
			throw new IllegalArgumentException("'orders' must not be [" + orders + "]");
		}
		
		this.orders = Arrays.asList(orders);
		return this;
	}
291310
public JSType createOptionalNullableType(JSType type) {
    return createUnionType(type, getNativeType(JSTypeNative.VOID_TYPE),
        getNativeType(JSTypeNative.NULL_TYPE));
  }
99150
private static int getOrdinal(final HLLType type) {
        for(int i=0; i<TYPE_ORDINALS.length; i++) {
            if(TYPE_ORDINALS[i].equals(type)) return i;
        }
        throw new RuntimeException("Unknown HLL type " + type);
    }
1150805
public <C> C mapTo(Class<C> type) {
    DataFormatMapper mapper = dataFormat.getMapper();
    return mapper.mapInternalToJava(jsonNode, type);
  }
170072
public function queryRefund($orderNo, $type = self::OUT_TRADE_NO)
    {
        $params = [
            $type => $orderNo,
        ];

        return $this->request(self::API_QUERY_REFUND, $params);
    }
1086627
private <T extends Index> List<T> listIndexType(String type, Class<T> modelType) {
        List<T> indexesOfType = new ArrayList<T>();
        Gson g = new Gson();
        for (JsonElement index : indexes) {
            if (index.isJsonObject()) {
                JsonObject indexDefinition = index.getAsJsonObject();
                JsonElement indexType = indexDefinition.get("type");
                if (indexType != null && indexType.isJsonPrimitive()) {
                    JsonPrimitive indexTypePrimitive = indexType.getAsJsonPrimitive();
                    if (type == null || (indexTypePrimitive.isString() && indexTypePrimitive
                            .getAsString().equals(type))) {
                        indexesOfType.add(g.fromJson(indexDefinition, modelType));
                    }
                }
            }
        }
        return indexesOfType;
    }
149210
function orderby (args, order) {
    if (this.typecheck) t.typecheck('orderby', [args, order]);
    
    var o = (order&&'string'===typeof order) ? order : '';
    var result = [];

    if ('string'===typeof args) {
        result = o ? [args+' '+o] : [args];
    }
    else if (args instanceof Array) {
        for (var i=0; i < args.length; i++) {
            if ('string'===typeof args[i]) {
                o ? result.push(args[i]+' '+o) : result.push(args[i]);
            }
            else if ('object'===typeof args[i]) {
                var key = Object.keys(args[i])[0];
                result.push(key+' '+args[i][key]);
            }
        }
    }
    else if (args instanceof Object) {
        var key = Object.keys(args)[0];
        result = [key+' '+args[key]];
    }

    return 'order by '+result.join();
}
980671
@NonNull
    @Override
    public OrderBy orderBy(@NonNull Ordering... orderings) {
        if (orderings == null) {
            throw new IllegalArgumentException("orderings is null.");
        }
        return new OrderBy(this, Arrays.asList(orderings));
    }