Class MemberSubstitution

    • Field Detail

      • methodGraphCompiler

        private final MethodGraph.Compiler methodGraphCompiler
        The method graph compiler to use.
      • strict

        private final boolean strict
        true if the method processing should be strict where an exception is raised if a member cannot be found.
    • Constructor Detail

      • MemberSubstitution

        protected MemberSubstitution​(boolean strict)
        Creates a default member substitution.
        Parameters:
        strict - true if the method processing should be strict where an exception is raised if a member cannot be found.
      • MemberSubstitution

        protected MemberSubstitution​(MethodGraph.Compiler methodGraphCompiler,
                                     MemberSubstitution.TypePoolResolver typePoolResolver,
                                     boolean strict,
                                     MemberSubstitution.Replacement.Factory replacementFactory)
        Creates a new member substitution.
        Parameters:
        methodGraphCompiler - The method graph compiler to use.
        typePoolResolver - The type pool resolver to use.
        strict - true if the method processing should be strict where an exception is raised if a member cannot be found.
        replacementFactory - The replacement factory to use.
    • Method Detail

      • strict

        public static MemberSubstitution strict()
        Creates a member substitution that requires the resolution of all fields and methods that are referenced within a method body. Doing so, this component raises an exception if any member cannot be resolved what makes this component unusable when facing optional types.
        Returns:
        A strict member substitution.
      • relaxed

        public static MemberSubstitution relaxed()
        Creates a member substitution that skips any unresolvable fields or methods that are referenced within a method body. Using a relaxed member substitution, methods containing optional types are supported. In the process, it is however possible that misconfigurations of this component remain undiscovered.
        Returns:
        A relaxed member substitution.
      • element

        public MemberSubstitution.WithoutSpecification element​(ElementMatcher<? super ByteCodeElement> matcher)
        Substitutes any interaction with a field or method that matches the given matcher.
        Parameters:
        matcher - The matcher to determine what access to byte code elements to substitute.
        Returns:
        A specification that allows to determine how to substitute any interaction with byte code elements that match the supplied matcher.
      • constructor

        public MemberSubstitution.WithoutSpecification constructor​(ElementMatcher<? super MethodDescription> matcher)
        Substitutes any constructor invocation that matches the given matcher.
        Parameters:
        matcher - The matcher to determine what constructors to substitute.
        Returns:
        A specification that allows to determine how to substitute any constructor invocations that match the supplied matcher.
      • invokable

        public MemberSubstitution.WithoutSpecification invokable​(ElementMatcher<? super MethodDescription> matcher)
        Substitutes any method or constructor invocation that matches the given matcher.
        Parameters:
        matcher - The matcher to determine what method or constructors to substitute.
        Returns:
        A specification that allows to determine how to substitute any constructor invocations that match the supplied matcher.
      • with

        public MemberSubstitution with​(MethodGraph.Compiler methodGraphCompiler)
        Specifies the use of a specific method graph compiler for the resolution of virtual methods.
        Parameters:
        methodGraphCompiler - The method graph compiler to use.
        Returns:
        A new member substitution that is equal to this but uses the specified method graph compiler.
      • with

        public MemberSubstitution with​(MemberSubstitution.TypePoolResolver typePoolResolver)
        Specifies a type pool resolver to be used for locating members.
        Parameters:
        typePoolResolver - The type pool resolver to use.
        Returns:
        A new instance of this member substitution that uses the supplied type pool resolver.
      • on

        public AsmVisitorWrapper.ForDeclaredMethods on​(ElementMatcher<? super MethodDescription> matcher)
        Applies this member substitution to any method that matches the supplied matcher.
        Parameters:
        matcher - The matcher to determine this substitutions application.
        Returns:
        An ASM visitor wrapper that applies all specified substitutions for any matched method.
      • wrap

        public org.objectweb.asm.MethodVisitor wrap​(TypeDescription instrumentedType,
                                                    MethodDescription instrumentedMethod,
                                                    org.objectweb.asm.MethodVisitor methodVisitor,
                                                    Implementation.Context implementationContext,
                                                    TypePool typePool,
                                                    int writerFlags,
                                                    int readerFlags)
        Wraps a method visitor.
        Specified by:
        wrap in interface AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper
        Parameters:
        instrumentedType - The instrumented type.
        instrumentedMethod - The method that is currently being defined.
        methodVisitor - The original field visitor that defines the given method.
        implementationContext - The implementation context to use.
        typePool - The type pool to use.
        writerFlags - The ASM ClassWriter reader flags to consider.
        readerFlags - The ASM ClassReader reader flags to consider.
        Returns:
        The wrapped method visitor.