patterntesting.runtime.log.SequenceDiagramAspect.aj Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of patterntesting-rt Show documentation

PatternTesting Runtime (patterntesting-rt) is the runtime component for the PatternTesting framework. It provides the annotations and base classes for the PatternTesting testing framework (e.g. patterntesting-check, patterntesting-concurrent or patterntesting-exception) but can be also used standalone for classpath monitoring or profiling. It uses AOP and AspectJ to perform this feat.

There is a newer version: 2.4.0

Show newest version

/*
 * $Id: SequenceDiagramAspect.aj,v 1.10 2014/01/17 20:14:55 oboehm Exp $
 *
 * Copyright (c) 2013 by Oliver Boehm
 *
 * Licensed 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 orimplied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * (c)reated 06.09.2013 by oliver ([email protected])
 */

package patterntesting.runtime.log;

import org.apache.commons.lang.StringUtils;

import patterntesting.runtime.annotation.*;

/**
 * This aspect controls which code will be logged as sequence diagram.
 * 
 * @author oliver
 * @since 1.3.1 (06.09.2013)
 */
@IgnoreForSequenceDiagram
public aspect SequenceDiagramAspect extends AbstractSequenceDiagramAspect {
    
    /**
     * applicationCode() includes all methods, fields and constructors marked
     * with "@DrawSequenceDiagram".
     * 
     * Note: The AspejctJ classes and JDK classes are excluded. I.e.
     * classes from org.aspectj and java will be not part of the generated
     * sequence diagram for two reasons:
     * 

     *  to speed up the weaving process
     *  to keep the generated sequence diagram clear
     * 
     * 
     */
    public pointcut applicationCode() :
        ((within(@DrawSequenceDiagram *..*) || markedMethods()))
        && !excludedMethods()
        && !within(@IgnoreForSequenceDiagram *..*)
        && !call(* org.aspectj..*.*(..))
        && !call(* java..*.*(..))
        && !call(org.aspectj..*.new(..))
        && !call(java..*.new(..))
        ;
    
    private pointcut drawCalls() : 
        call(@DrawSequenceDiagram *..*.new(..))
        || call(@DrawSequenceDiagram * *..*.*(..))
        ;

    private pointcut drawExecution() :
        execution(@DrawSequenceDiagram *..*.new(..))
        || execution(@DrawSequenceDiagram * *..*.*(..))
        ;
    
    private pointcut markedMethods() :
        cflow(drawCalls())
        || withincode(@DrawSequenceDiagram *..*.new(..))
        || withincode(@DrawSequenceDiagram * *..*.*(..))
        ;
    
    private pointcut excludedMethods() :
        execution(@IgnoreForSequenceDiagram *..*.new(..))
        || execution(@IgnoreForSequenceDiagram * *..*.*(..));

    before(DrawSequenceDiagram a) : drawExecution() && @annotation(a) {
        if (StringUtils.isEmpty(a.value())) {
            addToDiagram(thisJoinPoint);
        } else {
            startDiagram(a);
        }
    }
    
    after(DrawSequenceDiagram a) : drawExecution() && @annotation(a) {
        if (StringUtils.isNotEmpty(a.value())) {
            closeDiagram();
        }
    }

}