All Packages from ch.ethz.inf.* to ch.ethz.prose.*

Home >> All >> ch >> ethz

•

Package Samples:

• ch.ethz.prose
• ch.ethz.prose.crosscut
• ch.ethz.prose.engine
• ch.ethz.prose.filter
• ch.ethz.prose.query
• ch.ethz.inf.iks.jvmai.jvmdi
• ch.ethz.jvmai
• ch.ethz.prose.tools

Classes:

• AbstractCrosscut: Interface AbstractCrosscut is a Crosscut implementation together with a filtering mechanism for both join-point requests and join-point events. Every AbstractCrosscut owns a PointFilter . A specializer is a strategy-object used for filtering event requests. A Crosscut is used to generate a crosscut request, that is, a collection of join-point requests(Method createRequest ). Upon the first usage of a crosscut, the crosscut selects a number of classes in the current virtual machine or maybe all (default), and then generates for every potential point inside these classes (e.g. for all method entries, ...
• McutAdvice: The McutAdvice encapsulates the transformation of the join-point data (e.g., target, stack parameters) to the types required to execute the UserDefinedMCSignature of this crosscut. The execute method does this job. An McutAdvice object contains all the data needed for the advice method invocation : An array of objects containing the arguments of the method being currently invoked ( stackArgs ). The this object (if existent, that is, if the invoked method is not static) is the first argument. the number of valid arguments the UserDefinedMCSignature object describing the static information about ...
• AspectInterfaceImpl: About Interface AspectInterfaceImpl represents the aspect-interface to the jvmai-system. It's needed for initialization of the jvmai-system, management of joinpoint-watches and for enable or disable event-notification. An instance of this interface can be obtained by calling the method getAspectInterface() of a jvmai-provider (class DebuggerProvider ). Implementation The implementation of this aspect interface is based on the debugger interface of the JVM. To receive notifications from the JVM, it uses the native code available in this class. Bugs The JVMDI is not consistent over serveral J2SDK ...
• SignedAspect: Class SignedAspect is a wrapper for an Aspect contained in a SignedObject. Thus it is possible to verify the signer of the extension before it is used. For security reason, this class is (and has to be) declared final At construction, the public and private keys passed as KeyPair are not checked for being a valid pair and the private key is not stored for later use. Only an explicit call to verifyExtension does check the public key stored. The signing algorithm to use is deduced by the algorithm type of the public key: if the public key is of type "DSA" then the algorithm "SHA1withDSA" is used, ...
• Crosscut: User perspective If you want to use crosscuts, than you have to understand two things: how to write advices how to use point-cutters. Read the documentation for MethodCut , GetCut etc to understand these issues. Developer perspective Class Crosscut defines an object which can create CrosscutRequests . A crosscut request defines a crosscut as a set of join point requests together with actions to be performed when the events corresponding to the crosscut it defines are triggered. A crosscut is also a JointPointListener . According to the contract provided by JoinPointManager an crosscut expects to ...
• ProsePermission: The class ProsePermission is used for access control of critical parts in the RUNES system. The names recognized and their semantics can be seen in the following list, to specify all names, one can use the wildcard "*". registerListener: guards the creation of breakpoints startupExtensionSystem: if granted, ProseSystem.startup will be performed privileged under the the restrictions of ProseSystem only. This permission should simplify the Java security policy definition, as only ProseSystem needs several fine grained permissions, and all classes that need to start runes can do with the ProsePermission ...
• JoinPointManager: Class JoinPointManagerImpl defines implements two of the basic methods JoinPointManager . Subclasses of AbstractJoinPointManager should define only the link between registering event requests and the proper notification. They should use the notifyListeners method in order to notify the listeners of an event that this event occured, and invoke handleExceptions to handle notification exceptions. By providing an implementation of handleExceptions with a different handleExceptions method, subclasses may change the policy for exception handling. All implementations of AbstractJoinPointManager should ...
• ProseSystem: Class ProseSystem represents the user view of the system. It allows to start and stop prose, and to get access to an code AspectManager Users program aspects and they will insert them into the system using the insertExtension and withdrawExtension methods of the extension manager. This class is also used for bootstrapping the system. Before using the extension system, users of this class (eventually applications) will have to call ProseSystem.startup(); Another way to start this system happens over the RootComponent module. this will setup the system, according to special system properties too, ...
• MethodCut: Class MethodCut represents a crosscut. Such a crosscut defines a pattern (for matching specific join-points) and a method to be executed. Users must subclass MethodCut . There are two main modalities for subclassing: The tipical way (normal user) Define exactly one method (e.g., METHOD_ARGS(Bar thisO,Baz param1) ). This method is both the advice action to be executed and it defines a pattern. Thus, just entries and exits of invocations of the form Bar.*(Baz) will be considered join-points of this crosscut. This crosscut defines a crosscut for all entry- and exit- points of the matched methods. ...
• JoinPointKinds: Class JoinPointKinds contains the masks and kinds for join-points. The mapping should be as follows: KIND_CODE_JP MASK_CODE_JP KIND_METHOD_ENTRY_JP MASK_CODE_JP | MASK_METHOD_ENTRY_JP MASK_METHOD_EXIT_JP MASK_CODE_JP | MASK_METHOD_EXIT_JP KIND_FIELD_ACCESS_JP MASK_CODE_JP | MASK_FIELD_JP | MASK_FIELD_ACCESS_JP KIND_FIELD_MODIFICATION_JP MASK_CODE_JP |MASK_FIELD_JP | MASK_FIELD_MODIFICATION_JP KIND_EXCEPTION_THROW_ARGS_JP MASK_CODE_JP | MASK_EXCEPTION_THROW_ARGS_JP KIND_EXCEPTION_CATCH_ARGS_JP MASK_CODE_JP | MASK_EXCEPTION_CATCH_ARGS_JP //angy
• JoinPointHook: Interface JoinPointHook represents a listener for jvmai-events. An aspect-interface is needed to register an instance of JoinPointHook and to set (and clear) watches on joinpoints. Methods of this interface are called by the aspect-interface whenever a joinpoint with a registered watch is reached or a class has been loaded into the virtual machine. Execution of the thread releasing this events is stopped until this methods have been processed. Joinpoint related methods receive an instance of a subclass of JoinPoint containing information about the joinpoint itself. This instance can then be used ...
• JoinPoint: Abstract class JoinPoint is the base-class for a set of JoinPoint-classes. Instances of this classes contain information about a joinpoint which has been reached during execution. The callback-methods in JoinPointHook receive such instances as arguments. They can then be used to retrieve additional information about the state of the VM when this join-point has been reached (e.g. local variables, name of the method currently beeing executed ...) Important : Use only JoinPoint-objects provided by a JoinPointHook-method. Do not create them on your own Notice : In addition to the data created by the ...
• DefaultAspect: Class DefaultAspect provides a declarative way to define an extension. For example, the following code class MyExtension extends DefaultAspect { Crosscut c1 = new MethodCut() { public void METHOD_ARGS(ANY thisO,REST params) {} } Crosscut c2 = new MethodCut{} { public void adviceMethod(Object thisO, Object[] parms){} }.specializeWith( ( MethodS.BEFORE1) .AND ( MethodS.named("Foo")) ); } would produce an extension which returns a list of two crosscuts c1 and c2 .
• SignaturePattern: Every Crosscut contains a method to be executed when a join-point is hit. In the case of MethodCut objects, the SignaturePattern has three roles: The pattern role: through a special signature, define matches for the target class, and for the parameters of the methods belonging to the target. The method finder role: determine which method o of the crosscut must be ivoked upon a hit join-point. The optimization role: to cathegorize the signature of the advice method, such that the subsequent execution of the advice method is efficient. The categorization is currently performed according to the SIGNATURE__XXX ...
• MethodCutSignaturePattern: Every Crosscut contains a method to be executed when a join-point is hit. In the case of MethodCut objects, the advice method has three roles: The pattern role: through a special signature, define matches for the target class, and for the parameters of the methods belonging to the target. The method finder role: determine which method o of the crosscut must be ivoked upon a hit join-point. The optimization role: to cathegorize the signature of the advice method, such that the subsequent execution of the advice method is efficient. The categorization is currently performed according to the SIGNATURE__XXX ...
• PointCutter: Class PointCutter is an abstract implementation of PointFilter which additionaly defines two operators AND , resp. OR that allow the construction of PointFilter objects via combination of existing specializer instances. Expected Use the following construction should be legal: PointFilter x = (new MethodEntries( ) ) .AND (new MethodNanmes("*Foo") ) Subclasses of PointCutter are mandated to implement a toString method of their own which describes in an executive way their name.
• CatchCut: Class CatchCut represents a crosscut which cuts across all points belonging to all classes in the local VM where exceptions are catch. There are two ways of using this crosscut: override the convenience methods exceptionThrowAdvice and exceptionCatchAdvice if you do not want to deal with the reflective part of join-points. override the joinPointAdvice methods and define void-bodies for exceptionThrowAdvice and exceptionCatchAdvice . This second case is recomended only if you need the last bit of speed out of the system.
• ControlFlow: Class ControlFlow encapsulates thread local information needed by the jvmai. Each thread will be associated via the ThreadLocalVariable AspectInterfaceImpl.cflows with an instance of ControlFlow . With this, the need for joinpoints when they are needed is elimiated (hence no garbage collection artificially incurred by this JVMAI implementation. The control flow contains AT LEAST a pointer to a join-point object of each kind. The thread-local join-points must be instantiated such that they all point to a JoinPointContext object which, again, belongs to this controlflow.
• AspectManager: Interface AspectManager allows weaving and unweaving of aspects. An aspect manager can be obtained as a singleton from ProseSystem In the whole ProseSystem there are exactly two ExtensionManagers. the extension manager or current extension manager the test extension manager The test aspect manager is not attached to the VM (aspect woven do not execute advice). The test aspect manager behaves like the normal aspect manager but no events are reported to it, so i.e. it can be used to test an aspect before the insertion with the real aspect manager.
• RootComponent: Class RootComponent looks for properties called "ch.ethz.prose.ESSystem.X", where X is 0,1,2,..; If this property is defined and represents a class name which has two static methods with no parameters called startup and teardown then the startup method is called for this class. These methods should only throw SystemStartupException or SystemTeardownException respectively. The class specified in the property has to implement the interface Component .
• Provider: Class Provider builds the connection between the jvmai-system and the user-application. Every virtual machine (better: every jvmai-implementation) implements a provider. Method getProvider is used to get an instace of a provider specified by a classname. This provider connects to the jvmai-implementation and tries to get references to the aspect- and info-interface. Applications can then retrieve this references by calling getAspectInterface() and getInfoInterface() .
• ThrowCut: Class ThrowCut is a crosscut which cuts exception throws The advice method is THROW_ARGS . The only argument of THROW_ARGS is the thrown exception (or none). The join-point where the advice method is executted depend on: the signature of THROW_ARGS the value returned by pointCutter . Within an advice method, the thisJoinPoint() method can be called to obtain a reference to the currently executing join-point.
• FieldEventIntegrationTest: JUnit testcase. This is an integration test (black box) and tests the functionality of the classes FieldAccessRequestImpl fieldModificationRequestImpl FieldSignatureImpl FieldAccessEventImpl FieldModificationEventImpl (FieldEventImpl) by accessing them through the following interfaces only: FieldAccessRequest FieldModificationRequest FieldAccessEvent FieldModificationEvent
• CompositePointFilter: Interface CompositePointFilter must (or can) be implemented by PointFilters which are composed out of sub-PointFilters. For instance, a PointFilter may be a AND combination of two other PointFilters. A composite PointFilter is a shallow container. That is, one of the members might be a CompositePointFilter itself, meaning that the sub-sub-components should not be returned as part of the memberPointFilters result.
• Wildcard: Interface Wildcard is a placeholder for serveral classes or class lists at a time. All classes implementing wildcard will have to provide a default constructor! This is the expected way to use wildcards: if yourwildcard extends Wildcard , then ask your wildcard whether it is assignable from something else using: yourwildcard.newInstance().isAssignableFrom(String.class)

Home | Contact Us | Privacy Policy | Terms of Service