Java Code Examples for org.aspectj.lang.JoinPoint#StaticPart

public void setArgumentNamesFromStringArray(String... args) {
	this.argumentNames = new String[args.length];
	for (int i = 0; i < args.length; i++) {
		this.argumentNames[i] = StringUtils.trimWhitespace(args[i]);
		if (!isVariableName(this.argumentNames[i])) {
			throw new IllegalArgumentException(
					"'argumentNames' property of AbstractAspectJAdvice contains an argument name '" +
					this.argumentNames[i] + "' that is not a valid Java identifier");
		}
	}
	if (this.argumentNames != null) {
		if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
			// May need to add implicit join point arg name...
			Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
			if (firstArgType == JoinPoint.class ||
					firstArgType == ProceedingJoinPoint.class ||
					firstArgType == JoinPoint.StaticPart.class) {
				String[] oldNames = this.argumentNames;
				this.argumentNames = new String[oldNames.length + 1];
				this.argumentNames[0] = "THIS_JOIN_POINT";
				System.arraycopy(oldNames, 0, this.argumentNames, 1, oldNames.length);
			}
		}
	}
}
 

@Profiled(
   logFailuresSeparately = true,
   tag = "{$1}.TIPSystemIntegrationModuleImpl#registerData",
   logger = "org.perf4j.TimingLogger_Executor"
)
public String registerData(byte[] singleMessage, String tipId, boolean requestPatientSignature, ThreeStateBoolean patientConsent) throws IntegrationModuleException {
   JoinPoint.StaticPart var10000 = ajc$tjp_2;
   Object[] var18 = new Object[]{singleMessage, tipId, Conversions.booleanObject(requestPatientSignature), patientConsent};
   JoinPoint var17 = Factory.makeJP(var10000, this, this, (Object[])var18);
   TimingAspect var20 = TimingAspect.aspectOf();
   Object[] var19 = new Object[]{this, singleMessage, tipId, Conversions.booleanObject(requestPatientSignature), patientConsent, var17};
   ProceedingJoinPoint var10001 = (new TIPSystemIntegrationModuleImpl$AjcClosure5(var19)).linkClosureAndJoinPoint(69648);
   Annotation var10002 = ajc$anno$2;
   if (ajc$anno$2 == null) {
      var10002 = ajc$anno$2 = TIPSystemIntegrationModuleImpl.class.getDeclaredMethod("registerData", byte[].class, String.class, Boolean.TYPE, ThreeStateBoolean.class).getAnnotation(Profiled.class);
   }

   return (String)var20.doPerfLogging(var10001, (Profiled)var10002);
}
 

/**
 * This is an advice which will be used after the construction of an object.
 *
 * @param thisObject
 * @param jp
 *            The static information about this joint point.
 */
// HINT: This may be logged multiple times due to super constructor calls...
@AfterReturning("monitoredConstructor() && this(thisObject) && notWithinKieker()")
public void afterConstruction(final Object thisObject, final JoinPoint.StaticPart jp) {
	if (!CTRLINST.isMonitoringEnabled()) {
		return;
	}
	final Signature signature = jp.getSignature();
	if (!CTRLINST.isProbeActivated(this.signatureToLongString(signature))) {
		return;
	}
	// common fields
	TraceMetadata trace = TRACEREGISTRY.getTrace();
	final boolean newTrace = trace == null;
	if (newTrace) {
		trace = TRACEREGISTRY.registerTrace();
		CTRLINST.newMonitoringRecord(trace);
	}
	final ConstructionEvent crecord = new ConstructionEvent(TIME.getTime(), trace.getTraceId(), trace.getNextOrderId(), signature.getDeclaringTypeName(),
			System.identityHashCode(thisObject));
	CTRLINST.newMonitoringRecord(crecord);
}
 

public void write(byte[] b, int off, int len, JoinPoint.StaticPart jp) throws IOException {
    DiskResource.Write.starting(this, len, jp, true);
    try {
        super.write(b, off, len);
    } finally {
        DiskResource.Write.finished(this, len, jp, true);
    }
}
 

public int read(byte[] b, int off, int len, JoinPoint.StaticPart jp) throws IOException {
    Read.starting(in, jp);
    int numRead = 0;
    try {
        return numRead = in.read(b, off, len);
    } finally {
        Read.finished(in, numRead, jp);
    }
}
 

public void write(byte[] b, JoinPoint.StaticPart jp) throws IOException {
    DiskResource.Write.starting(this, b.length, jp, true);
    try {
        super.write(b);
    } finally {
        DiskResource.Write.finished(this, b.length, jp, true);
    }
}
 

public int read(JoinPoint.StaticPart jp, byte[] b, int off, int len) throws IOException {
    DiskResource.Read.starting(this, len, jp, true);
    int numRead = 0;
    try {
        return numRead = super.read(b, off, len);
    } finally {
        DiskResource.Read.finished(this, numRead, jp, true);
    }
}
 

/** Called to indicate that a method such as run() or call() has begun. Due to subclassing and wrapping, this might
 * be called multiple times. Only the first invocation manipulates the baggage */
public void BeginExecution(JoinPoint.StaticPart jp) {
    // Only the first invocation manipulates the baggage
    if (reentry_count++ == 0) {
        XTraceReport.entering(jp);
        baggage = Baggage.swap(baggage);
        XTraceReport.left(jp);
    }
}
 

public void close(JoinPoint.StaticPart jp) throws IOException {
    DiskResource.Close.starting(this, jp, true);
    try {
        super.close();
    } finally {
        DiskResource.Close.finished(this, jp, true);
    }
}
 

public void save(JoinPoint.StaticPart joinPoint) {
    logSources.set(joinPoint);
}
 

@Override
public Object start(JoinPoint.StaticPart label) {
    return NOOP;
}
 

@Override
public JoinPoint.StaticPart getStaticPart() {
	return this;
}
 

@Override
public TimerContext start(JoinPoint.StaticPart jp) {
    return new TimerContext(jp);
}
 

public void needsJoinPointStaticPart(JoinPoint.StaticPart tjpsp) {
	this.collaborator.needsJoinPointStaticPart(tjpsp.getSignature().getName());
}
 

public FileInputStreamWrapper(FileDescriptor fdObj, JoinPoint.StaticPart jp) {
    super(fdObj);
    this.creator = jp;
}
 

@Override
public Split start(JoinPoint.StaticPart jp) {
    return SimonManager.getStopwatch(cleanSpaces(jp.toString())).start();
}
 

public void release(long request_hrt, long acquire_hrt, long release_hrt, JoinPoint.StaticPart jp) {
    if (aggregator.enabled())
        aggregator.finished(op, Retro.getTenant(), release_hrt - acquire_hrt, release_hrt - request_hrt);
    if (xtrace.valid())
        xtrace.log(jp, rel, "Operation", rel, "LockID", lockid, "LockRequest", request_hrt, "LockAcquire", acquire_hrt);
}
 

@Override
public Timer start(JoinPoint.StaticPart jp) {
    return metrics.timer(name(jp.toString()));
}
 

public static void acquiring(Object lock, JoinPoint.StaticPart jp) {
    if (AGGREGATION_ENABLED)
        LocalResources.getLockAggregator(lockName(lock, jp)).requesting(Retro.getTenant());
    CPUTracking.pauseTracking();
}
 

/**
 * @param jp The pointcut from the @Around advice that was intercepted.
 * @return A label suitable for a monitoring/timer label.  It is a convenience method and need not be
 * used to create the monitor
 */

public static String getLabel(JoinPoint.StaticPart jp) {
    return jp.toString();
}