Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

jac.aspects.* (385)jac.core.* (105)jac.dist.* (2)
jac.ide.* (114)jac.lib.* (5)jac.samples.* (43)
jac.util.* (33)jac.wrappers.* (6)jackbot.plugin.* (4)
jackbot.scripting.* (9)jacomma.examples.* (4)jacomma.icm.* (82)
jacomma.platform.* (23)jacomma.util.* (16)

Package Samples:

jac.ide.diagrams: This package contains the implementation of the JAC's IDE: UMLAF (for UML A spectual F actory).  
jac.aspects.gui.web.html: Provides a simple and generic GUI (Graphical User Interface) aspect generating HTML pages.  
jac.aspects.distribution.bootstrap: Provides a highly configurable set of aspects to distribute JAC applications.  
jac.core.dist.corba: Provides JAC system core classes for distribution and remote communication.  
jac.core.dist: Provides JAC system core classes for distribution and remote communication.  
jac.core.dist.rmi: Provides JAC system core classes for distribution and remote communication.  
jac.aspects.gui.reports: Provides a simple and generic GUI (Graphical User Interface) aspect.  
jac.aspects.gui.web: Provides a simple and generic GUI (Graphical User Interface) aspect.  
jac.util.ant: Provides some useful classes for JAC.  
jac.util.res: Provides some useful classes for JAC.  
jac.core.dist.utils: Provides JAC system core classes.  
jac.core.rtti: Provides JAC system core classes.  
jac.core: Provides JAC system core classes.  
jackbot.plugin.cheddarbot
jackbot.plugin
jackbot.scripting.ecma
jackbot.scripting
jacomma.examples
jacomma.icm.type
jacomma.icm.io

Classes:

