/** * {@inheritDoc} */ public Visibility getVisibility() { return methodDescription.getVisibility(); }
/** * Creates a new record for an implemented method without attributes or a modifier resolver. * * @param methodDescription The implemented method. * @param byteCodeAppender The byte code appender to apply. */ public WithBody(MethodDescription methodDescription, ByteCodeAppender byteCodeAppender) { this(methodDescription, byteCodeAppender, MethodAttributeAppender.NoOp.INSTANCE, methodDescription.getVisibility()); }
/** * {@inheritDoc} */ public Visibility getVisibility() { return bridgeTarget.getVisibility(); }
/** * {@inheritDoc} */ public Visibility getVisibility() { return methodDescription.getVisibility(); } }
/** * {@inheritDoc} */ public Visibility getVisibility() { return methodDescription.getVisibility(); }
/** * Returns a prepared entry for a supplementary method. * * @param methodDescription The method to be implemented. * @return An entry for a supplementary entry that is defined by a method implementation instance. */ protected Prepared.Entry asSupplementaryEntry(MethodDescription methodDescription) { return new Prepared.Entry(handler, MethodAttributeAppender.Explicit.of(methodDescription), methodDescription, Collections.<MethodDescription.TypeToken>emptySet(), methodDescription.getVisibility(), false); }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { return new Resolved<U>(key.extend(methodDescription.asDefined(), harmonizer), methodDescription, methodDescription.getVisibility(), Resolved.NOT_MADE_VISIBLE); }
/** * Creates a new ambiguous entry if both provided entries are not considered to be a bridge of one another. * * @param key The key of the entry to be created. * @param left The left method to be considered. * @param right The right method to be considered. * @param visibility The entry's minimal visibility. * @param <Q> The type of the token of the harmonized key to determine method equality. * @return The entry representing both methods. */ protected static <Q> Entry<Q> of(Harmonized<Q> key, MethodDescription left, MethodDescription right, Visibility visibility) { visibility = visibility.expandTo(left.getVisibility()).expandTo(right.getVisibility()); return left.isBridge() ^ right.isBridge() ? new Resolved<Q>(key, left.isBridge() ? right : left, visibility, Resolved.NOT_MADE_VISIBLE) : new Ambiguous<Q>(key, new LinkedHashSet<MethodDescription>(Arrays.asList(left, right)), visibility); }
/** * {@inheritDoc} */ public Record prepend(ByteCodeAppender byteCodeAppender) { return new ForDefinedMethod.WithBody(visibilityBridge, new ByteCodeAppender.Compound(this, byteCodeAppender), attributeAppender, bridgeTarget.getVisibility()); }
/** * Creates an entry for an override where a method overrides another method within a super class. * * @param key The merged key for both methods. * @param override The method declared by the extending type, potentially a bridge method. * @param original The method that is overridden by the extending type. * @param visibility The minimal required visibility for this entry. * @param <V> The type of the harmonized key to determine method equality. * @return An entry representing the merger of both methods. */ private static <V> Entry<V> of(Harmonized<V> key, MethodDescription override, MethodDescription original, Visibility visibility) { visibility = visibility.expandTo(original.getVisibility()).expandTo(override.getVisibility()); return override.isBridge() ? new Resolved<V>(key, original, visibility, (original.getDeclaringType().getModifiers() & MADE_VISIBLE) == 0) : new Resolved<V>(key, override, visibility, NOT_MADE_VISIBLE); }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { Harmonized<U> key = this.key.extend(methodDescription.asDefined(), harmonizer); LinkedHashSet<MethodDescription> methodDescriptions = new LinkedHashSet<MethodDescription>(); TypeDescription declaringType = methodDescription.getDeclaringType().asErasure(); boolean bridge = methodDescription.isBridge(); Visibility visibility = this.visibility; for (MethodDescription extendedMethod : this.methodDescriptions) { if (extendedMethod.getDeclaringType().asErasure().equals(declaringType)) { if (extendedMethod.isBridge() ^ bridge) { methodDescriptions.add(bridge ? extendedMethod : methodDescription); } else { methodDescriptions.add(methodDescription); methodDescriptions.add(extendedMethod); } } visibility = visibility.expandTo(extendedMethod.getVisibility()); } if (methodDescriptions.isEmpty()) { return new Resolved<U>(key, methodDescription, visibility, bridge); } else if (methodDescriptions.size() == 1) { return new Resolved<U>(key, methodDescriptions.iterator().next(), visibility, Resolved.NOT_MADE_VISIBLE); } else { return new Ambiguous<U>(key, methodDescriptions, visibility); } }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { Harmonized<U> key = this.key.extend(methodDescription.asDefined(), harmonizer); Visibility visibility = this.visibility.expandTo(methodDescription.getVisibility()); return methodDescription.getDeclaringType().equals(this.methodDescription.getDeclaringType()) ? Ambiguous.of(key, methodDescription, this.methodDescription, visibility) : Resolved.of(key, methodDescription, this.methodDescription, visibility); }
for (Entry entry : entries) { if (entry.resolve(instrumentedType).matches(methodDescription)) { implementations.put(methodDescription, entry.asPreparedEntry(instrumentedType, methodDescription, methodDescription.getVisibility())); break;