下面列出了怎么用java.util.IdentityHashMap的API类实例代码及写法，或者点击链接到github查看源代码。
private static <T> Collection<Object[]> makeMapsMoreTypes(String desc,
T[] keys,
T val) {
Collection<Object[]> cases = new ArrayList<>();
cases.add(createCase("Hashtable with " + desc,
new Hashtable<>(), keys, val));
cases.add(createCase("IdentityHashMap with " + desc,
new IdentityHashMap<>(), keys, val));
cases.add(createCase("TreeMap with " + desc,
new TreeMap<>(), keys, val));
cases.add(createCase("WeakHashMap with " + desc,
new WeakHashMap<>(), keys, val));
cases.add(createCase("ConcurrentHashMap with " + desc,
new ConcurrentHashMap<>(), keys, val));
cases.add(createCase("ConcurrentSkipListMap with " + desc,
new ConcurrentSkipListMap<>(), keys, val));
return cases;
}
public static void main(String[] args) throws Exception {
final IdentityHashMap<String, String> identityHashMap =
new IdentityHashMap<>();
identityHashMap.put("One", "Un");
identityHashMap.put("Two", "Deux");
identityHashMap.put("Three", "Trois");
Iterator<Map.Entry<String, String>> entrySetIterator =
identityHashMap.entrySet().iterator();
Map.Entry<String, String> entry = entrySetIterator.next();
entrySetIterator.remove();
try {
entry.getKey();
throw new RuntimeException("Test FAILED: Entry not invalidated by removal.");
} catch (Exception e) { }
}
@Test
public void testAnotherImplementation() {
ListMap<String, String> stringMap = new ListMap<>(IdentityHashMap.class);
String foo = "foo";
String bar = "bar";
String far = "far";
String rab = "rab";
stringMap.put(foo, bar);
stringMap.put(foo, far);
stringMap.put(bar, rab);
List<String> fooValues = stringMap.get(new String("foo"));
assertEquals(0, fooValues.size());
fooValues = stringMap.get(foo);
assertEquals(2, fooValues.size());
assertEquals("bar", fooValues.get(0));
assertEquals("far", fooValues.get(1));
List<String> barValues = stringMap.get(new String("bar"));
assertEquals(0, barValues.size());
barValues = stringMap.get(bar);
assertEquals(1, barValues.size());
assertEquals("rab", barValues.get(0));
}
public static void main(String[] args) throws Exception {
final IdentityHashMap<String, String> identityHashMap =
new IdentityHashMap<>();
identityHashMap.put("One", "Un");
identityHashMap.put("Two", "Deux");
identityHashMap.put("Three", "Trois");
Set<Map.Entry<String, String>> entrySet = identityHashMap.entrySet();
HashSet<Map.Entry<String, String>> hashSet = new HashSet<>(entrySet);
// NB: These comparisons are valid in this case because none of the
// keys put into 'identityHashMap' above are equal to any other.
if (false == hashSet.equals(entrySet)) {
throw new RuntimeException("Test FAILED: Sets are not equal.");
}
if (hashSet.hashCode() != entrySet.hashCode()) {
throw new RuntimeException("Test FAILED: Set's hashcodes are not equal.");
}
}
private static void traverseSchema(Schema schema, SchemaVisitor visitor, IdentityHashMap<Object, Boolean> visited) {
if (visited.put(schema, Boolean.TRUE) != null) {
return; //been there, done that
}
visitor.visitSchema(schema);
switch (schema.getType()) {
case UNION:
for (Schema unionBranch : schema.getTypes()) {
traverseSchema(unionBranch, visitor, visited);
}
return;
case ARRAY:
traverseSchema(schema.getElementType(), visitor, visited);
return;
case MAP:
traverseSchema(schema.getValueType(), visitor, visited);
return;
case RECORD:
for (Schema.Field field : schema.getFields()) {
visitor.visitField(field);
traverseSchema(field.schema(), visitor, visited);
}
break;
default:
}
}
private Map<BonusObj, Object> getTempBonuses()
{
Map<BonusObj, Object> map = new IdentityHashMap<>();
getFilteredTempBonusList().forEach((bonus, value) -> {
pc.setApplied(bonus, false);
Object source = value.source;
CDOMObject cdomsource = (source instanceof CDOMObject) ? (CDOMObject) source : null;
if (bonus.qualifies(pc, cdomsource))
{
pc.setApplied(bonus, true);
}
if (pc.isApplied(bonus))
{
map.put(bonus, source);
}
});
return map;
}
public static EventDeserializer defaultDeserializer() {
Map<Long, TableMapEventData> tableMapEventByTableId = new HashMap<>();
Map<EventType, EventDataDeserializer> eventDataDeserializers = new IdentityHashMap<>();
eventDataDeserializers.put(EventType.WRITE_ROWS,
new WriteRowsEventDataDeserializer(tableMapEventByTableId));
eventDataDeserializers.put(EventType.UPDATE_ROWS,
new UpdateRowsEventDataDeserializer(tableMapEventByTableId));
eventDataDeserializers.put(EventType.DELETE_ROWS,
new DeleteRowsEventDataDeserializer(tableMapEventByTableId));
eventDataDeserializers.put(EventType.EXT_WRITE_ROWS,
new WriteRowsEventDataDeserializer(tableMapEventByTableId).
setMayContainExtraInformation(true));
eventDataDeserializers.put(EventType.EXT_UPDATE_ROWS,
new UpdateRowsEventDataDeserializer(tableMapEventByTableId).
setMayContainExtraInformation(true));
eventDataDeserializers.put(EventType.EXT_DELETE_ROWS,
new DeleteRowsEventDataDeserializer(tableMapEventByTableId).
setMayContainExtraInformation(true));
eventDataDeserializers.put(EventType.QUERY, new QueryEventDataDeserializer());
eventDataDeserializers.put(EventType.TABLE_MAP, new TableMapEventDataDeserializer());
return new EventDeserializer(new EventHeaderV4Deserializer(), new NullEventDataDeserializer(),
eventDataDeserializers, tableMapEventByTableId);
}
private static IdentityHashMap<SpanNode, Integer> getSpanNodes(SpanTree otherToCopy) {
IdentityHashMap<SpanNode, Integer> map = new IdentityHashMap<SpanNode, Integer>();
int spanNodeCounter = 0;
map.put(otherToCopy.getRoot(), spanNodeCounter++);
Iterator<SpanNode> it = otherToCopy.getRoot().childIteratorRecursive();
while (it.hasNext()) {
map.put(it.next(), spanNodeCounter++);
}
return map;
}
public void testMapChildren() {
new MapTest<>().run(new MapFactory<Object>(new Object()) {
public Map<Object, ValueType> newMap() {
return new IdentityHashMap<>();
}
});
new MapTest<>().run(new MapFactory<Object>(new Object()) {
public Map<Object, ValueType> newMap() {
return new WeakHashMap<>();
}
});
new MapTest<Color>().run(new MapFactory<Color>(Color.RED) {
public Map<Color, ValueType> newMap() {
return new EnumMap<>(Color.class);
}
});
new MapTest<>().run(new MapFactory<Object>(new Object()) {
public Map<Object, ValueType> newMap() {
return new HashMap<>();
}
});
new MapTest<Integer>().run(new MapFactory<Integer>(5) {
public Map<Integer, ValueType> newMap() {
return new TreeMap<>();
}
});
new MapTest<>().run(new MapFactory<Object>(new Object()) {
public Map<Object, ValueType> newMap() {
return new Hashtable<>();
}
});
new MapTest<>().run(new MapFactory<Object>(new Object()) {
public Map<Object, ValueType> newMap() {
return new ConcurrentHashMap<>();
}
});
}
public MergingMediaPeriod(CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory,
MediaPeriod... periods) {
this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory;
this.periods = periods;
childrenPendingPreparation = new ArrayList<>();
compositeSequenceableLoader =
compositeSequenceableLoaderFactory.createCompositeSequenceableLoader();
streamPeriodIndices = new IdentityHashMap<>();
}
/**
* Checks that 4 methods of requiring capacity lead to the same
* internal capacity, unless sized below default capacity.
*/
@Test(dataProvider = "sizes")
public void differentGrowthPatternsResultInSameCapacity(int size)
throws Throwable {
if (size < 21) // 21 is default maxExpectedSize
return;
IdentityHashMap<Object,Object> m;
m = new IdentityHashMap<Object,Object>(size);
int capacity1 = capacity(m);
m = new IdentityHashMap<>();
growUsingPut(m, size);
int capacity2 = capacity(m);
m = new IdentityHashMap<>();
growUsingPutAll(m, size);
int capacity3 = capacity(m);
m = new IdentityHashMap<>();
growUsingRepeatedPutAll(m, size);
int capacity4 = capacity(m);
if (capacity1 != capacity2 ||
capacity2 != capacity3 ||
capacity3 != capacity4)
throw new AssertionError("Capacities not equal: "
+ capacity1 + " "
+ capacity2 + " "
+ capacity3 + " "
+ capacity4);
}
private void putIdentityHashMap(Region<Object, Object> region, List<ExpectedValues> expected) {
String key = "keyIdentityHashMap";
IdentityHashMap<Object,Object> value = new IdentityHashMap<Object,Object>();
value.put("1", "string 1");
value.put("2", "string 2");
region.put(key, value);
expected.add(new ExpectedValues(value, 40, "java.util.IdentityHashMap", -1, getMemoryAddress(region, key), 1, 0, false, true));
}
@Override
public GetBuilder addParams(String key, String val)
{
if (this.params == null)
{
params = new IdentityHashMap<>();
}
params.put(key, val);
return this;
}
@Test
public void createMetrics() {
Map<Object, Object> instances = new IdentityHashMap<>();
instances.put(metrics_listen1_server1, null);
instances.put(metrics_listen1_server2, null);
instances.put(metrics_listen2_server1, null);
instances.put(metrics_listen2_server2, null);
Assert.assertEquals(4, instances.size());
Assert.assertSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen1_server2.getEndpointMetric());
Assert.assertNotSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen2_server1.getEndpointMetric());
Assert.assertSame(metrics_listen2_server1.getEndpointMetric(), metrics_listen2_server2.getEndpointMetric());
}
@Override
public void merge(MergeState mergeState) throws IOException {
Map<DocValuesConsumer, Collection<String>> consumersToField = new IdentityHashMap<>();
// Group each consumer by the fields it handles
for (FieldInfo fi : mergeState.mergeFieldInfos) {
if (fi.getDocValuesType() == DocValuesType.NONE) {
continue;
}
// merge should ignore current format for the fields being merged
DocValuesConsumer consumer = getInstance(fi, true);
Collection<String> fieldsForConsumer = consumersToField.get(consumer);
if (fieldsForConsumer == null) {
fieldsForConsumer = new ArrayList<>();
consumersToField.put(consumer, fieldsForConsumer);
}
fieldsForConsumer.add(fi.name);
}
// Delegate the merge to the appropriate consumer
PerFieldMergeState pfMergeState = new PerFieldMergeState(mergeState);
try {
for (Map.Entry<DocValuesConsumer, Collection<String>> e : consumersToField.entrySet()) {
e.getKey().merge(pfMergeState.apply(e.getValue()));
}
} finally {
pfMergeState.reset();
}
}
private Map<Skill, Double> getConstructingInfo(CharID id)
{
Map<Skill, Double> map = getInfo(id);
if (map == null)
{
map = new IdentityHashMap<>();
setCache(id, map);
}
return map;
}
/**
* Returns the dictionary of the prototype.
* @param proto Prototype of the dictionary.
* @return Dictionary of the prototype.
*/
protected SortedDawg modelOf(final LibLevenshteinProtos.Dawg proto) {
final Map<LibLevenshteinProtos.DawgNode, DawgNode> nodes =
new IdentityHashMap<>();
final DawgNode root = modelOf(proto.getRoot(), nodes);
return new SortedDawg(proto.getSize(), root);
}
/**
* Creates an HLS media period.
*
* @param extractorFactory An {@link HlsExtractorFactory} for {@link Extractor}s for the segments.
* @param playlistTracker A tracker for HLS playlists.
* @param dataSourceFactory An {@link HlsDataSourceFactory} for {@link DataSource}s for segments
* and keys.
* @param mediaTransferListener The transfer listener to inform of any media data transfers. May
* be null if no listener is available.
* @param loadErrorHandlingPolicy A {@link LoadErrorHandlingPolicy}.
* @param eventDispatcher A dispatcher to notify of events.
* @param allocator An {@link Allocator} from which to obtain media buffer allocations.
* @param compositeSequenceableLoaderFactory A factory to create composite {@link
* SequenceableLoader}s for when this media source loads data from multiple streams.
* @param allowChunklessPreparation Whether chunkless preparation is allowed.
* @param useSessionKeys Whether to use #EXT-X-SESSION-KEY tags.
*/
public HlsMediaPeriod(
HlsExtractorFactory extractorFactory,
HlsPlaylistTracker playlistTracker,
HlsDataSourceFactory dataSourceFactory,
@Nullable TransferListener mediaTransferListener,
LoadErrorHandlingPolicy loadErrorHandlingPolicy,
EventDispatcher eventDispatcher,
Allocator allocator,
CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory,
boolean allowChunklessPreparation,
@HlsMetadataType int metadataType,
boolean useSessionKeys) {
this.extractorFactory = extractorFactory;
this.playlistTracker = playlistTracker;
this.dataSourceFactory = dataSourceFactory;
this.mediaTransferListener = mediaTransferListener;
this.loadErrorHandlingPolicy = loadErrorHandlingPolicy;
this.eventDispatcher = eventDispatcher;
this.allocator = allocator;
this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory;
this.allowChunklessPreparation = allowChunklessPreparation;
this.metadataType = metadataType;
this.useSessionKeys = useSessionKeys;
compositeSequenceableLoader =
compositeSequenceableLoaderFactory.createCompositeSequenceableLoader();
streamWrapperIndices = new IdentityHashMap<>();
timestampAdjusterProvider = new TimestampAdjusterProvider();
sampleStreamWrappers = new HlsSampleStreamWrapper[0];
enabledSampleStreamWrappers = new HlsSampleStreamWrapper[0];
manifestUrlIndicesPerWrapper = new int[0][];
eventDispatcher.mediaPeriodCreated();
}
/**
* Creates a TreeLayout for a given tree.
* <p>
* In addition to the tree the {@link NodeExtentProvider} and the
* {@link Configuration} must be given.
*
* @param tree
* @param nodeExtentProvider
* @param configuration
* @param useIdentity
* [default: false] when true, identity ("==") is used instead of
* equality ("equals(...)") when checking nodes. Within a tree
* each node must only exist once (using this check).
*/
public TreeLayout(TreeForTreeLayout<TreeNode> tree,
NodeExtentProvider<TreeNode> nodeExtentProvider,
Configuration<TreeNode> configuration, boolean useIdentity) {
this.tree = tree;
this.nodeExtentProvider = nodeExtentProvider;
this.configuration = configuration;
this.useIdentity = useIdentity;
if (this.useIdentity) {
this.mod = new IdentityHashMap<TreeNode, Double>();
this.thread = new IdentityHashMap<TreeNode, TreeNode>();
this.prelim = new IdentityHashMap<TreeNode, Double>();
this.change = new IdentityHashMap<TreeNode, Double>();
this.shift = new IdentityHashMap<TreeNode, Double>();
this.ancestor = new IdentityHashMap<TreeNode, TreeNode>();
this.number = new IdentityHashMap<TreeNode, Integer>();
this.positions = new IdentityHashMap<TreeNode, Point2D>();
} else {
this.mod = new HashMap<TreeNode, Double>();
this.thread = new HashMap<TreeNode, TreeNode>();
this.prelim = new HashMap<TreeNode, Double>();
this.change = new HashMap<TreeNode, Double>();
this.shift = new HashMap<TreeNode, Double>();
this.ancestor = new HashMap<TreeNode, TreeNode>();
this.number = new HashMap<TreeNode, Integer>();
this.positions = new HashMap<TreeNode, Point2D>();
}
// No need to explicitly set mod, thread and ancestor as their getters
// are taking care of the initial values. This avoids a full tree walk
// through and saves some memory as no entries are added for
// "initial values".
TreeNode r = tree.getRoot();
firstWalk(r, null);
calcSizeOfLevels(r, 0);
secondWalk(r, -getPrelim(r), 0, 0);
}
private void globalPathRegistry_register(String id, ClassPath [] classpaths) {
Map<ClassPath,Void> map = registeredClasspaths.get(id);
if (map == null) {
map = new IdentityHashMap<ClassPath, Void>();
registeredClasspaths.put(id, map);
}
for (ClassPath cp : classpaths) {
map.put(cp,null);
}
GlobalPathRegistry.getDefault().register(id, classpaths);
}
private Map<BonusObj, Object> getAllActiveBonuses()
{
Map<BonusObj, Object> ret = new IdentityHashMap<>();
for (final BonusContainer pobj : pc.getBonusContainerList())
{
// We exclude equipmods here as their bonuses are already counted in
// the equipment they belong to.
if (pobj != null && !(pobj instanceof EquipmentModifier))
{
boolean use = true;
if (pobj instanceof PCClass)
{
// Class bonuses are only included if the level is greater
// than 0
// This is because 0 levels of a class can be added to
// access spell casting etc
use = pc.getLevel(((PCClass) pobj)) > 0;
}
if (use)
{
pobj.activateBonuses(pc);
List<BonusObj> abs = pobj.getActiveBonuses(pc);
for (BonusObj bo : abs)
{
ret.put(bo, pobj);
}
}
}
}
if (pc.getUseTempMods())
{
ret.putAll(getTempBonuses());
}
return ret;
}
/** Simple constructor.
* @param root tree root
* @param tolerance below which points are consider to be identical
*/
public EdgesBuilder(final BSPTree<Sphere2D> root, final double tolerance) {
this.root = root;
this.tolerance = tolerance;
this.edgeToNode = new IdentityHashMap<Edge, BSPTree<Sphere2D>>();
this.nodeToEdgesList = new IdentityHashMap<BSPTree<Sphere2D>, List<Edge>>();
}
static int capacity(IdentityHashMap<?,?> map) {
try {
return ((Object[]) tableField.get(map)).length / 2;
} catch (Throwable t) {
throw new LinkageError("table", t);
}
}
private Map<BonusObj, TempBonusInfo> getFilteredTempBonusList()
{
final Map<BonusObj, TempBonusInfo> ret = new IdentityHashMap<>();
for (Map.Entry<BonusObj, TempBonusInfo> me : tempBonusBySource.entrySet())
{
BonusObj bonus = me.getKey();
TempBonusInfo ti = me.getValue();
if (!tempBonusFilters.contains(BonusDisplay.getBonusDisplayName(ti)))
{
ret.put(bonus, ti);
}
}
return ret;
}
@Override
public PostFormBuilder addHeader(String key, String val)
{
if (this.headers == null)
{
headers = new IdentityHashMap<>();
}
headers.put(key, val);
return this;
}
/**
* Creates an HLS media period.
*
* @param extractorFactory An {@link HlsExtractorFactory} for {@link Extractor}s for the segments.
* @param playlistTracker A tracker for HLS playlists.
* @param dataSourceFactory An {@link HlsDataSourceFactory} for {@link DataSource}s for segments
* and keys.
* @param mediaTransferListener The transfer listener to inform of any media data transfers. May
* be null if no listener is available.
* @param loadErrorHandlingPolicy A {@link LoadErrorHandlingPolicy}.
* @param eventDispatcher A dispatcher to notify of events.
* @param allocator An {@link Allocator} from which to obtain media buffer allocations.
* @param compositeSequenceableLoaderFactory A factory to create composite {@link
* SequenceableLoader}s for when this media source loads data from multiple streams.
* @param allowChunklessPreparation Whether chunkless preparation is allowed.
* @param useSessionKeys Whether to use #EXT-X-SESSION-KEY tags.
*/
public HlsMediaPeriod(
HlsExtractorFactory extractorFactory,
HlsPlaylistTracker playlistTracker,
HlsDataSourceFactory dataSourceFactory,
@Nullable TransferListener mediaTransferListener,
LoadErrorHandlingPolicy loadErrorHandlingPolicy,
EventDispatcher eventDispatcher,
Allocator allocator,
CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory,
boolean allowChunklessPreparation,
@HlsMetadataType int metadataType,
boolean useSessionKeys) {
this.extractorFactory = extractorFactory;
this.playlistTracker = playlistTracker;
this.dataSourceFactory = dataSourceFactory;
this.mediaTransferListener = mediaTransferListener;
this.loadErrorHandlingPolicy = loadErrorHandlingPolicy;
this.eventDispatcher = eventDispatcher;
this.allocator = allocator;
this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory;
this.allowChunklessPreparation = allowChunklessPreparation;
this.metadataType = metadataType;
this.useSessionKeys = useSessionKeys;
compositeSequenceableLoader =
compositeSequenceableLoaderFactory.createCompositeSequenceableLoader();
streamWrapperIndices = new IdentityHashMap<>();
timestampAdjusterProvider = new TimestampAdjusterProvider();
sampleStreamWrappers = new HlsSampleStreamWrapper[0];
enabledSampleStreamWrappers = new HlsSampleStreamWrapper[0];
manifestUrlIndicesPerWrapper = new int[0][];
eventDispatcher.mediaPeriodCreated();
}
@Test
public void putAllTest()
{
final Map<String, Integer> offHeapMap = new OffHeapMap<>(
(Integer str) -> String.valueOf(str).getBytes(UTF_8),
(byte[] bytes) -> Integer.valueOf(new String(bytes, UTF_8)),
IdentityHashMap::new
);
Map<String, Integer> integerMap = MutableMap.of("a1", 123);
offHeapMap.putAll(integerMap);
Assert.assertEquals(offHeapMap, integerMap);
}
/**
* Checks that 4 methods of requiring capacity lead to the same
* internal capacity, unless sized below default capacity.
*/
@Test(dataProvider = "sizes")
public void differentGrowthPatternsResultInSameCapacity(int size)
throws Throwable {
if (size < 21) // 21 is default maxExpectedSize
return;
IdentityHashMap<Object,Object> m;
m = new IdentityHashMap<Object,Object>(size);
int capacity1 = capacity(m);
m = new IdentityHashMap<>();
growUsingPut(m, size);
int capacity2 = capacity(m);
m = new IdentityHashMap<>();
growUsingPutAll(m, size);
int capacity3 = capacity(m);
m = new IdentityHashMap<>();
growUsingRepeatedPutAll(m, size);
int capacity4 = capacity(m);
if (capacity1 != capacity2 ||
capacity2 != capacity3 ||
capacity3 != capacity4)
throw new AssertionError("Capacities not equal: "
+ capacity1 + " "
+ capacity2 + " "
+ capacity3 + " "
+ capacity4);
}
/**
* Returns an annotated formula f such that f.node is equivalent to annotated.node
* with its <tt>simplified</tt> predicates replaced with their corresponding Formulas and the remaining
* predicates replaced with equivalent constraints. The annotated formula f will contain transitive source
* information for each of the subformulas of f.node. Specifically, let t be a subformula of f.node, and
* s be a descdendent of annotated.node from which t was derived. Then, f.source[t] = annotated.source[s]. </p>
* @requires simplified.keySet() in annotated.predicates()[RelationPredicate.NAME]
* @requires no disj p, p': simplified.keySet() | simplified.get(p) = simplified.get(p') // this must hold in order
* to maintain the invariant that each subformula of the returned formula has exactly one source
* @requires for each p in simplified.keySet(), the formulas "p and [[this.bounds]]" and
* "simplified.get(p) and [[this.bounds]]" are equisatisfiable
* @return an annotated formula f such that f.node is equivalent to annotated.node
* with its <tt>simplified</tt> predicates replaced with their corresponding Formulas and the remaining
* predicates replaced with equivalent constraints.
*/
private AnnotatedNode<Formula> inlinePredicates(final AnnotatedNode<Formula> annotated, final Map<RelationPredicate,Formula> simplified) {
final Map<Node,Node> sources = new IdentityHashMap<Node,Node>();
final AbstractReplacer inliner = new AbstractReplacer(annotated.sharedNodes()) {
private RelationPredicate source = null;
protected <N extends Node> N cache(N node, N replacement) {
if (replacement instanceof Formula) {
if (source==null) {
final Node nsource = annotated.sourceOf(node);
if (replacement!=nsource)
sources.put(replacement, nsource);
} else {
sources.put(replacement, source);
}
}
return super.cache(node, replacement);
}
public Formula visit(RelationPredicate pred) {
Formula ret = lookup(pred);
if (ret!=null) return ret;
source = pred;
if (simplified.containsKey(pred)) {
ret = simplified.get(pred).accept(this);
} else {
ret = pred.toConstraints().accept(this);
}
source = null;
return cache(pred, ret);
}
};
return annotate(annotated.node().accept(inliner), sources);
}
/**
* Constructor for ASTRewriteAnalyzer.
* <p>The given options cannot be null.</p>
*
* @param content the content of the compilation unit to rewrite.
* @param lineInfo line information for the content of the compilation unit to rewrite.
* @param rootEdit the edit to add all generated edits to
* @param eventStore the event store containing the description of changes
* @param nodeInfos annotations to nodes, such as if a node is a string placeholder or a copy target
* @param comments list of comments of the compilation unit to rewrite (elements of type <code>Comment</code>) or <code>null</code>.
* @param options the current jdt.core options (formatting/compliance)
* @param extendedSourceRangeComputer the source range computer to use
* @param recoveryScannerData internal data used by {@link RecoveryScanner}
*/
public ASTRewriteAnalyzer(
char[] content,
LineInformation lineInfo,
String lineDelim,
TextEdit rootEdit,
RewriteEventStore eventStore,
NodeInfoStore nodeInfos,
List comments,
Map options,
TargetSourceRangeComputer extendedSourceRangeComputer,
RecoveryScannerData recoveryScannerData) {
this.eventStore= eventStore;
this.content= content;
this.lineInfo= lineInfo;
this.nodeInfos= nodeInfos;
this.tokenScanner= null;
this.currentEdit= rootEdit;
this.sourceCopyInfoToEdit= new IdentityHashMap();
this.sourceCopyEndNodes= new Stack();
this.formatter= new ASTRewriteFormatter(nodeInfos, eventStore, options, lineDelim);
this.extendedSourceRangeComputer = extendedSourceRangeComputer;
this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
this.options = options;
this.recoveryScannerData = recoveryScannerData;
}