}
	if len(c.Encoded) == 0 || c.Type.Trailing() {
		return c.Type.Is(ChecksumNone) || c.Type.Trailing()
	}
	raw := c.Raw
	return c.Type.RawByteLen() == len(raw)
}

// Matches returns whether given content matches c.
func (c Checksum) Matches(content []byte, parts int) error {
	if len(c.Encoded) == 0 {
		return nil
	}
	hasher := c.Type.Hasher()
	_, err := hasher.Write(content)
	if err != nil {
		return err
	}

	case <-ctx.Done():
		return ctx.Err()
	}
}

func (w *Watcher) Close() {
	_ = w.watcher.Close()
}

// Creates a file watcher that watches for any changes to the directory
func CreateFileWatcher(paths ...string) (*Watcher, error) {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		return nil, fmt.Errorf("watcher create: %v", err)
	}

	fileModified, errChan := make(chan struct{}), make(chan error)

        if (StringUtil.isBlank(urlKey)) {
            return null;
        }

        for (final Map.Entry<Pattern, CrawlerClient> entry : clientMap.entrySet()) {
            final Matcher matcher = entry.getKey().matcher(urlKey);
            if (matcher.matches()) {
                return entry.getValue();
            }
        }
        return null;
    }

    public void setInitParameterMap(final Map<String, Object> params) {

  private val typeHint: Boolean = false,
) : DerAdapter<T> {
  init {
    require(tagClass >= 0)
    require(tag >= 0)
  }

  override fun matches(header: DerHeader): Boolean = header.tagClass == tagClass && header.tag == tag

  override fun fromDer(reader: DerReader): T {
    val peekedHeader = reader.peekHeader()

            throw new RobotsTxtException("Failed to parse robots.txt.", e);
        }
    }

    protected String getValue(final Pattern pattern, final String line) {
        final Matcher m = pattern.matcher(line);
        if (m.matches() && m.groupCount() > 0) {
            return m.group(1);
        }
        return null;
    }

    protected String stripComment(final String line) {

WIP ML Build Docker container for ML repositories (Tensorflow, JAX and XLA).

This container branches off from
/tensorflow/tools/tf_sig_build_dockerfiles/. However, since
hermetic CUDA and hermetic Python is now available for Tensorflow, a lot of the
requirements installed on the original container can be removed to reduce the
footprint of the container and make it more reusable across different ML

 * limitations under the License.
 */
package okhttp3.internal.ws

import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.isEqualTo
import assertk.assertions.matches
import java.io.EOFException
import java.io.IOException
import java.net.ProtocolException
import java.util.Random
import kotlin.test.assertFailsWith
import okhttp3.internal.format
import okio.Buffer

#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
name: "CodeQL"

on:
  push:
    branches:
    - master
    - "*.x"
  pull_request:
    branches:
    - master
    - "*.x"
  schedule:
    - cron: '0 0 * * 4'

jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest

    strategy:

        // TODO support other type
        return "</doc>";
    }

    protected String trimSpace(final String value) {
        if (trimSpaceEnabled) {
            final Matcher matcher = SPACE_PATTERN.matcher(value);
            return matcher.replaceAll(" ").trim();
        }
        return value;
    }

    public void addAttribute(final String name, final Object value) {
        attributeMap.put(name, value);

org/apache/ivy/plugins/matcher/NoMatcher.class package org.apache.ivy.plugins.matcher; public final synchronized class NoMatcher implements Matcher { public static final Matcher INSTANCE; public void NoMatcher(); public final boolean matches(String); static void <clinit>(); } org/apache/ivy/plugins/matcher/Matcher.class package org.apache.ivy.plugins.matcher; public abstract interface Matcher { public abstract boolean matches(String); } org/apache/ivy/plugins/matcher/AbstractPatternMatch.class package org.a...