MethodPointcut: This class can be used by JAC aspect components to easily define a set of method points on the base program that the aspects will use to modify its behavior. A method pointcut is defined through four pointcut expressions. For the moment, these pointcut expressions are a simple extension of regular expressions -- in an EMACS_LISP syntax (see the GNU-regexp tutorial) that can be combined with the && operator (in this case all the regexps must match) or the || operator (in this case, only one regexp must match). Before a regexp, you can use the ! (not) operator to inverse the matching. Depending on ...
InputSequence: This class allows a GUI programmer to create input sequences to ask the user to fill a set of parameters when invoking a method. By default, when invoking a method through the GUI, an InputWrapper opens a dialog to fill the parameters values when needed. If an input sequence is attached to this method (see GuiAC.setInputSequence ), then the input wrappers will ask for the parameters using several input dialogs, each one corresponding to a step of the input sequence. Defining a new input sequence is done by concretizing this class. For instance, the following class defines a sequence with two steps ...
AbstractServer: This abstract class provides the bases to build a server for clients that implement the Jac Thinclient Protocol (JTP). The JTP defines 6 requests. All of them takes as a first parameter the session ID (sid) that must be unique for each client. viewRequest(sid,jid) : allows the client to open a view on an object called "jid" within the accessed JAC container updateRequest(sid,jid,fieldValues) : allows the client to updates an object state refreshRequest(sid) : allows the client to refresh the current view newRequest(sid,className) : allows the client to instantiate a new object of the given class ...
Jac: This class runs a JAC program by using a Javassist loader customized with a JacLoader user classpath. Use the following command to run MyApp.main() with arg1, ... : % java jac.core.Jac [options] app.jac arg1, ... where 'app.jac' is a JAC application descriptor where options are: -r (release): JAC displays the release number -v (verbose): the JAC class loader is set to verbose -d (debug) : the JAC class loader is set to debugging mode -c (clean) : JAC cleans the tempory classes directory (previously created with 'write' option) -w (write) : the JAC class loader writes on disk all the translated ...
ACParser: This class parses the *.acc files. The *.acc files are the Aspect Component Configuration files. The are used to configure the aspect components when they are woven to an application. Each application must define one configuration file for each aspect they want to use. For the moment, the syntax of a configuration file is very simple and allow the programmer that uses an existing aspect to invoke a set of public methods taking strings or string arrays as parameters on the configured aspect. For instance, if the authentication aspect has the following configuration interface: public class AuthenticationAC ...
ReplicationGroup: This class is a high-level class that allows the programer to easily create replication groups. In the JAC terminology, a replication group is a set of objects of the same class and name that are located on several remote containers (defined by the replication group topology). The set of replicas are put on consistency with a consistency protocol that can be of various forms. A consistency protocol is defined by its class (wich is a subclass of ConsistencyWrapper and that implements the core protocol interactions) and by its knowledge graph (i.e. the set of replicas known by a given replica of ...
ObjectRepository: This class allows the JAC applications to access objects that are managed within the current VM or that can be defined outside of it by the currently woven aspects. By default, the object repository methods only return the JAC objects that are accessible through the JacObject.getObject methods. However, since it upcalls the ACManager.whenGetObjects() method, all the aspect components can change the returned object set. As typical examples: the persistence aspects may load objects that correspond to the get filter so that the application can see the objects stored in the database the owning aspect ...
CacheWrapper: CacheWrapper implements a wrapper that caches the wrappee methods results so that it can avoid the wrappee computations. It can improve performances of complex computations. Please make sure to use the rigth wrapping method. For example, if you have a Matrix class: public class Matrix { invert(); ... } An instance of Matrix must be wrapped with stateCache since the result depends on the matrix state: CacheWrapper cw = new CacheWrapper(); a_matrix.wrap(cw, "stateCache", "invert"); However, when the state of the matrix is modified, the cache should be cleared since its values are not valid anymore. ...
UserAC: This aspect handles users within an application. Any class of the application can be declared as a user representation. The aspect configurator should then declare which are the fields of this class that corresponds to the user's id (that is used to login) and to the password (not required). Users can then be bounded to profiles that define what are the elements of the application that have the right to access or not. A profile has a list of rules associated to it. When the aspect needs to know if a user with a given profile is allowed to acess resource, it inspects the rules of the profile in ...
LimiterWrapper: LimiterWrapper implements a wrapper that tests a counter value before calling the wrappee object. If the counter is not with the max and min limits, it raises the LimiterException Use this wrapper as follows: LimiterWrapper lw = new LimiterWrapper(0, 100); a_stack.wrap(lw, "inc", "push"); a_stack.wrap(lw, "dec", "pop"); a_stack.wrap(lw, "testMax", "push"); a_stack.wrap(lw, "testMin", "pop"); Where a_stack is an instance of a class Stack . When wrapping the stack, it will raise a LimiterException if a push is done and that the counter is greater or equal to 100 or if a pop is done and that the counter ...
MethodItem: This class defines a meta item that corresponds to the java.lang.reflect.Method meta element. In addition to the java.lang.reflect classical features, this RTTI method element is able to tell if a method is a setter, a getter, or more generally speaking, a state modifier for a given field of the object it belongs to. And, if this field is a collection (an array, a list or a map), then this meta element is able to tell if the method it represents adds or removes elements to or from this collection. It also provides to introspection features for references on Jac objects. For the moment, default ...
FloodControlIRCClient: Extends IRCClient and adds support for writing to the IRC server with flood control. Flood control is implemented using a seperate thread to actually send messages to the server. The ircWrite() method does not write to the server immediately, instead adding the message to a queue of outgoing messages. It then wakes up the send thread to send the message, in order to minimize latency. The flood control thread assigns a weight value to every message sent, and adds that value to an internal counter. If the counter passes some threshold, then the message is not sent. Every second, another thread decrements ...
RMIRemoteContainerStub: RMIRemoteContainerStub acts as a client stub to access a remote container. RMIRemoteContainerStub holds a RMIRemoteContainer_Stub instance. This is the client stub of the remote RMIRemoteContainer object that owns as a delegate the container that is to be accessed. Note: what we need is an instance of something that extends RemoteContainer. But we can't have an object that is both a client stub for a remote RMI object and a RemoteContainer (no multiple inheritance in Java). So we implemented this delegating scheme where: RMIRemoteContainerStub (which is a RemoteContainer) delegates its job to a ...
TableSorter: A sorter for TableModels. The sorter has a model (conforming to TableModel) and itself implements TableModel. TableSorter does not store or copy the data in the TableModel, instead it maintains an array of integers which it keeps the same size as the number of rows in its model. When the model changes it notifies the sorter that something has changed eg. "rowsAdded" so that its internal array of integers can be reallocated. As requests are made of the sorter (like getValueAt(row, col) it redirects them to its model via the mapping array. That way the TableSorter appears to hold another copy of ...
CORBARemoteContainerStub: CORBARemoteContainerStub acts as a client stub to access a remote container. CORBARemoteContainerStub holds a CORBARemoteContainerInterf instance. This is the client stub of the remote CORBARemoteContainer object that owns as a delegate the container that is to be accessed. Note: what we need is an instance of something that extends RemoteContainer. But we can't have an object that is both a client stub for a remote CORBA object and a RemoteContainer (no multiple inheritance in Java). So we implemented this delegating scheme where: CORBARemoteContainerStub (which is a RemoteContainer) delegates ...
Application: This class represents the JAC applications. Before it is actually started, each application must define a name, some path informations, and a set of aspect configurations (one for each aspect the application needs to use) by instantiating and configuring this class. Then, the system registers the new application instance into the application repository of the system. At a user-level, an application configuration is described in application descriptor files (*.acc). A typical application descriptor is: // file myApp.acc applicationName: myApp lauchingClass: myPath.Run aspects: \ rtti rtti.acc true ...
Wrapper: This class is the root class for all the wrappers. A wrapper is part of a collaboration point when one or several of its methods wrap a base program object (a wrappee). The set of wrappers (methods) that wrap a wrappee (method) it called a wrapping (method) chain. When a method call occurs on a wrappee, the system creates a new collaboration point in the current collaboration and all the wrappers are sequentially called. A given wrapper passes the hand to the next wrapper (or to the wrappee if last) by explicitly calling the proceed() method. For futher details about wrapping semantics, see the ...
LoadtimeRTTI: This class defines the super class for all the meta items whithin the rtti aspect. A meta item encapsulates a java.lang.reflect item so that the user of this item can add extra informations (attributes). Typically this feature can be used by an aspect to tag an element of the model to react to this tag later on. Examples: A persistence aspect can tag some field persistent, add methods that change the object states even if they do not fit naming conventions... A GUI can tag a given field to be invisible or a class to be displayed by a special view (eg a given Swing component)...
MetaItem: This class defines the super class for all the meta items whithin the rtti aspect. A meta item encapsulates a java.lang.reflect item so that the user of this item can add extra informations (attributes). Typically this feature can be used by an aspect to tag an element of the model to react to this tag later on. Examples: A persistence aspect can tag some field persistent, add methods that change the object states even if they do not fit naming conventions... A GUI can tag a given field to be invisible or a class to be displayed by a special view (eg a given Swing component)...
MetaItemDelegate: This class defines the super class for all the meta items whithin the rtti aspect. A meta item encapsulates a java.lang.reflect item so that the user of this item can add extra informations (attributes). Typically this feature can be used by an aspect to tag an element of the model to react to this tag later on. Examples: A persistence aspect can tag some field persistent, add methods that change the object states even if they do not fit naming conventions... A GUI can tag a given field to be invisible or a class to be displayed by a special view (eg a given Swing component)...
AssociationsAC: This aspect manages associations. If two relations are declared to constitue an association, modifications on one relation are refelected in the other. For instance, if you have a Customer class and an Order class : ,----------. 1 n ,-------. | Customer |--------| Order | `----------' `-------' You can declare an association made of Cutomer.orders and Order.customer, so that setting the cutomer of an order will automatically add this order in the customer's list of orders. And vice-versa. Associations are declared within the RTTI aspect.
JacObjectInputStream: JacObjectInputStream is used to read JAC objects from an input stream during a deserialization process. This stream is used when deserializing an array of bytes with JacObject.deserialize() . All the objects that are not serialized JAC objects are deserialized with the default procedure. When a serialized JAC object is encountered, a whenDeserialized event is thrown on the current AC manager so that the aspect components can parametrize the deserialization process. A symetric process for serialization is implemented by JacObjectOutputStream .
OptimizedCountingWrapper: This counter must wrap the methods of which calls have to be counted. It extends the simple counting wrapper to provide 2 optimization methods when client methods call several times the method wrapped by incr . In these cases, the counter is direcly incremented by the number of times the incr method has to be called. In order to avoid redundancy, incr must not be called if incrWithArg or incrWithField have already been called. To perform this contextual test, use the before and after running wrapper methods of the aspect component.
JacObjectOutputStream: JacObjectOutputStream is used to write JAC objects into an output stream during a serialization process. This stream is used when serializing a JAC object into an array of bytes when calling JacObject.serialize() . All the objects that are not JAC objects are serialized with the default procedure. When a JAC object is encountered, a whenSerialized event is thrown on the current AC manager so that the aspect components can parametrize the serialization process. A symetric process for deserialization is implemented by JacObjectInputStream .
FieldItem: This class defines a meta item that corresponds to the java.lang.reflect.Field meta element. In addition to the java.lang.reflect classical features, this RTTI method element is able to tell if a field is accessed for reading or writting by a given method. It also provides some modification methods that are aspect compliant. For the moment, default meta informations are setted by the ClassRepository class using some naming conventions. In a close future, these informations will be deduced from the class bytecodes analysis at load-time.

Home | Contact Us | Privacy Policy | Terms of Service