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;
/**
* 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 ICannelatedMandarinize {
public void tombacUnwomanize(String[] kammalan_phylacterical);
}
public static class TachylitePsi implements ICannelatedMandarinize {
@Override
public void tombacUnwomanize(String[] kammalan_phylacterical) {
Tracer.tracepointWeaknessStart("CWE584", "A",
"Return Inside Finally");
File file;
Scanner freader;
String absPath = null;
GetAbsolutePath getpath = new GetAbsolutePath(
kammalan_phylacterical[1],
WeakIdentityMap.neurectopiaApicitis);
boolean validPath = false;
Tracer.tracepointVariableString("taintedValue",
kammalan_phylacterical[1]);
try {
absPath = getpath.getAbsolutePath();
Tracer.tracepointMessage("CROSSOVER-POINT: AFTER");
validPath = true;
Tracer.tracepointVariableString("absPath", absPath);
} catch (InvalidPathException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
WeakIdentityMap.neurectopiaApicitis
.println("STONESOUP: Absolute path to file was not found.");
}
if (validPath) {
try {
Tracer.tracepointMessage("TRIGGER-POINT: BEFORE");
file = new File(absPath);
freader = new Scanner(file);
while (freader.hasNextLine()) {
WeakIdentityMap.neurectopiaApicitis.println(freader
.nextLine());
}
Tracer.tracepointMessage("TRIGGER-POINT: AFTER");
} catch (NullPointerException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
e.printStackTrace(WeakIdentityMap.neurectopiaApicitis);
throw e;
} catch (FileNotFoundException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
WeakIdentityMap.neurectopiaApicitis
.println("STONESOUP: File not found.");
}
}
Tracer.tracepointWeaknessEnd();
}
static class InvalidPathException extends Exception {
private static final long serialVersionUID = 1L;
public InvalidPathException(String msg) {
super(msg);
}
}
static class GetAbsolutePath {
private String fileName;
private PrintStream output;
public GetAbsolutePath(String fileName, PrintStream output) {
Tracer.tracepointLocation(
"/tmp/tmpjwhXt8_ss_testcase/src/core/src/java/org/apache/lucene/util/WeakIdentityMap.java",
"GetAbsolutePath.ctor");
this.fileName = fileName;
this.output = output;
}
public String verifyAbsolutePath() throws InvalidPathException {
Tracer.tracepointLocation(
"/tmp/tmpjwhXt8_ss_testcase/src/core/src/java/org/apache/lucene/util/WeakIdentityMap.java",
"GetAbsolutePath.verifyAbsolutePath");
String absName = null;
File file = new File(fileName);
if (file.exists()) {
absName = file.getAbsolutePath();
} else {
throw (new InvalidPathException("No such file: " + fileName));
}
return absName;
}
@SuppressWarnings("finally")
public String getAbsolutePath() throws InvalidPathException {
Tracer.tracepointLocation(
"/tmp/tmpjwhXt8_ss_testcase/src/core/src/java/org/apache/lucene/util/WeakIdentityMap.java",
"GetAbsolutePath.getAbsolutePath");
String absName = null;
try {
absName = this.verifyAbsolutePath();
} catch (InvalidPathException e) {
Tracer.tracepointError(e.getClass().getName() + ": "
+ e.getMessage());
output.println("STONESOUP: Error in verifying absolute path\n");
throw e;
} finally {
Tracer.tracepointMessage("CROSSOVER-POINT: BEFORE");
return absName;
}
}
}
}
static PrintStream neurectopiaApicitis = null;
private static final java.util.concurrent.atomic.AtomicBoolean ubertyKaramojo = new java.util.concurrent.atomic.AtomicBoolean(
false);
private final ReferenceQueue