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

Quick Search    Search Deep

Page 1   2  
jac.aspects.associations.* (2)jac.aspects.authentication.* (15)jac.aspects.cache.* (3)
jac.aspects.confirmation.* (2)jac.aspects.distribution.* (24)jac.aspects.gui.* (260)
jac.aspects.i18n.* (1)jac.aspects.idGen.* (2)jac.aspects.integrity.* (9)
jac.aspects.naming.* (6)

Package Samples:

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.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.aspects.authentication
jac.aspects.cache
jac.aspects.confirmation
jac.aspects.distribution
jac.aspects.distribution.consistency
jac.aspects.gui
jac.aspects.gui.swing
jac.aspects.i18n
jac.aspects.integrity
jac.aspects.naming
jac.aspects.idGen
jac.aspects.associations
jac.aspects.distribution.thinclient

Classes:

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 ...
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 ...
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 ...
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 ...
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.
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.
GenericConditions: Some basic methods for constraints on fields values. Constraint methods must return a Boolean that is Boolean.TRUE if the test has been validated (passed), Boolean.FALSE else. Their parameters are : Wrappee wrappee : the the substance object (holding the field FieldItem field : the constrained field Object value : the proposed future value of the field (can be refused by the contraint Object[] values : some configuration params that can be used in the test
CustomizedGUI: This class allows the programmer to create simple customized GUIs. The idea is to define sub-panels that can contain views on the objects of the application. The geometric placement of the sub-panel is defined by the setSubPanesGeometry method that has to be called at contruction-time. Once the geometry is chosen, you can tell a pane to contain a view on a given object by using the setObjectForPane or the addReferenceToPane methods. This class must be subclassed by the porgrammer of a JAC application to provide a customized GUI.
CustomizedFileFilter: A convenience implementation of FileFilter that filters out all files except for those type extensions that it knows about. Extensions are of the type ".foo", which is typically found on Windows and Unix boxes, but not on Macinthosh. Case is ignored. Example - create a new filter that filerts out all files but gif and jpg image files: JFileChooser chooser = new JFileChooser(); ExampleFileFilter filter = new ExampleFileFilter( new String{"gif", "jpg"}, "JPEG & GIF Images") chooser.addChoosableFileFilter(filter); chooser.showOpenDialog(this);
BindingWrapper: This wrapper class binds an object to the actual named object by forwarder. BindingWrapper wraps the JAC object that that has not been resolved yet by the binding aspect. When a call is performed on the wrappee, the binder wrapper gets the actual JAC object that corresponds to the logical name by asking the name repository of the naming aspect. Then, it creates a forwarding wrapper to this object and replaces itself with it. The binding aspect uses the naming aspect. Do not try to use it alone.
InvokeThread: This class allows the programmer to invoke a given method in a new thread. JAC programmers should use JAC to pass some attibutes of the current thread to the new thread. Typical use: InvokeThread.run( myObject, "myMethodName", new Object[] { arg0, ...}, new String[] { attrName0, ... }, new Object[] { attrValue0, ... }, new String[] { lattrName0, ... }, new Object[] { lattrValue0, ... } );
DisplayContext: This class implements a display context. A display context contains a display (i.e. means to interact with the user and to create new view in customized vindows), and a customized view (i.e a root window of a GUI). A display context is passed in the interaction's flow so that each element of the GUI can construct the right GUI elements using the contextual factory. It is a defined as a collaboration attribute used by aspects needing to interact with the GUI (e.g. authentication, confirmation).
SessionAC: This aspect component handle the session aspect within JAC applications. The session aspects memorizes some contextual informations as users id or password and link them to the current session id (the "Session.sid" attribute in the context). If the client correctly sets this attribute for each interaction, then the session aspect restores the saved information so that the user will not have to input extra information (such as his password) for each interaction.
WeakConsistencyWrapper: This wrapper class implements a weak consistency protocol for a set of replicas. The semantics of this protocol is that the readed data can be inconsistent with the other replicas. When a write event occurs, the currently written replicas asks for the consistent state to the valid replica (the owner) and becomes itself the valid replica. This protocol ensures that the set of modifications are finally done in at least one replica.
TableMap: In a chain of data manipulators some behaviour is common. TableMap provides most of this behavour and can be subclassed by filters that only need to override a handful of specific methods. TableMap implements TableModel by routing all requests to its model, and TableModelListener by routing all events to its listeners. Inserting a TableMap which has not been subclassed into a chain of table filters should have no effect.
FieldEditor: This class defines a Swing component editor for primitive fields in objects. By default this view constructs an embedded JTextField containing the string representation of the field value. However, the field can be attributed to be displayed with a customized rendering by the GUI aspect component. When the field of an object is a collection of a reference, then other types of wiews are used.
DebuggingAC: Implements a simple debugging aspect for JAC applications. The actual functionalities of the debugging are externalized within the Debugger class. Here is a sample configuration file that steps all the methods that modify the instances of class A and B , excepted the setter for the field called f. step ".*" "A || B" "MODIFIERS && !SETTER(f)"
FieldView: This class defines a Swing component view for primitive fields in objects. By default this view constructs an embedded JLabel containing the string representation of the field value. However, the field can be attributed to be displayed with a customized rendering by the GUI aspect component. When the field of an object is a collection of a reference, then other types of wiews are used.
Actions: This class is a container of commonly used GUI actions static methods. Usually, a GUI action takes in parameter the display context. Using the context, is can then know the customized window to use to interact with the users. When an action does not take any display context, it means that it does not need any interaction with the GUI or that the display context is retrieved throught the collaboration.
DeploymentRule: A deployment rule parametrizes the deployment scheme of a set of objects identified by a regular expression. Each object that is named by the naming aspect so that it matches the regular expression will be deployed regarding the deployment rule. The deployment aspect component uses a set of deployment rules to know how to handle a newly used object.
StrongPushConsistencyWrapper: This wrapper implements a consistency protocol that forwards all the writing calls to all the replicas that are known by the wrapper. It is called "push" since the wrapper pushes the data to the other replicas. Despite this strategy is the most curently used, other strong or weak consistency strategies can be implemented by other consistency wrappers.
WebGui: This class provides a server for web clients using a thin client protocol and implements the Display interface to assume data inputs and outputs between JAC objects and web clients. This inferface is typically used by Java web clients and more specifically by servlets. The implementation provided by JAC is JacServlet .
WebDisplay: This class provides a server for web clients using a thin client protocol and implements the Display interface to assume data inputs and outputs between JAC objects and web clients. This inferface is typically used by Java web clients and more specifically by servlets. The implementation provided by JAC is JacServlet .
ViewControlWrapper: This wrapper updates the views of a given object when its state changes, that is to say when a write method is called on the wrappee. A view controller can control several views of the same wrappee at the same time. This mecanism is similar to the famous MVC design pattern. The model is the wrappee and the controller is the wrapper.

Home | Contact Us | Privacy Policy | Terms of Service