}

  override fun select(uri: URI): List<Proxy> {
    // Don't handle 'socket' schemes, which the RI's Socket class may request (for SOCKS).
    return if (uri.scheme == "http" || uri.scheme == "https") proxies else listOf(Proxy.NO_PROXY)
  }

  override fun connectFailed(
    uri: URI,
    sa: SocketAddress,
    ioe: IOException,
  ) {
  }

                            } else {
                                existingDoc.put(Constants.SEARCHER, searcherNames);
                            }
                        }
                    } else {
                        doc.put(scoreField, Float.valueOf(rrfScore));
                        documentsByIdMap.put(id, doc);

				dm.m.Lock()

				// If success, copy array to object
				if isReadLock {
					copy(dm.readLocks, locks)
				} else {
					copy(dm.writeLocks, locks)
				}

				dm.m.Unlock()
				log("lockBlocking %s/%s for %#v: granted\n", id, source, dm.Names)

        this.traceResource = this.session.getConfig().isTraceResourceUsage();
        if (this.traceResource) {
            this.acquires = new LinkedList<>();
            this.releases = new LinkedList<>();
        } else {
            this.acquires = null;
            this.releases = null;
        }
    }

    boolean matches(final String shr, final String servc) {

                        }
                        if (file.isDirectory()) {
                            break;
                        }
                    }
                }
            } else if (!file.mkdirs()) {
                throw new CrawlerSystemException("Could not create " + file.getAbsolutePath());
            }
            targetFile = file;
        }

     */
    public void addCondition(final String key, final String regex) {
        final String value = conditionMap.get(key);
        if (StringUtil.isBlank(value)) {
            conditionMap.put(key, regex);
        } else {
            conditionMap.put(key, value + "|" + regex);
        }
    }

    @Override
    public boolean isTarget(final Map<String, Object> docMap) {

      @SuppressWarnings("unchecked")
      List<T> result = (List<T>) reversed;
      return result;
    } else if (list instanceof ReverseList) {
      return ((ReverseList<T>) list).getForwardList();
    } else if (list instanceof RandomAccess) {
      return new RandomAccessReverseList<>(list);
    } else {
      return new ReverseList<>(list);
    }
  }

            if (!getFlag(NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY)) {
                setLMResponse(getLMResponse(tc, type2, password));
                setNTResponse(getNTResponse(tc, type2, passwordHash));
            } else {
                // NTLM2 Session Response

                final byte[] clientChallenge = new byte[24];
                tc.getConfig().getRandom().nextBytes(clientChallenge);

				if a == b {
					continue
				}
			}
			if !strict && eVer.header.matchesNotStrict(oVer.header) {
				if prefer == nil {
					if eVer.header.sortsBefore(oVer.header) {
						prefer = e
					} else {
						prefer = other
					}
				}
				continue
			}
			if prefer != nil {
				return prefer, false
			}

			if eVer.header.sortsBefore(oVer.header) {
				return e, false
			}

func (orderBy OrderBy) Name() string {
	return "ORDER BY"
}

// Build build where clause
func (orderBy OrderBy) Build(builder Builder) {
	if orderBy.Expression != nil {
		orderBy.Expression.Build(builder)
	} else {
		for idx, column := range orderBy.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column.Column)
			if column.Desc {
				builder.WriteString(" DESC")
			}
		}
	}