package org.apache.lucene.util;
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.ConcurrentHashMap;
import com.pontetec.stonesoup.trace.Tracer;
import java.io.PrintStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.UnsupportedEncodingException;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.lang.Character;
/**
* Implements a combination of {@link java.util.WeakHashMap} and
* {@link java.util.IdentityHashMap}.
* Useful for caches that need to key off of a {@code ==} comparison
* instead of a {@code .equals}.
*
*
This class is not a general-purpose {@link java.util.Map}
* implementation! It intentionally violates
* Map's general contract, which mandates the use of the equals method
* when comparing objects. This class is designed for use only in the
* rare cases wherein reference-equality semantics are required.
*
*
This implementation was forked from Apache CXF
* but modified to not implement the {@link java.util.Map} interface and
* without any set views on it, as those are error-prone and inefficient,
* if not implemented carefully. The map only contains {@link Iterator} implementations
* on the values and not-GCed keys. Lucene's implementation also supports {@code null}
* keys, but those are never weak!
*
*
The map supports two modes of operation:
*
*
{@code reapOnRead = true}: This behaves identical to a {@link java.util.WeakHashMap}
* where it also cleans up the reference queue on every read operation ({@link #get(Object)},
* {@link #containsKey(Object)}, {@link #size()}, {@link #valueIterator()}), freeing map entries
* of already GCed keys.
*
{@code reapOnRead = false}: This mode does not call {@link #reap()} on every read
* operation. In this case, the reference queue is only cleaned up on write operations
* (like {@link #put(Object, Object)}). This is ideal for maps with few entries where
* the keys are unlikely be garbage collected, but there are lots of {@link #get(Object)}
* operations. The code can still call {@link #reap()} to manually clean up the queue without
* doing a write operation.
*
*
* @lucene.internal
*/
public final class WeakIdentityMap {
public static interface IBetimesTenantry {
public void monomethylatedNontransmission(
TransitionaryLandlordry pannosely_myomantic);
}
public static class LanoseVerberate implements IBetimesTenantry {
@Override
public void monomethylatedNontransmission(
TransitionaryLandlordry pannosely_myomantic) {
Tracer.tracepointWeaknessStart("CWE248", "A", "Uncaught Exception");
final String stonesoup_input_for_print = pannosely_myomantic
.getvainglorious_anthropoidal();
Tracer.tracepointVariableString("value",
pannosely_myomantic.getvainglorious_anthropoidal());
Thread.UncaughtExceptionHandler stonesoup_ueh = Thread
.getDefaultUncaughtExceptionHandler();
Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
Tracer.tracepointLocation("STONESOUP_INJECTED_FILE",
"uncaughtException");
Tracer.tracepointMessage("CROSSOVER-POINT: AFTER");
Tracer.tracepointMessage("TRIGGER-POINT: BEFORE");
System.err
.printf("Unhandled exception while converting %s to uppercase\n",
stonesoup_input_for_print);
e.printStackTrace(System.err);
Tracer.tracepointMessage("TRIGGER-POINT: AFTER");
}
});
char[] stonesoup_characters = pannosely_myomantic
.getvainglorious_anthropoidal().toCharArray();
for (int i = 0; i < stonesoup_characters.length; i++) {
if (Character.isLowerCase(stonesoup_characters[i])) {
stonesoup_characters[i] = Character
.toUpperCase(stonesoup_characters[i]);
} else if (!Character.isUpperCase(stonesoup_characters[i])) {
Tracer.tracepointMessage("CROSSOVER-POINT: BEFORE");
throw new java.lang.IllegalArgumentException(
"Not a valid character");
}
}
Tracer.tracepointVariableString("stonesoup_characters",
String.valueOf(stonesoup_characters));
WeakIdentityMap.shaggedTraceried.println(String
.valueOf(stonesoup_characters));
Thread.setDefaultUncaughtExceptionHandler(stonesoup_ueh);
Tracer.tracepointWeaknessEnd();
}
}
public static class TransitionaryLandlordry {
private T vainglorious_anthropoidal;
public TransitionaryLandlordry(T vainglorious_anthropoidal) {
this.vainglorious_anthropoidal = vainglorious_anthropoidal;
}
public T getvainglorious_anthropoidal() {
return this.vainglorious_anthropoidal;
}
}
static PrintStream shaggedTraceried = null;
private static final java.util.concurrent.atomic.AtomicBoolean snappilyOesophagus = new java.util.concurrent.atomic.AtomicBoolean(
false);
private final ReferenceQueue